Example

With \(n=5\), the problem could look like this:

This is only a shorthand for:
\(
\begin{align}
&1 \cdot x_1 &= 3 \\
&2 \cdot x_1 + 1 \cdot x_2 &= 1\\
&7 \cdot x_1 + 1 \cdot x_2 + 1 \cdot x_3 &= 4\\
&8 \cdot x_1 + 2 \cdot x_2 + 8 \cdot x_3 + 1 \cdot x_4 &= 1\\
&1 \cdot x_1 + 8 \cdot x_2 + 2 \cdot x_3 + 8 \cdot x_4 + 1 \cdot x_5 &= 5
\end{align}
\)

This is easy to solve, isn’t it?

First step: Solve for \(x_1\)

First you see that \(x_1 = 3\). Now you replace every occurence of \(x_1\) in the system of equations above:

Now you make the multiplications and remove the first trivial line.

Second step: update

Get the constant factors to the right side of the equations:
\(
\begin{align}
&1 \cdot x_2 &= 1-6=-5\\
&1 \cdot x_2 + 1 \cdot x_3 &= 4-21=-17\\
&2 \cdot x_2 + 8 \cdot x_3 + 1 \cdot x_4 &= 1-24=-23\\
&8 \cdot x_2 + 2 \cdot x_3 + 8 \cdot x_4 + 1 \cdot x_5 &= 5-3=2
\end{align}
\)

You can now easily see that you’re in the same situation as in the first step! Next you will solve for \(x_2\), then for \(x_3, x_4\) and finally for \(x_5\).

Python straightforward algorithm

#!/usr/bin/env python
# -*- coding: utf-8 -*-

def solveUnipotentLowerTriangularMatrix(L, b):
    x = [0] * len(b)
    for step in range(0, len(b)):
        x[step] = b[step]
        for row in range(0, len(b)):
            b[row] = b[row] - L[row][step]*x[step]
    return x

if __name__ == "__main__":
    L = [[1, 0, 0, 0, 0],
         [2, 1, 0, 0, 0],
         [7, 1, 1, 0, 0],
         [8, 2, 8, 1, 0],
         [1, 8, 2, 8, 1]]
    b =  [3, 1, 4, 1, 5]

    print(solveUnipotentLowerTriangularMatrix(L, b))

Pretty easy, isn’t it? But can we even do better?

Even better algorithm

Yes, we can!

Take a look at what’s happening when row = 0 in line 9. We make a step that is not necessary. Also, we can take the space of b to store x!

#!/usr/bin/env python
# -*- coding: utf-8 -*-

def solveUnipotentLowerTriangularMatrix(L, b):
    for step in range(0, len(b)):
        for row in range(step+1, len(b)):
            b[row] -= L[row][step]*b[step]

if __name__ == "__main__":
    L = [[1, 0, 0, 0, 0],
         [2, 1, 0, 0, 0],
         [7, 1, 1, 0, 0],
         [8, 2, 8, 1, 0],
         [1, 8, 2, 8, 1]]
    b =  [3, 1, 4, 1, 5]

    solveUnipotentLowerTriangularMatrix(L, b)
    print(b)

Now it looks super clean, doesn’t it

Keep in mind that you have to store L and b if you need the values after you’ve applied this algorithm.
This is the reason why there here. This algorithm “returns” its value by manipulating b.

Time complexity

I’ll analyze the second algorithm.

Let’s assume that line 7 takes \(c\) operations and \(n\) is the size of \(L \in \mathbb{R}^{n \times n}\).

Then we would have a total of

Space complexity

Well, thats simple: \(\mathcal{O}(1)\)!

The post Solving equations of unipotent lower triangular matrices appeared first on Martin Thoma.

Click to create new green dots.
Ctrl+Click to create new blue dots.

When the circle has exactly the same number of blue / green dots in it, it will be green.

See also

One interesting setting for k=2

• Voronoi diagram
• K-nearset neighbor
• k-means clustering

The post k-nearest-neighbor clustering – an interactive example appeared first on Martin Thoma.

The Collatz sequences \((c^n_i)\) of a number \(n \in \mathbb{N}_{> 0}\) is defined like this:

So the sequence \((c^n_{i})\) is defined as:

You can define a directed graph \(G=(V, E)\) like this:

I will call this the Collatz graph.

Collatz conjecture

The Collatz conjecture was not (dis)proved by now. This is astonishing, as it was proposed in 1937 and I think it is very easy to understand.

We also don’t know if the Collatz graph is connected. When it is not connected, it could be that one sequence \((c^n_i)\) goes to infinity or that there is another circle (\(4,2,1,4\) is a circle in the Collatz graph).

Small \(n\)

When you go through all possible Collatz sequences with \(n \in 1, \dots, 15\), this is what you get:

A graph for all Collatz sequences [latex](c^n_i)[/latex] with [latex]n\leq15[/latex]

This image was created with the following Python script:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Based on: http://en.wikipedia.org/wiki/File:Collatz-graph-all-30-no27.svg

def f(n):
    if n % 2 == 0:
        return n / 2
    else:
        return 3*n + 1

def writeDotfile(filename, limit, explored):
    dotfile = file(filename, 'w')

    dotfile.write('digraph {\n')
    dotfile.write('node[style=filled,color=".7 .3 1.0"];\n')
    dotfile.write('1\n')
    dotfile.write('node[style=filled,color=".95 .1 1"];\n')
    #dotfile.write('size="15,8";\n')

    for n in range(2, limit):
        while n not in explored:
            dotfile.write(str(n) + ' -> ')
            explored.add(n)
            n = f(n)
        dotfile.write(str(n) + ';\n')
    dotfile.write('}\n')

def createPng(dotfile, base, program):
    import os
    command = program + " -Tsvg " + dotfile + " -o " + base + ".svg"
    print("Execute command: %s" % command)
    os.system(command)

    command = "inkscape "+base+".svg"+" -w 512 --export-png="+base+".png"
    print("Execute command: %s" % command)
    os.system(command)

