En.cppreference.com

Inconveniences of Unsigned Types in .NET

Languages like C++ come with convenient support for unsigned integer types where non-negative values make sense. std::size_t is the unsigned integer type of the sizeof and alignof operators. std::size_t is also used when indexing C++ containers.

In contrast, .NET tends to use signed integer types even where unsigned ones would be more intuitive, e.g.,

• List<T>.Count returns an Int32
• Indexing into a List<T> takes in an Int32 index

.NET is language independent. Languages like C#, F#, and Visual Basic target .NET implementations. The Common Language Specification (CLS) is the set of features that are common to all the languages. Of relevance is the fact that Byte, Int16, Int32, and Int64 are the only CLS-compliant integer types.

Given an \(N \times N\) matrix, where each of the rows and columns are sorted in ascending order, return the \(k^{th}\) smallest element in the matrix. The memory complexity must be better than \(O(N^2)\).

It’s not guaranteed that matrix[r][c] > matrix[r-1][c], so we can’t compute the row (and similarly, the column) in which the \(k^{th}\) smallest element is in.

Using a priority queue that holds the \(K\) smallest elements does not work because the memory usage is \(O(K)\), where \(K\) can be any value in \([1, N^2]\). Furthermore, that doesn’t take into account that the rows and columns are already sorted.

Problem

Given an \(M \times N\) integer array grid where grid[i][j] could be:

• 1 representing the starting square. There is exactly one starting square.
• 2 representing the ending square. There is exactly one ending square.
• 0 representing empty squares that we can walk over.
• -1 representing obstacles that we cannot walk over.

Return the number of 4-directional walks from the starting square to the ending square, that walk over every non-obstacle square exactly once.

Unscoped (or Plain or C-Style) Enumerations

Plain (or C-style) enums are entered in the same scope as the name of their enum, and implicitly convert to their integer value, e.g.

enum Color { red, green, blue };
int col = green;
Color c2 = 1; // error: invalid conversion from 'int' to 'Color' [-fpermissive]

enum CardColor { red, black }; // Error: "red" conflicts with a previous declaration

The name can be omitted if it’s not going to be used, e.g.

enum { red, green, blue };
int col = red;

.

Unnamed enums are common in code written before alternative ways of specifying integer constants, e.g.

A template is a class or a function that we can parameterize with a set of types or values.

Parameterized Types

The vector-of-doubles can be generalized to a vector-of-anything type by making it a template:

// `template<typename T>` can be read as "for all types T". Older code
// uses `template<class T>`, which is equivalent.
template<typename T>
class Vector {
 public:
  explicit Vector(int s);
  ~Vector() { delete[] elem; }

  // ... copy and move operations ...

  T& operator[](int i);               // For non-const Vectors
  const T& operator[](int i) const;   // For const Vectors
  int size() const { return sz; }

 private:
  T* elem;
  int sz;
};

A class is a user-defined type provided to represent a concept in the code of a program. Essentially, all language facilities beyond the fundamental types, operators, and statements exist to help define better class or to use them more conveniently.

Problem Statement

Write a program that will take these scrambled words from scrambled.txt, and compare them against wordlist.txt to unscramble them, e.g., sleewa unscrambles to weasel.

Solution

Pre-process wordlist.txt into a dictionary keyed by the sorted version of the anagram, e.g., weasel is keyed under aeelsw. To support multiple anagrams, the value should be a list of all strings from wordlist that share the sorted anagram. Iterating through scrambled.txt becomes a lookup operation keyed on the sorted string.