Implementing the Chain of responsibility pattern

A chain of responsibility pattern delegates a sequence of commands to a chain of processing objects. Objects can be dynamically added to a list

Implementing the Command pattern

The command pattern is used to create objects which encapsulate behaviours and states.  This pattern is frequently needed when we want to delegate a sequence of calls with no need of explicitly knowing the parameter details or the specific methods here involved. 

Implementing the Interpreter pattern

The Interpreter is a pattern used for implementing a specialized interpreted language. The idea is to have a class for each symbol of the grammar, used for defining the Interpreter.

Implementing the Iterator pattern

The Iterator pattern is used to access all the elements of an object without exposing its internal representation. This pattern is commonly used by libraries of containers such as the STL for decoupling accesses to a specific container from its implementation.

Implementing the Mediator pattern

The Mediator allows interactions among classes with loose coupling. Each class is not required to recognize too much details of the other classes logic, which is exposed only to the mediator. Objects are not required to communicate directly anymore but they leverage the mediator, thereby reducing the coupling effects.

Implementing the Observer pattern

The Observer pattern implements the publisher/subscriber interactions, where a number of registered observer objects are informed about events produced by the publishers. This pattern is frequently used for implementing a distributed event handling system and for windows systems. 

Implementing the Strategy pattern

The Strategy pattern allows selection at run-time on specific algorithms for implementing a particular behaviour given a class of similar algorithms for that function.

Implementing the State pattern

The State pattern is used to allow an object to change his behaviour, when the internal state of the object itself is changing. For instance this pattern can be used to change the state of an object at run-time.

Implementing the Template pattern

The template pattern allows the definition of  algorithms skeleton as an abstract class, where subclasses have the responsibility of providing its concrete behaviour. The word template is not related to C++ templates.

Implementing the Visitor pattern

The Visitor pattern allows to visit an object in a hierarchical way with no need of considering internal details. In this way algorithms can be separated from the object structure on which they operate.

Given an unsigned int, swap the bits in odd and even positions

Print the binary representation of an unsigned int

Set the i-th bit

Compute whether or not an unsigned number is a power of two

Toggle the i-th bit

Unset the i-th bit

Given an unsigned number with only one bit set, find the position of this bit

Given an array of integers where all the numbers are appearing twice find the only number which appears once

Add two numbers without using arithmetic operators

Count the number of bits set in an unsigned number

Given an array of integers where all the numbers are appearing twice find the only two numbers which appears once

Multiply two numbers without using arithmetic operators

Compute the two’s complement for a given integer

Isolate the rightmost bit set to 1

Create a mask for trailing zeros

Swap two integers variables with no additional memory

Compute parity for a 32 bit number

Swap bit i and j in a 64 bit number

Convert a number from base b1 to base b2

Convert an integer to a string and a string to an integer