if __name__ == "__main__":
    import argparse
 
    parser = argparse.ArgumentParser(
        description="Graph for small Collatz sequences"
    )
    parser.add_argument("-f", "--file", dest="filename",
                        default="collatz-graph.gv",
                        help="write dot-FILE", metavar="FILE")
    parser.add_argument("-p", "--program", dest="program",
                  help="dot, neato, twopi, circo, fdp, sfdp, osage", 
                  metavar="PROGRAM", default="dot")
    parser.add_argument("-n", 
                      dest="limit", default=20, type=int, 
                      help="limit")
    args = parser.parse_args()
    
    writeDotfile(args.filename, args.limit, set([1]))
    import os
    createPng(args.filename, os.path.splitext(args.filename)[0], args.program)

called like this:

python small-numbers.py -n 15 -p fdp

\(n=27\)

\(n=27\) is an enourmously long sequence:

Collatz sequence [latex]c^{27}_i[/latex]

It was created with pgfplots:

\documentclass[varwidth=true, border=2pt]{standalone}
\usepackage[margin=2.5cm]{geometry} %layout

\usepackage{pgfplots}

\begin{document}
\begin{tikzpicture}
    \begin{axis}[
            axis x line=middle,
            axis y line=middle,
            enlarge y limits=true,
            scaled y ticks = false,
            width=15cm, height=8cm, % size of the image
            grid = major,
            grid style={dashed, gray!30},
            ylabel=$c^{27}_i$,
            xlabel=$i$,
            legend style={at={(0.1,-0.1)}, anchor=north}
         ]
          \addplot[sharp plot, mark=x, blue] table [x=steps, y=n, col sep=comma] {../collatz27.csv};
    \end{axis}
\end{tikzpicture}
\end{document}

How long are Collatz sequences?

I’ve been interested in the question how long Collatz sequences are. Of course, they will be longer when \(n\) is bigger. But how does the choice of \(n\) influence the number of steps it takes until you reach \(c^n_i = 1\)?

I’ve tested all Collatz sequences with \(n \leq 10,000,000\). This is the result:

Collatz sequence steps

For every hexagon, you check how many datapoints \((n,steps)\) you have there. This leads to the count. As you can see, step numbers from 50-120 are very common, the rest is very uncommon. The number of steps increases very slow.

The data was created as a 116.9 MB csv file with this C++ code:

#include <iostream>
#include <string>
#include <map>
#include <vector>
#include <climits> // get maximum value of unsigned long long
#include <cstdlib> // exit

#define SURPRESS_OUTPUT true
#define SHOW_DICT_CREATION false
 
using namespace std;

struct element {
    /** What is the next collatz number? */
    unsigned long long next;
    
    /** How many steps does it take until you reach 1? */
    unsigned long long steps;
};

map<unsigned long long, struct element> collatz;

unsigned long long CRITICAL_VALUE = (ULLONG_MAX-1) / 3;

unsigned long long maxAddFromOneEntry = 0;
unsigned long long maxEntry = 0;
unsigned long long maxStepsToOne = 0;
unsigned long long saveULong = 0;

/** n >= 1 */
unsigned long long nextCollatz(unsigned long long n) {
    if (n%2 == 0) {
        return n/2;
    } else {
        if (n >= CRITICAL_VALUE) {
            cerr << "Critical value is: " << CRITICAL_VALUE << endl;
            cerr << "n is: " << n << endl;
            cerr << "saveULong is: " << saveULong << endl;
            exit(1);
        }
        return 3*n+1;
    }
}

void insertCollatz(unsigned long long i){
    if (collatz.find(i) == collatz.end()) {
        if (SHOW_DICT_CREATION && !SURPRESS_OUTPUT) {
            cout << i << " is not in collatz:" << endl;
        }

        // i is not in collatz
        vector<unsigned long long> steps;
        unsigned long long current = i;
        unsigned long long next = nextCollatz(current);
        while(collatz.find(current) == collatz.end()) {
            steps.push_back(current);
            current = next;
            next = nextCollatz(current);
        }

        if (steps.size() > maxAddFromOneEntry) {
            maxAddFromOneEntry = steps.size();
        }

        vector<unsigned long long>::reverse_iterator it;
        for(it=steps.rbegin(); it != steps.rend(); it++){
            struct element el;
            el.next = current;
            el.steps = collatz[current].steps + 1;
            collatz[*it] = el;

            if (el.steps > maxStepsToOne) {
                maxStepsToOne = el.steps;
            }

            if (*it > maxEntry) {
                maxEntry = *it;
            }

            current = *it;

            if (SHOW_DICT_CREATION && !SURPRESS_OUTPUT) {
                cout << "\tinserted " << *it << "->" << el.next << endl;
            }
        }

        return;
    } else if (SHOW_DICT_CREATION && !SURPRESS_OUTPUT) {
        cout << i << " was already in collatz." << endl;
    }
}

void printCollatz() {
    for(map<unsigned long long, struct element>::iterator it=collatz.begin(); 
        it!=collatz.end(); ++it) {
        unsigned long long next = (*it).first;
        while(next != 1) {
            cout << next << "->";
            next = collatz[next].next;
        }
        cout << 1 << endl;
    }
}

void printSteps(unsigned long long max) {
    cout << "n,steps" << endl;
    for(unsigned long long i=1;i<=max;i++) {
        cout << i << "," << collatz[i].steps << endl;
    }
}

int main(int argc, char* argv[]) {
    struct element e;
    e.next = 4;
    e.steps = 0;
    collatz[1] = e;

    unsigned long long maxCollatz = (unsigned long long) atoi(argv[1]);
 
    for (unsigned long long i = 2; i <= maxCollatz; i++) {
        insertCollatz(i);
        saveULong = i;
        if (i % 1000000 == 0) {
            cerr << i << endl;
        }
    }

    cerr << "maxAddFromOneEntry: " << maxAddFromOneEntry << endl;
    cerr << "maxStepsToOne: " << maxStepsToOne << endl;
    cerr << "maxEntry: " << maxEntry << endl;
    cerr << "entries: " << collatz.size() << endl;
    
    //printCollatz();
    printSteps(maxCollatz);

    return 0;
}

