CareerCup

In C++, supporting numbers > 9.

#include <string>
#include <iostream>
#include <sstream>
#include <stack>

std::string IntToString(int nValue)
{
    std::string result;
    std::ostringstream convert;
    convert << nValue;
    result = convert.str();
    return result;
}

int StringToInt(std::string str)
{
    int nResult;
    if (!(std::istringstream(str) >> nResult))
        nResult = 0;
    return nResult;
}

int Calculate(const std::string& formula)
{
    std::stack<std::string> stack;

    for (int i = 0; i < formula.length(); i++)
    {
        // We add a number
        if (formula[i] != '*' 
            && formula[i] != '+')
        {
            std::string number;
            while (i < formula.length() 
                && formula[i] != '+' 
                && formula[i] != '*')
            {
                number = number + formula[i];
                i++;
            }
            i--;
            // Check if prev operation is multiply
            if (!stack.empty() && stack.top() == "*")
            {
                stack.pop();
                int nb1 = StringToInt(stack.top());
                stack.pop();
                int result = nb1 * StringToInt(number);
                stack.push(IntToString(result));
            }
            else
                stack.push(number);
        }
        else if (formula[i] == '*')
        {
            std::string operand(1, formula[i]);
            stack.push(operand);
        }
    }

    // Just add all remaining numbers on the stack together
    int result = 0;

    while (!stack.empty())
    {
        result += StringToInt(stack.top());
        stack.pop();
    }
    return result;
}

int main(int argc, const char * argv[]) {
    /* Calculation */
    std::string formula = "555+8*2";

    std::cout << Calculate(formula) << std::endl;
}

#include <string>
#include <iostream>

bool IsNumberOrDigit(char c)
{
    return ((c >= '0' && c <= '9') 
        || (c >= 'a' && c <= 'z')
        || (c >= 'A' && c <= 'Z'));
}

bool SameCharacters(char c1, char c2)
{
    return (c1 == c2 
        || (c1 >= 'a' && c1 <= 'z' && c2 >= 'A' && c2 <= 'Z' && c1 == c2 + 32)
        || (c1 >= 'A' && c1 <= 'Z' && c2 >= 'a' && c2 <= 'z' && c2 == c1 + 32));
}

bool IsPalindrome(const std::string &haystack)
{
    bool isPalindrome = true;
    int i, j;

    if (haystack.length() != 0)
    {
        i = 0;
        j = haystack.size() - 1;
        while (i < j)
        {
            while (i < j && !IsNumberOrDigit(haystack[i]))
                i++;
            while (i < j && !IsNumberOrDigit(haystack[j]))
                j--;
            if (IsNumberOrDigit(haystack[i]) && IsNumberOrDigit(haystack[j]) && !SameCharacters(haystack[i], haystack[j]))
            {
                isPalindrome = false;
                break;
            }
            else
            {
                i++;
                j--;
            }
        }
    }
    return isPalindrome;
}

int main(int argc, const char * argv[]) {
    /* IsPalindrome */

    std::string haystack = "A man, a plan, a canal, panama!";

    std::cout << IsPalindrome(haystack) << std::endl;
    return 0;
}

C++ with recursion:

#include <vector>
#include <string>
#include <iostream>

bool FindNeedleInHaystack(std::vector<char> needle, const std::string &haystack, int startHay, std::string combination)
{
    std::vector<char> needleCopy(needle);
    for (int i = startHay; i < haystack.length(); i++)
    {
        for (int j = 0; j < needle.size(); j++)
        {
            if (needle[j] == haystack[i])
            {
                if (needle.size() == 1)
                {
                    std::cout << combination + haystack[i] << std::endl;
                    return true;
                }
                needleCopy.erase(needleCopy.begin()+j);
                if (FindNeedleInHaystack(needleCopy, haystack, i + 1, combination + haystack[i]))
                    return true;
                needleCopy = needle;
                break;
            }
        }
        if (startHay > 0)
            return false;
    }
    return false;
}

int main(int argc, const char * argv[]) {
    std::vector<char> needle = {'a', 'b', 'c'};
    std::string haystack = "abbcbcbbbcabb";

    FindNeedleInHaystack(needle, haystack, 0, "");

    return 0;
}

#include <iostream>

class Node
{
public:
    Node(int nValue): nValue(nValue), pNext(0)
    {};

    Node(int nValue, Node *pNext): nValue(nValue), pNext(pNext)
    {};

    int nValue;
    Node *pNext;
};

void PrintList(Node *pNode)
{
    while (pNode)
    {
        std::cout << pNode->nValue << std::endl;
        pNode = pNode->pNext;
    }
}

void ReverseList(Node *pNode)
{
    Node *pCurrent = 0;
    Node *pNext = 0;

    while (pNode)
    {
        // Storing the next of current node
        pNext = pNode->pNext;
        // If current was already set, it means it's not the first node -> we need to change the node->next to current (which is actually previous node)
        if (pCurrent)
        {
            pNode->pNext = pCurrent;
        }
        else
        {
            // In this case, this is first node
            pNode->pNext = 0;
        }
        pCurrent = pNode;
        pNode = pNext;
    }
}

int main(int argc, const char * argv[]) {
    Node *a = new Node(1);
    Node *b = new Node(2, a);
    Node *c = new Node(3, b);
    Node *d = new Node(4, c);

    // Print list before
    std::cout << "From D:" << std::endl;
    PrintList(d);
    std::cout << "From A:" << std::endl;
    PrintList(a);

    // Reverse linked list in O(1) memory
    ReverseList(d);

    // Print list after
    std::cout << "From D:" << std::endl;
    PrintList(d);
    std::cout << "From A:" << std::endl;
    PrintList(a);
    
    delete d;
    delete c;
    delete b;
    delete a;
    return 0;
}