Then I’ve processed it with R:

R -f analyze.R

analyze.R:

library(ggplot2)
memory.limit(4000)

mydata = read.csv("/home/moose/Downloads/algorithms/collatz/steps.csv")

# Prepare data
p<-ggplot(mydata, aes ( x=n,y=steps ))

p<-p + geom_hex(bins=30)
p<-p + opts(panel.background = theme_rect(fill='white', colour='white'))

# This will save the result in a pdf file called Rplots.pdf
p

And finally, I’ve converted it to png:

inkscape Rplots.pdf -w 512 --export-png=collatz-sequence-steps.png

I’ve explained this a bit more detailed on StackExchange.

Maximum in sequence

In the following plot you can see \(n \in 1, \dots, 10,000,000\) on the \(x\)-axis and the maximum \(y = \max(\{a^n_i | i \in \mathbb{N}_{> 0}\})\):

Hexagonal binpacking plot for maximum in sequence

library(ggplot2)

mydata = read.csv("../collatz-maxNumber.csv")

# Prepare data
p<-ggplot(mydata, aes(x=n, y=maximum)) + scale_y_log10()

p<-p + geom_hex(bins=50)
p<-p + opts(panel.background = theme_rect(fill='white', colour='white'))

# This will save the result in a pdf file called Rplots.pdf
p

Execution times

Generating all Collatz sequences up to 10,000,000 items took about 50 seconds. But R needed about 10 minutes to generate images from that.

Inkscape didn’t like the heavy plot:

moose@pc07$ inkscape Rplots.pdf -w 512 --export-png=maxInSequence.png

(inkscape:26733): GLib-ERROR **: /build/buildd/glib2.0-2.34.1/./glib/gmem.c:165: failed to allocate 3440640 bytes
^CTrace/breakpoint trap (core dumped)

Maximum in sequence and steps

Maximum value and number of steps for n up to 10,000

Read more

• All sources of this article are on GitHub
• Dot guide, Node shapes
• R on UbuntuUsers (German)
• Project Euler 14

The post The Collatz sequence appeared first on Martin Thoma.

Here is a basic example that shows how you can use it:

#include <iostream> // cout
#include <string>

#include <map>

using namespace std;

int main() {
    map<string, string> phonebook;

    // Put some stuff in it
    phonebook["Martin"] = "(0123) 45 678";
    phonebook["Alice"] = "+(13) 37 0000";
    phonebook["Bob"]   = "+(13) 37 0000";
    phonebook["Charlie"] = "Alice";

    // Look stuff up
    cout << "The phone number of Alice is " 
         << phonebook["Alice"] << endl;

    cout << "Number of phone book entries: "
         << phonebook.size() << endl;

    // Print everything
    cout << "Iterate over all phonebook entries: " << endl;
    for(map<string,string>::iterator it=phonebook.begin(); 
        it!=phonebook.end(); ++it) {
        cout << "\t" << (*it).first << ": " << (*it).second << endl;
    }

    // Check if entry exists:
    string person = "Bob";
    cout << "Does " << person << " have a phone number ?" << endl;
    map<string,string>::iterator it = phonebook.find(person);
    if(it != phonebook.end()) {
        //element found:
        cout << "\t" << "Yes! His number is: " << it->second << endl;
    } else {
        cout << "\t" << "No." << endl;
    }
}

See also

• C++ Reference: general information and example
• Map is ordered collection (source)

The post Maps in C++ appeared first on Martin Thoma.

More information is on go-hero.net.

Consonants

A solution from nip:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

def solve(s, n):
    vowels = {'a', 'e', 'i', 'o', 'u'}
    nvalue = 0
    count = 0 # how many consecutive consonants
    pos = -1 # position of the last substring of n consonants
    for i, c in enumerate(s):
        if c in vowels:
            count = 0
        else:
            count += 1
        if count >= n:
            pos = i + 2 - n
        if pos >= 0:
            nvalue += pos
    return nvalue
 
if __name__ == "__main__":
    testcases = input()
      
    for caseNr in xrange(1, testcases+1):
        name, n = raw_input().split(" ")
        print("Case #%i: %s" % (caseNr, solve(name, int(n))))

Pogo

This is a very clever solution from xiaowuc1 (translated from Java to Python).

The idea is to calculate at first the maximum number of steps you need and then go from your target destination to the origin.

How many steps do you need?
In the \(i\) round, you will make \(i\) steps. You need at least \(x+y\) steps to get from \((0|0)\) to \((x|y)\). This means, you need to solve \(\sum_{i=1}^n i = x + y\) for \(n\). This is \(\frac{n^2 + n}{2} = x+y\). You might also need to make one extra step if the parity of \(\frac{n^2 + n}{2}\) is not the same as \(x+y\).
You can calculate this with a simple loop (see code below).

After you know the maximum number of steps, you can apply a greedy solution: Start from \((x|y)\) and always go into the direction that is farer away from the origin.

#!/usr/bin/env python
# -*- coding: utf-8 -*-

def calculateSteps(x, y):
    s = 0
    dist = abs(x) + abs(y)
    while (s**2 + s)/2 < dist or ((s**2 + s)/2)%2 != dist%2:
        s += 1
    return s
 
def solve(x,y):
    """ starting at (0|0) and going i steps, 
        how can you reach (x|y)? """   
    s = calculateSteps(x, y)
 
    solution = ""
    for i in range(s, 1-1,-1):
        if abs(x) > abs(y):
            if x > 0:
                solution += "E"
                x -= i
            else:
                solution += "W"
                x += i
        else:
            if y > 0:
                solution += "N"
                y -= i
            else:
                solution += "S"
                y += i
    return solution[::-1]

if __name__ == "__main__":
    testcases = input()
 
    for caseNr in xrange(1, testcases+1):
        x,y = raw_input().split(" ")
        x,y = int(x),int(y)
        print("Case #%i: %s" % (caseNr, solve(x,y)))

The Great Wall

The following solution is not applicable for the large input set, but it works fine for the small one:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from collections import defaultdict

def prepareTribes(tribes):
    tribeStack = []
    for tribe in tribes:
        for attackNumber in range(0, tribe["ni"]):
            tribeStack.append({
                "day" :tribe["di"]+attackNumber*tribe["delta_di"],
                "west":2*(tribe["wi"]+attackNumber*tribe["delta_pi"]),
                "east":2*(tribe["ei"]+attackNumber*tribe["delta_pi"]),
                "height":tribe["si"]+attackNumber*tribe["delta_si"]
            })
    return sorted(tribeStack, key=lambda tribe: tribe["day"])

def runAttack(wall, tribe):
    increase = []
    for i in xrange(tribe["west"], tribe["east"] + 1):
        if wall[i] < tribe["height"]: # wall-ee
            increase.append({"wallPos" : i, "height" : tribe["height"]})

    return increase

def solve(tribes):
    wall = defaultdict(int)
    tribeStack = prepareTribes(tribes)
    #for tribe in tribeStack:
    #    print tribe["day"], "[" + str(tribe["west"]) + "," + str(tribe["east"])+"]", tribe["height"]
    successes = 0
    increase = []
    for i, tribe in enumerate(tribeStack):
        increaseTmp = runAttack(wall, tribe)
        #print wall
        #print tribe
        if len(increaseTmp) > 0:
            successes += 1

        increase += increaseTmp

        if i+1==len(tribeStack) or tribeStack[i+1]["day"] > tribe["day"]:
            for el in increase:
                if wall[el["wallPos"]] < el["height"]:
                    wall[el["wallPos"]] = el["height"]
    return successes

if __name__ == "__main__":
    testcases = input()
      
    for caseNr in xrange(1, testcases+1):
        N = input() # Number of tribes attacking the wall
        tribes = []
        for tribe in range(N):
            di, ni, wi, ei, si, delta_di, delta_pi, delta_si = raw_input().split(" ")
            tribes.append({"di":int(di), # the day of the tribe's first attack
            "ni": int(ni), # the number of attacks from this tribe
            "wi": int(wi), # the westmost 
            "ei": int(ei), # and eastmost points respectively of the Wall attacked on the first attack
            "si": int(si), # the strength of the first attack
            "delta_di": int(delta_di), # the number of days between subsequent attacks by this tribe
            "delta_pi": int(delta_pi), # the distance this tribe travels to the east between subsequent attacks (if this is negative, the tribe travels to the west)
            "delta_si": int(delta_si) # the change in strength between subsequent attacks
            })
        print("Case #%i: %s" % (caseNr, solve(tribes)))

By the way, nobody has solved the large input set of this one with Python! But here is a Java solution.

The post Google Code Jam – Round 1C 2013 appeared first on Martin Thoma.

Connect four

Connect Four [...] is a two-player game in which the players first choose a color and then take turns dropping colored discs from the top into a seven-column, six-row vertically-suspended grid. The pieces fall straight down, occupying the next available space within the column. The object of the game is to connect four of one’s own discs of the same color next to each other vertically, horizontally, or diagonally before your opponent.

Source: Wikipedia

It looks like this:

Connect Four
Source: commons.wikimedia.org

The task

Imagine you would like to find a good strategy where to drop your disk. A simple brute-force method is to create a so called game tree. This means you go through each possibility at each situation that could occur in the game for both players.

This approach has generally two problems:

1. You have to know how to go through each situation. For connect four it is easy. Both players place their disks in turns and in every turn the current player has at most 7 possibilities. But it is impossible for games like Calvinball or Mao.
2. The game tree might be HUGE. In this case, you can have \(4,531,985,219,092 \approx 4.5 \cdot 10^{12}\) game situations (source). Even if you would need only one bit for each situation, it would require 566.5 GB!

Anyway, lets say we want to store many unique game situations. Unique means, even if you have hundreds of possible paths to get to a given game situations, you will store this game situation only once.

Implementation

First of all, I would like to mention that you can skip the source code. I’ve only included it to make it easier to understand what I’m talking about.

Lets say our game situation looks like this:

struct gamesituation {
    /** How does the board currently look like? */
    char board[BOARD_WIDTH][BOARD_HEIGHT];

    /**
     * What are the next game situations that I can reach from this 
     * board? 
     * The next[i] means that the player dropped the disc at column i
     */
    int next[7];

    /* I could use a bitfield for this ... but it would make access
     * much more inconvenient. 
     */
    unsigned char isEmpty;  // Is this gamesitatution already filled?
    unsigned char isFinished; // Is this game finished?
    unsigned char stalemate; // Was this game a stalemate?
    unsigned char winRed;   // Did red win?
    unsigned char winBlack; // Did black win?
};

You need a check if one player won:

/*
 * Check if player has won by placing a disc on (x,y). 
 * with direction (xDir, yDir)
 * @return 1 iff RED won, -1 iff BLACK won and 0 if nobody won
 */
signed char hasPlayerWon(char board[BOARD_WIDTH][BOARD_HEIGHT], 
                  int x, int y, char xDir, char yDir) {
    char color = board[x][y];

    int tokensInRow = getTokensInRow(board, color, x, y, xDir, yDir)
              + getTokensInRow(board, color, x, y, -xDir, -yDir) - 1;

    if (tokensInRow >= WINNING_NR) {
        if (color == RED) {
            return 1;
        } else if (color == BLACK) {
            return -1;
        } else {
            perror("this color doesn't / shouldn't exist\n");
            exit(1);
        }
    }

    return 0;
}

/* 
 * A new disc has been dropped. Check if this disc means that 
 * somebody won.
 * @return 1 iff RED won, -1 iff BLACK won, otherwise NOT_FINISHED
 */
int isBoardFinished(char board[BOARD_WIDTH][BOARD_HEIGHT], 
                    int x, int y) {
    signed char status;

    // check left-right
    status = hasPlayerWon(board, x, y, 1, 0);

    if (status != 0) {
        return status;
    }

    // top-down
    status = hasPlayerWon(board, x, y, 0, 1);

    if (status != 0) {
        return status;
    }

    // down-left to top-right
    status = hasPlayerWon(board, x, y, 1, 1);

    if (status != 0) {
        return status;
    }

    // top-left to down-right
    status = hasPlayerWon(board, x, y, -1, 1);

    if (status != 0) {
        return status;
    }

    return NOT_FINISHED;
}

If you need an explanation for this, you should read this article.

And you need a function that can mirror boards (to get rid of identical, but mirrored situations) and one that can compare boards:

char isSameBoard(char a[BOARD_WIDTH][BOARD_HEIGHT], 
                 char b[BOARD_WIDTH][BOARD_HEIGHT]) {
    for (int x = 0; x < BOARD_WIDTH; x++) {
        for (int y = 0; y < BOARD_HEIGHT; y++) {
            if (a[x][y] != b[x][y]) {
                return FALSE;
            }
        }
    }

    return TRUE;
}

void mirrorBoard(char board[BOARD_WIDTH][BOARD_HEIGHT],
                 char newBoard[BOARD_WIDTH][BOARD_HEIGHT]) {
    for (int x = 0; x < BOARD_WIDTH; x++) {
        for (int y = 0; y < BOARD_HEIGHT; y++) {
            newBoard[BOARD_WIDTH - x - 1][y] = board[x][y];
        }
    }
}

You need a function that makes all possible moves for the players:

/*
 * Make all possible turns that the player can make in this
 * game situation.
 */
void makeTurns(char board[BOARD_WIDTH][BOARD_HEIGHT], 
   char currentPlayer, unsigned int lastId, int recursion) {
    unsigned int insertID;
    int outcome;

    for (int column = 0; column < BOARD_WIDTH; column++) {
        // add to column
        int height = BOARD_HEIGHT - 1;

        // the disc falls down
        while (height >= 0 && board[column][height] == EMPTY) {
            height--;
        }
        height++;

        // this colum is full
        if (height == 6) {
            continue;
        }

        // place disc
        board[column][height] = currentPlayer;

        if (didBoardAlreadyOccur(board)) {
            // I've already got to this situation
            insertID = getBoardIndex(board);
            savePreviousID(insertID, lastId, column);
        } else {
            char mirrored[BOARD_WIDTH][BOARD_HEIGHT];
            mirrorBoard(board, mirrored);

            if (didBoardAlreadyOccur(mirrored)) {
                // I've already got this situation, but mirrored
                // so take care of symmetry at this point
                mirroredCounter++;
                insertID = getBoardIndex(mirrored);
                savePreviousID(insertID, lastId, column);
            } else {
                registeredSituations++;

                if (registeredSituations == MAXIMUM_SITUATIONS) {
                    giveCurrentInformation();
                    exit(MAXIMUM_SITUATIONS_REACHED_EXIT_STATUS);
                }

                if (REGISTERED_MOD > 0 &&
                    registeredSituations % REGISTERED_MOD == 0) {
                    giveCurrentInformation();
                }

                outcome = isBoardFinished(board, column, height);

                if (ABS(outcome) <= 1) {
                    // the game is finished
                    insertID = getNewIndex(board);
                    storeToDatabase(insertID, board, TRUE, outcome);
                    savePreviousID(insertID, lastId, column);
                } else {
                    // Switch players
                    if (currentPlayer == RED) {
                        currentPlayer = BLACK;
                    } else {
                        currentPlayer = RED;
                    }

                    insertID = getNewIndex(board);
                    setBoard(insertID, board);
                    savePreviousID(insertID, lastId, column);
                    char copy[BOARD_WIDTH][BOARD_HEIGHT];

                    for (int x = 0; x < BOARD_WIDTH; x++) {
                        for (int y = 0; y < BOARD_HEIGHT; y++) {
                            copy[x][y] = board[x][y];
                        }
                    }

                    makeTurns(copy, currentPlayer, insertID, 
                              recursion + 1);
                }
            }
        }
    }
}

How is this realated to hash functions?

You might have noticed a few functions that I didn’t explain by now:

• didBoardAlreadyOccur(board): Checks if a given board is stored in database.
• getBoardIndex(board): This is a function that takes a board and gives a non-negative integer which is characteristic for the given board.
• savePreviousID(insertID, lastId, column): store insertID as a possible next situation for lastId in database
• setBoard(insertID, board): Insert board into database at position insertID

How would you implement didBoardAlreadyOccur(board)? This function (or insertID) will be the slowest part of the code and will be called VERY often. So it needs to be as fast as possible.

A hash function

Most of the time you can create hash functions by mapping values to integers. In my case, I mapped the board – which is a two-dimensional char array – to one integer by thinking of it as a very long number. I think of a red disc as the digit 1, a black disc as the digit 2 and an empty field as 0:

unsigned int charToInt(char x) {
    if (x == RED) {
        return 1;
    } else if (x == BLACK) {
        return 2;
    } else {
        return 0;
    }
}

When you want to get the board number, you can get it like this:

Empty=0, red=1, yellow=2
The board number is 00000000000000000210000211210112212

For most game situations, this number will be much too big to store it in an integer. Also, we would like to get an index for our array so that we know where to store this board. The simplest solution to this problem is to calculate NUMBER % ARRAY_SIZE:

unsigned int getFirstIndex(char board[BOARD_WIDTH][BOARD_HEIGHT]) {
    unsigned int index = 0;

    for (int x = 0; x < BOARD_WIDTH; x++) {
        for (int y = 0; y < BOARD_HEIGHT; y++) {
            index += charToInt(board[x][y]) * 
                     myPow(3, ((x + y * BOARD_WIDTH) % HASH_MODULO));
        }
    }

    index = index % MAXIMUM_SITUATIONS;
    return index;
}

The function getFirstIndex maps an char Array with BOARD_WIDTH * BOARD_HEIGHT = 7 * 6 = 42 elements to an integer interval [0, MAXIMUM_SITUATIONS] = [0, 20000000]. Although I only use three values for the char array, that is \(3^{42} = 109418989131512359209 \approx 1.09 \cdot 10^{20}\). There are many game situation numbers that can never occur (e.g. two more red than black dists), but we still map a significantly larger space to [0,20000000]. You can’t change that. You can probably find (much) better mappings, but as we know that there are \(4.5 \cdot 10^{12}\) game situations, you will always have the problem that your codomain is much smaller than the domain of your hash function. That’s a fundamental problem of hash functions.

This means, you will have two board situations that map to the same hash number. This is called a “hash collision”. When you use the hash number directly as an index for your board, you will have to deal with hash collisions. Some solutions are:

• Ignoring the problem: That’s boring and not always possible (but simple).
• Linear probing
• Quadratic probing

Linear probing

The idea of linear probing is very simple:

Inserting a new item:

1. You look at the index \(i\) that your hash function gave you.
2. If this index is already full, you look at \(i+1\)
3. When you took a look at all slots of your array, you can’t insert the new item.

Searching for an already inserted item:

1. You look at the index \(i\) that your hash function gave you.
2. If \(i\) is empty, you’re ready. The item was not inserted.
3. If \(i\) is not the item you’ve searched for, you have to look at \(i+1\).
4. Keep looking at the next item until you find your searched item, you’ve looked at all items or you find an empty slot.

Deleting is complicated. You have to look at all items after the deleted one, remove them from your array and insert them again. That’s not good.

The problem of linear probing is clustering. When you have some hash values that are close together, you might get hash collisions faster. When you’ve got your first collisions, you resolve them by inserting the value close to the value where you originally wanted to save it. So you get one big cluster quite fast. When you want to insert an element in the cluster, you first have to search the end of the cluster. That’s bad for performance.

An advantage of linear probing compared to quadratic probing is that you might get a better performance due to cache effects.

Quadratic probing

The idea of quadratic probing is the same as for linear probing, but you try to fix the clustering-problem by using a clever way to search for a free spot:

where \(h\) is your hash function and \(i\) is your i-th try to find a free spot while you have \(m\) spots in total.

This one also suffers from clustering, but it’s not as bad as with linear clustering.

Double hashing

This solution could be the best one, but also the hardest one to implement correctly. You could find a free spot by using a second hash function \(h’\) like this:

BUT you have to make sure that \(Pr[h(x)=h(y) \land h'(x)=h'(y)] = \frac{1}{m^2}\)

Performance

You can use linear probing, quadratic probing and double hashing in my example and measure how many game situations get stored. The more game situations you can store in the same amount of time, the better:

Linear probing, quadratic probing and double hashing for connect four

You can see that linear probing performs much worse than quadratic probing and double hashing. When you compare quadratic probing with double hashing, there seems not to be a big difference. But note that my second hash function is almost the same as the first one. You could probably choose a better second hash function and get better results (suggestions are welcome).

Why are hash functions important?

Hash functions help you to map a big amount of data to a small space. They are important, because they are a relevant part of many datastructures. The better they are, the faster will operations on those datastructures work. Better means: Faster to compute or less collisions.

Some datastructures like this are:

• HashMap and HashTable (→ difference)
• HashSet

Final notes

Another resolution for hash collisions is creating a linked list. This means you will not suffer from clustering and you can insert in \(\mathcal{O}(1)\). But searching for an element is still in \(\mathcal{O}(n)\), where \(n\) is the number of elements that were already inserted.

Resources

You can find the code at GitHub.

The post How do hash functions work? appeared first on Martin Thoma.

More information are on go-hero.net.

Osmos

#!/usr/bin/env python
# -*- coding: utf-8 -*-

def howBigDoIget(A, motes):
    while len(motes) > 0 and A > min(motes):
        A += min(motes)
        motes.remove(min(motes))
    return A

def stepsNeededForNext(A, motes):
    m = min(motes)
    steps = 0
    if m >= 1 and A == 1:
        return 10**12
    while A <= m:
        A += (A-1)
        steps += 1
    return steps

def solve(A, motes):
    steps = 0
    A = howBigDoIget(A, motes)
    while len(motes) > 0 and A <= max(motes):
        if (stepsNeededForNext(A, motes) >= len(motes)):
            steps += len(motes)
            return steps
        else:
            A += (A-1)
        A = howBigDoIget(A, motes)
        steps += 1
    return steps
 
if __name__ == "__main__":
    testcases = input()
    for caseNr in xrange(1, testcases+1):
        A, N = map(int,raw_input().split(" "))
        motes = sorted(map(int,raw_input().split(" ")))
        copyed = motes[:]
        solution = solve(A, motes)
        if solution > N:
            solution = N
        print("Case #%i: %s" % (caseNr, solution))

Falling Diamonds

Oncee you’ve read the task, you should understand some very basic ideas:

• First of all, diamonds only fall at \(x=0\)!
• If your target coordinates are \((x,y)\), you have the same output as for \((-x,y)\), as everything is symmetric.
• You have to get a basis for your diamonds pyramid. I’ve colored the basis in yellow in the images below.
• When your target is above the ground, you can let the diamond slide down to calculate the size of the basis.

You have to get those yellow diamonds first, before you can get the orange one.

Let Diamonds slide down

Note that you don’t have to calculate a probabilty for the yellow pyramids. You get those with probability of 1.

What I’ve forgot: You should also catch the case that you can fill up the next bigger pyramid. If this is possible, you can guarantee that you will reach your target \((x,y)\).

The rest is simple math. You have \(rest\) diamonds left after you’ve build the base (yellow). Then you need \(y+1\) diamonds slide to the right side. The probability that you have exactly \(k\) hits while making \(N\) tries with a probability of 50% is \(\binom{N}{k} \cdot (\frac{1}{2})^N\). You want at least \(k\) hits, so you want \(\sum_{i=k}^N \binom{N}{i} \cdot (\frac{1}{2})^N\).

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import gmpy

""" Calculate the binomial coefficient """
def binomial(n, k):
    return gmpy.comb(n,k)

""" 
    @param N: Number of diamonds
    @param x,y: Target coordinate
    @return: possiblity, that a diamond will be at coordinate (x,y) 
"""
def solve(N, x, y):
    if x == 0:
        n = y+1
        if N >= (n*n+n)/2:
            return 1.0
        else:
            return 0.0

    # From this point, x != 0 is True

    xTmp = x + y # let target slide down

    n = xTmp-1
    baseDiamands = (n**2+n)/2

    # are there enough diamonds left after you've build the basis?
    rest = N - baseDiamands
    if rest <= 0:
        return 0.0

    # are there enough diamonds left so that you can guarantee that 
    # you will  fill up the next bigger pyramid at least to the 
    # target position?
    biggerBaseDiamonds = baseDiamands+n+2+y
    if N >= biggerBaseDiamonds:
        return 1.0

    # some math:
    # bernoulli
    prob = 0.0
    hitsNeeded = y+1

    for k in range(hitsNeeded, rest+1):
        prob += binomial(rest,k)
    
    return prob/2**rest
 
if __name__ == "__main__":
    testcases = input()
      
    for caseNr in xrange(1, testcases+1):
        N, x, y = map(int,raw_input().split(" "))
        print("Case #%i: %.9Lf" % (caseNr, solve(N, abs(x), y)))

The post Google Code Jam – Round 1B 2013 appeared first on Martin Thoma.

An diesem Artikel wird natürlich noch gearbeitet.

Behandelter Stoff

Falls hier was fehlt, könnt ihr mich gerne in den Kommentaren oder per Mail (info@martin-thoma.de) darauf aufmerksam machen. Ich bin ja mal gespannt, ob ich das bis zum Ende aktuell halte.

Definitionen

Fragen

Material

• Vorlesungswebsite
• Skript

Aufbau der Klausur

?

Übungsbetrieb

Es gibt Übungsblätter auf der Vorlesungswebsite, aber keinen Übungsschein, keine Abgaben und keine Bonuspunkte.

Termine und Klausurablauf

Datum: Freitag, den 26. Juli 2013 von 14:00 bis 16:00 Uhr
Ort: steht noch nicht fest (Stand: 29.04.2013)
Punkte: ?
Bestehensgrenze: ?
Übungsschein: Nein
Bonuspunkte: Nein

Nicht vergessen

• Studentenausweis
• Kugelschreiber

Ergebnisse

Sind noch nicht draußen (Stand: 29.04.2013)

The post Sicherheit-Klausur appeared first on Martin Thoma.

Einwegfunktionen und \(\mathcal{P} \neq \mathcal{NP}\)

Es gilt: Wenn eine Einwegfunktion \(f\) existiert, dann gilt \(\mathcal{P} \neq \mathcal{NP}\).

Warum?

Nun, angenommen es gibt eine Einwegfunktion \(f\). Dann sei die formale Sprache \(L_f\) definiert durch:

Es gilt: \(L_f \notin \mathcal{P}\), da für ein gegebenes \(y\) das zugehörige \(x\) in polynomialzeit bestimmt werden könnte (wie will man sonst prüfen, ob \(\bar x\) ein Präfix von \(x\) ist?)

Falls jemanden diese Begründung nicht ausreicht ist hier noch ein Beweis von Prof. Hofheinz (Danke!)

Beh.: \(L_f \notin \mathcal{P}\)
Bew.: durch Widerspruch
Annahme.: \(L_f \in P\)
\(\Rightarrow\) Es existiert ein Polyzeit-Algorithmus \(\mathcal{A}\) für \(L_f\), der bei Eingabe \((\bar x, y)\) entscheidet, ob ein \(x\) mit \(f(x)=y\) und Präfix \(\bar x\) existiert oder nicht. Dann können wir einen Algorithmus \(\mathcal{B}\) aus \(\mathcal{A}\) bauen, der \(f\) invertiert.

Gegeben \(y\) verfährt \(\mathcal{B}\) wie folgt:
\(\mathcal{B}\) ruft \(\mathcal{A}(0,y)\) auf und erfährt so, ob ein Urbild \(x\) von \(y\) mit Anfangsbit \(0\) existiert. Wenn ja, ruft \(\mathcal{B}\) den Algorithmus \(\mathcal{A}(00,y)\) auf, wenn nein ruft \(\mathcal{B}\) den Algorithmus \(\mathcal{A}(10,y)\) auf usw.

So wird ein Urbild \(x\) bitweise bestimmt. Ein solches \(\mathcal{B}\) findet also effizient Urbilder, im Widerspruch zur Einwegannahme über \(f \blacksquare\)

Aber: Wenn das \(x\) gegeben ist, dann ist es einfach zu zeigen, dass \(y= f(x)\) gilt und damit auch, ob \(\bar x\) ein Präfix von \(x\) ist. Damit ist \(L_f \in \mathcal{NP}\).

Damit gilt: \(L_f \in \mathcal{NP} \setminus \mathcal{P}\).
Wenn aber \(\mathcal{NP} \setminus \mathcal{P} \neq \emptyset\), dann gilt insbesondere \(\mathcal{P} \neq \mathcal{NP}\).

An dieser Stelle sollte man also einsehen, dass eine Einwegfunktion nach obiger Definition nur existieren kann, wenn \(\mathcal{P} \neq \mathcal{NP}\) gilt.

Semantische Sicherheit

Wikipedia gibt folgende Beschreibung von semantischer Sicherheit:

Ein Verschlüsselungsverfahren ist semantisch sicher, wenn jeder Angreifer jede Information, die er aus einem Chiffrat über die Nachricht ableiten kann, bereits dann ableiten kann, wenn er nur die Länge des Chiffrats kennt. Ein Chiffrat verrät also nichts über eine Nachricht als ihre Länge.

Herr Prof. Hofheinz hat folgende informelle Definition von Semantischer Sicherheit in der Vorlesung gegeben:

Hier ist

• \(M\) eine Nachricht (Message),
• \(\text{Enc(K, M)}\) die Verschlüsselung einer konkreten Nachricht \(M\) mit dem Schlüssel \(K\),
• \(\varepsilon\) eine triviale Information (ich glaube das ist z.B. die Länge des Ciphertextes) und
• \(f\) extrahiert beliebige Informationen aus dem Plaintext

Die erste Wahrscheinlichkeit bezeichnet die Möglichkeit, aus dem Ciphertext Informationen der Art \(f\) über den Plaintext \(M\) zu erhalten.
Die zweite Wahrscheinlichkeit bezeichnet die Möglichkeit „aus dem Nichts“ Informationen über eine Nachricht zu erhalten. Damit will man triviale Informationen eliminieren. Insgesamt gibt es also die Wahrscheinlichkeit an, nicht-triviale Informationen aus einer Verschlüsselten Nachricht zu erhalten. Mit effizient ist vermutlich in Polynomialzeit gemeint.

Wenn es nun mehrfach benutzbare semantisch sichere Verfahren gibt, dann kann man dieses Verfahren als Einwegfunktion nutzen. Wenn eine Einwegfunktion existiert, gilt \(\mathcal{P} \neq \mathcal{NP}\). Also folgt:

Wenn es nun mehrfach benutzbare semantisch sichere Verfahren existieren, gilt \(\mathcal{P} \neq \mathcal{NP}\). Dies ist aber eines der Millennium-Probleme und noch nicht geklärt.

The post Semantische Sicherheit appeared first on Martin Thoma.

More information might soon be on go-hero.net.

I’m too slow for Google Code Jam *sigh*. Nevertheless, here are my solutions:

Bullseye

Small

<?

function solve($r, $t) {
    $circles = 0;
    while($t >= 0) {
        $circles++;
        $t -= ($r+1)*($r+1)-$r*$r;
        $r += 2;
    }
    return floor($circles) - 1;
}

$fp = fopen ($argv[1], 'r');
$testcases = fgets ($fp);
$caseNr=0;
while($line = fgets ($fp)) {
    $caseNr++;
    $a = explode(' ', $line);
    $r = $a[0];
    $t = $a[1];
    echo "Case #$caseNr: ".solve($r, $t)."\n";

}
?>

Large

*Argh* I’ve copied the wrong equation from my pad to my computer

You basically have to solve this:
\(\begin{align}
t – \sum_{i=0}^x ((r+1+2i)^2 – (r+2i)^2) &\geq 0\\
\Leftrightarrow t – (x+1)(2x+2r+1) &\geq 0 \\
\Leftrightarrow (-2)x^2 + (2r+3)x + (t-2r-1) &\geq 0 \\
\Rightarrow x_{1,2} = 0 \Leftrightarrow x_{1,2} &= \frac{1}{-4} \cdot (-(2r+3) \pm \sqrt{(2r+3)^2-4(-2)(t-2r-1)}) \\
&= -\frac{1}{4} \cdot (-2r-3 \pm \sqrt{4r^2+12r+9+8(t-2r-1)})\\
&= -\frac{1}{4} \cdot (-2r-3 \pm \sqrt{4r^2+12r+9+8t-16r-8})\\
&= -\frac{1}{4} \cdot (-2r-3 \pm \sqrt{4r^2-4r+1+8t})\\
&= \frac{1}{4} \cdot (2r+3 \pm \sqrt{(2r-1)^2+8t})\\
&= \frac{1}{4} \cdot (2r+3 \pm \sqrt{(2r-1)^2+8t})\\
\end{align}
\)

I have to know that \(1 \leq r\) and \(1 \geq x \in \mathbb{N}\). So you have to round \(x_1, x_2\) to the nearest solution.

Did you know that Python has (in numpy) a method to calculate roots of a quadratic equation? See numpy.roots for reference.

#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
from numpy import ceil, roots
 
def check(r, t, x):
    return t-(x+1)*(2*r+2*x+1) >= 0
 
def solveFast(r, t):
    myRoots = roots((2,2*r+3,2*r+1-t))
    for i in xrange(2):
        if myRoots[i] >= 0:
            answer = int(ceil(myRoots[i])) + 1
            while not check(r, t, answer):
                answer -= 1
            return answer + 1
  
if __name__ == "__main__":
    testcases = input()
       
    for caseNr in xrange(1, testcases+1):
        line = raw_input()
        r, t = map(int, line.split(' '))
        print("Case #%i: %s" % (caseNr, solveFast(r, t)))

Good Luck

This one solves at least the first test case, but not the second one.

I love itertools

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from math import factorial
from itertools import combinations_with_replacement
import pprint
from copy import deepcopy

def mul(integers):
    s = 1
    for p in integers:
        s *= p
    return s

def merge(candidates, block):
    newCandidates = deepcopy(candidates)
    for el in set(block):
        diff = block.count(el) - newCandidates.count(el)
        for i in xrange(diff):
            newCandidates.append(el)
    return newCandidates

def canBeIn(b, candidates, N):
    merged = merge(candidates, b)
    return not (len(merged) > N)

""" 
    N: number of numbers in total that got randomly picked
    M: A_i in [2, M]
"""
def solve(N, M, products, productToBuildungs):
    candidates = []

    # Is there a simple answer?
    for p in products:
        if productToBuildungs[p][0] == 1:
            candidates = merge(candidates, productToBuildungs[p][1][0])
            if len(candidates) == N:
                return candidates

    for p in products:
        pos = filter(lambda b: canBeIn(b, candidates, N), productToBuildungs[p][1])
        if len(pos) == 1:
            candidates = merge(candidates, pos[0])

    while len(candidates) < N:
        candidates.append(2)

    return candidates

if __name__ == "__main__":
    testcases = input()
      
    for caseNr in xrange(1, testcases+1):
        print("Case #%i:" % caseNr)
        line = raw_input()
        arr = line.split(' ')
        R = int(arr[0])
        N = int(arr[1])
        M = int(arr[2])
        K = int(arr[3])

        # which products can I get
        productToBuildungs = {}
        for r in xrange(0, N+1):
            for product in combinations_with_replacement(range(2,M+1),r):
                s = mul(product)
                if s not in productToBuildungs:
                    productToBuildungs[s] = [1, [list(product)]]
                else:
                    productToBuildungs[s][0] += 1
                    productToBuildungs[s][1].append(list(product))

        for r in xrange(R):
            products = [int(el) for el in raw_input().split(' ') if int(el) != 1]
            print(''.join(map(str, sorted(solve(N, M, products, productToBuildungs)))))

The post Google Code Jam – Round 1A 2013 appeared first on Martin Thoma.