Contents

• 1 What are Bitmasks?
• 2 Bit operators
• 3 Some examples
• 4 See also

What are Bitmasks?

In computer science, a mask is data that is used for bitwise operations. Essentially it is a variable.

They are very often used in C programs.

Bit operators

These are the bit operators:

• ~ Bitwise NOT (not to be confused with Logical NOT ‘!’)
• & Bitwise AND (not to be confused with Logical AND ‘&&’)
• | Bitwise OR (again, not to be confused with Logical OR ‘||’)
• ^ Bitwise XOR
• << Bitwise left shift
• >> Bitwise right shift

This is how the operators work:

Some examples

Lets say I have any variable named “variable” with 32 bit.

Get the last bit:

return variable & 1;

Get the first bit:

return variable >> 31;

Get the bits 4 – 14 (11 bits):

return (variable  >> 4) & ((1<<11) - 1);

Getting the pow(2,11):

return 1<<11;

See also

• What does a type followed by _t (underscore-t) represent?. Jonathan Leffler, Stackoverflow.
• Why does mode_t use 4 byte?. Niklas B., Stackoverflow.

LaTeX (Tikz) animation of an eulerian path

The ideas

Draw the Graph

If you want to visualize a graph algorithm, you should first try to get the image of the graph with Tikz.
First include all packages / create the general structure of the document:

\documentclass[hyperref={pdfpagelabels=false}]{beamer}
\usepackage{lmodern}

\usepackage[utf8]{inputenc} % this is needed for german umlauts
\usepackage[ngerman]{babel} % this is needed for german umlauts
\usepackage[T1]{fontenc}    % this is needed for correct output of umlauts in pdf

\usepackage{verbatim}
\usepackage{tikz}
\usetikzlibrary{arrows,shapes}

% see http://deic.uab.es/~iblanes/beamer_gallery/index_by_theme.html
\usetheme{Frankfurt}
\usefonttheme{professionalfonts}

\begin{document}
\begin{frame}
	Your content will be here.
\end{frame}
\end{document}

Simple graphs could look like this:

\begin{figure}
	\begin{tikzpicture}[->,scale=1.8, auto,swap]
		% Draw the vertices.
		\node (a) at (0,0) {$a (this is text)$};
		\node (b) at (0,1) {$b$};
		\node (c) at (1,1) {$c$};
		\node (d) at (1,0) {$d$};
		\node (e) at (3,1) {$d$};

		% Connect vertices with edges and draw weights
		\path (a) edge node {} (b);
		\path (b) edge node {} (c);
		\path (c) edge node {} (d);
		\path (d) edge node {} (a);
	\end{tikzpicture}
\end{figure}

You should get something similar to this:

Simple example graph created with LaTeX and Tikz

Animate

Animations can be created with Tikz by working with layers. You don’t want to redraw the whole graph every time. Most of the time you want to overlay/underlay some parts of the graph. This can be achieved by declaring a new layer:

\pgfdeclarelayer{NAME}

Then you need to tell PGF which layers are to use in the next figure:

\pgfsetlayers{LAYER LIST}

The layer main should always be part of the list. Here is an example:

\pgfdeclarelayer{background}
\pgfdeclarelayer{foreground}
\pgfsetlayers{background,main,foreground}

Now the magic begins. You consecutively add frames to the layer:

	\begin{pgfonlayer}{background}
		\path<2->[draw,line width=5pt,-,red!50] (a.center) edge node {} (b.center);
		\path<10->[draw,line width=5pt,-,red!50] (b.center) edge node {} (d.center);
		\path<12->[draw,line width=5pt,-,red!50] (d.center) edge node {} (e.center);
	\end{pgfonlayer}

The number (2, 10 and 12 in this example) indicate the frame in which it should be added. This is the absolute frame, but 1 is the first frame of the figure environment!

Status quo

\documentclass[hyperref={pdfpagelabels=false}]{beamer}
\usepackage{lmodern}

\usepackage[utf8]{inputenc} % this is needed for german umlauts
\usepackage[ngerman]{babel} % this is needed for german umlauts
\usepackage[T1]{fontenc}    % this is needed for correct output of umlauts in pdf

\usepackage{verbatim}
\usepackage{tikz}
\usetikzlibrary{arrows,shapes}

% see http://deic.uab.es/~iblanes/beamer_gallery/index_by_theme.html
\usetheme{Frankfurt}
\usefonttheme{professionalfonts}

\begin{document}

\pgfdeclarelayer{background}
\pgfdeclarelayer{foreground}
\pgfsetlayers{background,main,foreground}

\begin{frame}
\begin{figure}
    \begin{tikzpicture}[->,scale=1.8, auto,swap]
        % Draw the vertices.
        \node (a) at (0,0) {$a (this is text)$};
        \node (b) at (0,1) {$b$};
        \node (c) at (1,1) {$c$};
        \node (d) at (1,0) {$d$};
		\node (e) at (3,1) {$d$};

        % Connect vertices with edges and draw weights
        \path (a) edge node {} (b);
        \path (b) edge node {} (c);
        \path (c) edge node {} (d);
        \path (d) edge node {} (a);

		\begin{pgfonlayer}{background}
			\path<2->[draw,line width=5pt,-,red!50] (a.center) edge node {} (b.center);
			\path<10->[draw,line width=5pt,-,red!50] (b.center) edge node {} (d.center);
			\path<12->[draw,line width=5pt,-,red!50] (d.center) edge node {} (e.center);
		\end{pgfonlayer}
    \end{tikzpicture}
\end{figure}
\end{frame}
\end{document}

Simplify it

You can make some definitions, e.g.:

draw,line width=5pt,-,red!50

can be replaced by

\tikzstyle{selected edge} = [draw,line width=5pt,-,red!50]

You can make loops:

	% Draw the vertices.
	\foreach \pos / \identifier / \name in {{(0,0)/a/a (this is text)},
		{(0,1)/b/b}, {(1,1)/c/c}, {(1,0)/d/d}, {(3,1)/e/d}}
		\node (\identifier) at \pos {$\name$};

The whole, working template

\documentclass[hyperref={pdfpagelabels=false}]{beamer}
\usepackage{lmodern}

\usepackage[utf8]{inputenc} % this is needed for german umlauts
\usepackage[ngerman]{babel} % this is needed for german umlauts
\usepackage[T1]{fontenc}    % this is needed for correct output of umlauts in pdf

\usepackage{verbatim}
\usepackage{tikz}
\usetikzlibrary{arrows,shapes}

% Define some styles for graphs
\tikzstyle{vertex}=[circle,fill=black!25,minimum size=20pt,inner sep=0pt]
\tikzstyle{selected vertex} = [vertex, fill=red!24]
\tikzstyle{blue vertex} = [vertex, fill=blue!24]
\tikzstyle{edge} = [draw,thick,-]
\tikzstyle{weight} = [font=\small]
\tikzstyle{selected edge} = [draw,line width=5pt,-,red!50]
\tikzstyle{ignored edge} = [draw,line width=5pt,-,black!20]

% see http://deic.uab.es/~iblanes/beamer_gallery/index_by_theme.html
\usetheme{Frankfurt}
\usefonttheme{professionalfonts}

% disables bottom navigation bar
\beamertemplatenavigationsymbolsempty

% http://tex.stackexchange.com/questions/23727/converting-beamer-slides-to-animated-images
\setbeamertemplate{navigation symbols}{}%

\begin{document}
\pgfdeclarelayer{background}
\pgfsetlayers{background,main}

\begin{frame}
	\begin{figure}
		\begin{tikzpicture}[->,scale=1.8, auto,swap]
			% Draw the vertices. First you define a list.
			\foreach \pos/\name in {{(0,0)/a}, {(0,2)/b}, {(1,2)/c},
				                    {(1,0)/d}, {(2,1)/e}, {(3,1)/f},
									{(4,2)/g}, {(5,2)/h}, {(4,0)/i},
									{(5,0)/j}}
				\node[vertex] (\name) at \pos {$\name$};

			% Connect vertices with edges and draw weights
			\foreach \source/ \dest /\pos in {a/b/, b/c/, c/d/, d/a/,
										c/e/bend left, d/e/, e/c/,
										e/f/, f/g/, f/i/,
										g/f/bend right, i/f/bend left,
										g/h/, h/j/, j/i/, i/g/}
				\path (\source) edge [\pos] node {} (\dest);

			% Start animating the edge selection.
			% For convenience we use a background layer to
			% highlight edges. This way we don't have to worry about
			% the highlighting covering weight labels.
			\begin{pgfonlayer}{background}
				\foreach \source / \dest / \fr / \pos in {d/a/1/,
						a/b/2/, b/c/3/, c/d/4/, d/e/5/, e/c/6/,
						c/e/7/bend left, e/f/8/, f/g/9/,
						g/f/10/bend right, f/i/11/, i/g/12/, g/h/13/,
						h/j/14/, j/i/15/, i/f/16/bend left}
				    \path<\fr->[selected edge] (\source.center) edge
										[\pos] node {} (\dest.center);
			\end{pgfonlayer}
		\end{tikzpicture}
	\end{figure}
	Lorem ipsum dolor sit amet, consetetur sadipscing elitr,
	sed diam nonumy eirmod tempor invidunt ut labore et dolore
	magna aliquyam erat, sed diam voluptua. At vero eos et
	accusam et.
\end{frame}
\end{document}

Resources

• TikZ and pgf: Manual for version 1.18
• TeXamples.net: Great page with many Tikz-Examples
• The beamer class

Contents

• 1 Dia
• 2 LaTeX
  • 2.1 MetaUML
• 3 See also

Dia

Creating UML diagrams with Dia works like a charm! It provides some default tools. You should simply try it. Dia is a free tool.

Take a look at these screenshots:

Create a class for a class diagram in Dia

Edit class properties in Dia

Customizing associations in Dia - adding multiplicities is so much easier in Dia than in MetaUML!

A quick example for a class diagram created with Dia

LaTeX

I only know MetaUML for creating class diagrams entirely in LaTeX. Does anybody know something different?

Of course, you can include a diagram created with Dia:

1. Export the diagram as PNG (antialized)
2. Add something like that to your tex-file: \includegraphics[width=180mm]{myDiagramm.png}

MetaUML

A MetaUML class diagram looks like that in code (saved as myMetaDiagram.mp):

input metauml;
beginfig(1);
	Class.World("World")
		   ("-age: int",
			"#ressources: List")
		   ("+sayHello(): void");

	Class.NoHuman("Human")
		   ("-birthday: Date",
			"-nickname: String",
			"-secret: String")
		   ("+code(language: Language): Program");

	leftToRight(50)(World, NoHuman);
	drawObjects(World, NoHuman);

	link(aggregation)(NoHuman.w -- World.e);
	item(iAssoc)("1")(obj.n     = .2[World.e,NoHuman.w]);
	item(iAssoc)("has >")(obj.n = .5[World.e,NoHuman.w]);
	item(iAssoc)("0..*")(obj.n  = .8[World.e,NoHuman.w]);

endfig;
end

You have to execute mpost before you can compile LaTeX. A working example is in this UML Archive.

It looks like that in your generated PDF file:

MetaUML class diagram

See also

• Wikipedia: Class diagram, Dia
• Dia: Dia und UML
• MetaUML: Tutorial, Reference and Test Suite
• Freies Magazin, Mai 2012: Astah – Kurzvorstellung des UML-Programms (German)

• Problem 1 (Diamond Inheritance):
  • Small Set: 3077/4230 users (73%)
  • Large Set: 2387/3044 users (78%)
• Problem 2 (Out of Gas):
  • Small Set: 471/766 users (61%)
  • Large Set: 73/253 users (29%)
• Problem 3 (Box Factory):
  • Small Set: 1071/1810 users (59%)
  • Large Set: 308/788 users (39%)

Diamond Inheritance

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

import psyco
psyco.full()

testcases = input()

def line2intlist(line):
	list = line.split(' ')
	numbers = [ int(x) for x in list ]
	return numbers

def getAnswer(classDict, N):
	for startPoint in xrange(1, N):
		reachable = [startPoint]
		justAppended = [startPoint]
		while len(justAppended) > 0:
			newJustAppended = []
			for node in justAppended:
				for new in classDict[node]:
					if new in reachable:
						return "Yes"
					else:
						newJustAppended.append(new)
						reachable.append(new)
			justAppended = newJustAppended
	return "No"

for i in xrange(0, testcases):
	N = input()
	classDict = {}
	for classNr in xrange(1, N+1):
		liste = line2intlist(raw_input())
		classDict[classNr] = liste[1:]
	print("Case #%i: %s" % (i+1, getAnswer(classDict, N)))

See also

• Wikipedia: Google Code Jam
• Google Code Jam Statistics

• Problem 1 (Safety in Numbers):
  • Small Set: 2695/5614 users (48%)
  • Large Set: 2016/2686 users (75%)
• Problem 2 (Tide Goes In, Tide Goes Out):
  • Small Set: 684/894 users (77%)
  • Large Set: 620/671 users (92%)
• Problem 3 (Equal Sums):
  • Small Set: 2261/2534 users (89%)
  • Large Set: 149/854 users (17%)

Safety in Numbers

I tried this approach:
X is the sum of all points given by judges. The visitors have an equal amount of points to give.
\(P_i\) is the number of total points of contestant i.
\(J_i\) is the number of points of contestant i by the judges.
\(V_i\) is the percentage of the visitors points contestant i gets.

So: \(P_i = J_i + V_i * X\)

You don’t know \(V_i\) and \(P_i\). You have to get the minimal value of \(V_i\) to guarantee that contestant \(i\) will not to be eliminated. So you have to create some kind of “worst case” for contestant i, if he gets \(V_i \cdot X\) visitor-points. The worst case is that the minimum of all remaining visitors is as high as possible. So if you think of them as players, they will always try to get a equal number of points.

If they can get an equal number of points, you can make these (in)equations:
\(average = (X – p_i)/(N-1)\)
\(p_i + V_i \cdot X \geq avg + \frac{1-V_i}{N-1} \cdot X\)
\(V_i \cdot X – \frac{1-V_i}{N-1} \cdot X \geq avg – p_i\)
\(V_i X (N-1) – (1-V_i) \cdot X \geq (N-1) \cdot (avg – p_i)\)
\(V_i X (N-1) – X +V_i \cdot X \geq (N-1) \cdot (avg – p_i)\)
\(V_i X (N-1) +V_i \cdot X \geq (N-1) \cdot (avg – p_i) + X\)
\(V_i \geq (N-1) \cdot ((avg – p_i) + X)/(X (N-1) +X)\)
\(V_i \geq (N-1) \cdot ((avg – p_i) + X)/(X ((N-1) +1))\)
\(V_i \geq \frac{N-1}{X \cdot N} \cdot (avg – p_i + X)\)

Unfortunately, its possible that the other players can’t get an equal number of points. So this approach is useless in this case.

Here is an approach with an approximation, which also works for the large input set.

#include <iostream>
#include <cstdio>
using namespace std;

int main() {

	int testcases, N, sum;
	int s[1011];

	cin >> testcases;

	for (int caseNr = 1; caseNr <= testcases; caseNr++) {
		cin >> N;

		/** the sum of all points of all contestants*/
		sum = 0;

    	for (int i = 0; i < N; i++) {
			cin >> s[i];
			sum += s[i];
		}

		printf("Case #%d:", caseNr);

		for (int contestant = 0; contestant < N; contestant++) {
			// approximate the minimum for each contestant
			double low = 0, high = 1;

			// increase the accuracy 100 times
			for (int j = 0; j < 100; j++) {
				double mid = (low + high) / 2;
				double me = s[contestant] + mid * sum;
				double remaining = 1 - mid;

				for (int k = 0; k < N && remaining > 0; k++) {
					if (k != contestant && s[k] < me) {
						// the contestant k needs at least
						// this part of all audience votes
						remaining -= (me - s[k]) / sum;
					}
				}

				if (remaining > 0) {
					low = mid;
				} else {
					high = mid;
				}
			}
			printf(" %.6lf", low * 100);
		}

		printf("\n");
	}
}

Tide Goes In, Tide Goes Out

This one could be solved with Graphs. You calculate one Graph, where every node is one cell. Every cell / node is connected to adjacent cells. Every cell has a value which is the time when you can enter them.

After you’ve created the graph, you can make something like that:

graph = createGraph(floorHeight, ceilingHeight)
endReached = False
nodesReached = []
while (not endReached):
    tmp = getMinimumAdjacentNode(graph, nodesReached)
    nodesReached.append(tmp)
return maxTime(nodesReached)

Equal Sums

A trivial solution for the small one is to try every combination. You might want to take a look at Pythonss itertools.combinations().

See also

• Wikipedia: Google Code Jam
• Google Code Jam Statistics

listings

Minimal example

LaTeX Java Source Code: listings

\documentclass[a4paper,12pt]{article}
\usepackage{amssymb} % needed for math
\usepackage{amsmath} % needed for math
\usepackage[utf8]{inputenc} % this is needed for german umlauts
\usepackage[ngerman]{babel} % this is needed for german umlauts
% this is needed for correct output of umlauts in pdf
\usepackage[T1]{fontenc}
\usepackage[margin=2.5cm]{geometry} %layout
\usepackage{listings} % needed for the inclusion of source code

% this is needed for forms and links within the text
\usepackage{hyperref}  

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% THE DOCUMENT BEGINS                      %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{document}
	\lstinputlisting[language=Java]{Othello.java}
\end{document}

My Template

If you want to customize a little bit more and if you want to get highlighted (colorized) source code, you could use the following template. It looks like this as a PDF-file.

\documentclass[a4paper,12pt]{article}
\usepackage{amssymb} % needed for math
\usepackage{amsmath} % needed for math
\usepackage[utf8]{inputenc} % this is needed for german umlauts
\usepackage[ngerman]{babel} % this is needed for german umlauts
\usepackage[T1]{fontenc}    % this is needed for correct output of umlauts in pdf
\usepackage[margin=2.5cm]{geometry} %layout
\usepackage{listings} % needed for the inclusion of source code

% the following is needed for syntax highlighting
\usepackage{color}

\definecolor{dkgreen}{rgb}{0,0.6,0}
\definecolor{gray}{rgb}{0.5,0.5,0.5}
\definecolor{mauve}{rgb}{0.58,0,0.82}

\lstset{ %
  language=Java,                  % the language of the code
  basicstyle=\footnotesize,       % the size of the fonts that are used for the code
  numbers=left,                   % where to put the line-numbers
  numberstyle=\tiny\color{gray},  % the style that is used for the line-numbers
  stepnumber=1,                   % the step between two line-numbers. If it's 1, each line
                                  % will be numbered
  numbersep=5pt,                  % how far the line-numbers are from the code
  backgroundcolor=\color{white},  % choose the background color. You must add \usepackage{color}
  showspaces=false,               % show spaces adding particular underscores
  showstringspaces=false,         % underline spaces within strings
  showtabs=false,                 % show tabs within strings adding particular underscores
  frame=single,                   % adds a frame around the code
  rulecolor=\color{black},        % if not set, the frame-color may be changed on line-breaks within not-black text (e.g. commens (green here))
  tabsize=4,                      % sets default tabsize to 2 spaces
  captionpos=b,                   % sets the caption-position to bottom
  breaklines=true,                % sets automatic line breaking
  breakatwhitespace=false,        % sets if automatic breaks should only happen at whitespace
  title=\lstname,                 % show the filename of files included with \lstinputlisting;
                                  % also try caption instead of title
  keywordstyle=\color{blue},          % keyword style
  commentstyle=\color{dkgreen},       % comment style
  stringstyle=\color{mauve},         % string literal style
  escapeinside={\%*}{*)},            % if you want to add a comment within your code
  morekeywords={*,...}               % if you want to add more keywords to the set
}

% this is needed for forms and links within the text
\usepackage{hyperref}  

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Variablen                                 						 %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\newcommand{\authorName}{Martin Thoma}
\newcommand{\tags}{\authorName, my, tags}
\title{This is the title}
\author{\authorName}
\date{\today}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% PDF Meta information                                 				 %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\hypersetup{
  pdfauthor   = {\authorName},
  pdfkeywords = {\tags},
  pdftitle    = {This is the title}
} 

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% THE DOCUMENT BEGINS             	                              	 %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{document}
	\lstinputlisting[language=Java]{Othello.java}
\end{document}

Supported Languages

The LaTeX listings package provides quite a lot of language and dialects. Each bold dialect is the default dialect:

First the interesting ones:

• Assembler (Motorola68k, x86masm)
• bash
• C (ANSI, Handel, Objective, Sharp)
• C++ (ANSI, GNU, ISO, Visual)
• Java (empty, AspectJ)
• Python
• SQL
• TeX (AlLaTeX, common, LaTeX, plain, primitive)
• XML

And the rest:
ABAP (R/2 4.3, R/2 5.0, R/3 3.1, R/3 4.6C, R/3 6.10), ACSL, Ada (2005, 83, 95), Algol (60, 68), Ant, Awk (gnu, POSIX), Basic (Visual), Caml (light, Objective), CIL, Clean, Cobol (1974, 1985, ibm), Comal 80, command.com (WinXP), Comsol, csh, Delphi, Eiffel, Elan, erlang, Euphoria, Fortran (77, 90, 95), GCL, Gnuplot, Haskell, HTML, IDL (empty, CORBA), inform, JVMIS, ksh, Lingo, Lisp (empty, Auto), Logo, make (empty, gnu), Mathematica (1.0, 3.0, 5.2), Matlab, Mercury, MetaPost, Miranda, Mizar, ML, Modula-2, MuPAD, NASTRAN, Oberon-2, OCL (decorative, OMG), Octave, Oz, Pascal (Borland6, Standard, XSC), Perl, PHP, PL/I, Plasm, PostScript, POV, Prolog, Promela, PSTricks, R, Reduce, Rexx, RSL, Ruby, S (empty, PLUS), SAS, Scilab, sh, SHELXL, Simula (67, CII, DEC, IBM), SPARQL, tcl (empty, tk), VBScript, Verilog, VHDL (empty, AMS), VRML (97), XSLT

minted

Minted needs the package pygments:

sudo apt-get install python-pygments

Example

LaTeX Java Source Code: minted

\documentclass[a4paper,12pt]{article}
\usepackage{amssymb} % needed for math
\usepackage{amsmath} % needed for math
\usepackage[utf8]{inputenc} % this is needed for german umlauts
\usepackage[ngerman]{babel} % this is needed for german umlauts
\usepackage[T1]{fontenc}    % this is needed for correct output of umlauts in pdf
\usepackage[margin=2cm]{geometry} %layout
\usepackage{minted} % needed for the inclusion of source code

\begin{document}
\renewcommand{\theFancyVerbLine}{
  \sffamily\textcolor[rgb]{0.5,0.5,0.5}{\scriptsize\arabic{FancyVerbLine}}}

\inputminted[linenos, numbersep=5pt, tabsize=4, frame=lines, label=Othello.java]{java}{Othello.java}

\end{document}

Material

All files can be found in LaTeX-Source-Code Archive.

See also

• WikiBook: LaTeX/Packages/Listings
• CTAN lisings documentation
• CTAN minted documentation

• Problem 1 (Password Problem):
  • Small Set: 3511/3851 users (91%)
  • Large Set: 2329/3376 users (69%)
• Problem 2 (Kingdom Rush):
  • Small Set: 1912/3466 users (55%)
  • Large Set: 1617/1848 users (88%)
• Problem 3 (Cruise Control):
  • Small Set: 65/312 users (21%)
  • Large Set: 22/42 users (52%)

Just as last time, you can execute these scripts by

python jam.py < A-small-practice.in > results.txt

Passwords

This works only for the small input set:

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

def line2floatlist(line):
	""" Convert integers in one line, separated by space to a
		list of integers.
	"""
	list = line.split(' ')
	numbers = [ float(x) for x in list ]
	return numbers

def prob(A, B, probabilities):
	typesMin = float('inf')
	for i in xrange(0, A + 1):
		probKorrect = 1.0
		for el in probabilities[0:(len(probabilities)-i)]:
			probKorrect *= el
		probWrong = 1.0 - probKorrect
		remainingTypes = i + (B - A + i) + 1
		remainingTypesErr = remainingTypes + B + 1
		types = probKorrect * remainingTypes \
				+ probWrong * remainingTypesErr
		#print types
		if types < typesMin:
			typesMin = types
	if (1+B+1) < typesMin:
		typesMin = (1+B+1)

	return round(typesMin , 6)
	#return typesMin

if __name__ == "__main__":
	testcases = input()

	for caseNr in xrange(0, testcases):
		A, B = raw_input().split(" ")
		A = int(A)
		B = int(B)
		probabilities = line2floatlist(raw_input())
		#print ((A+1), B)
		#print probabilities
		print("Case #%i: %.6lf" % (caseNr+1, prob(A, B, probabilities)))

Kingdom Rush

My solution works only for the small input set:

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

from copy import deepcopy

def line2intlist(line):
	""" Convert integers in one line, separated by space to a
		list of integers.
	"""
	list = line.split(' ')
	numbers = [ int(x) for x in list ]
	return numbers

def isSolvable(starDict):
	""" Is it possible to solve this one? """
	intList = []
	for index in starDict:
		wasInFor = True
		one, two = starDict[index]
		intList.append(one)
		intList.append(two)
	intList.sort()

	for levelVar in xrange(0, len(intList)):
		if levelVar < intList[levelVar]:
			return False
	return True

def king(starDict, myLevel = 0, myCompetes = 0, partially = []):
	somethingChanged = True
	while somethingChanged:
		removeList = []
		somethingChanged = False

		#all where i can do both
		for index in starDict:
			one, two = starDict[index]
			if two <= myLevel:
				removeList.append(index)
				somethingChanged = True

		#remove them
		for index in removeList:
			myCompetes += 1
			del starDict[index]
			if index in partially:
				myLevel += 1
				partially.remove(index)
			else:
				myLevel += 2

	if starDict:
		minCompetes = float('inf')
		for index in starDict:
			one, two = starDict[index]
			if one <= myLevel and (index not in partially):
				starDictTmp = deepcopy(starDict)
				partiallyTmp = deepcopy(partially)
				partiallyTmp.append(index)
				tmpCompetes = king(starDictTmp, myLevel+1,
							myCompetes+1, partiallyTmp)
				if tmpCompetes < minCompetes:
					minCompetes = tmpCompetes
		myCompetes = minCompetes
	return myCompetes

if __name__ == "__main__":
	testcases = input()

	for caseNr in xrange(0, testcases):
		levels = input()
		stars = []
		for i in xrange(0, levels):
			stars.append(line2intlist(raw_input()))

		#make stars dictionary
		starDict = {}
		level = 1
		for el in stars:
			starDict[level] = deepcopy(el)
			level += 1

		if not isSolvable(starDict):
			print("Case #%i: Too Bad" % (caseNr+1))
		else:
			print("Case #%i: %s" % (caseNr+1, king(starDict)))

Cruise Controll

Only 22 people have a perfect solution for this one.

This is the solution of royf:

import itertools
import math
import numpy

def read_word(f):
    return next(f).strip()

def read_int(f, b=10):
    return int(read_word(f), b)

def read_letters(f):
    return list(read_word(f))

def read_digits(f, b=10):
    return [int(x, b) for x in read_letters(f)]

def read_words(f, d=' '):
    return read_word(f).split(d)

def read_ints(f, b=10, d=' '):
    return [int(x, b) for x in read_words(f, d)]

def read_arr(f, R, reader=read_ints, *args, **kwargs):
    res = []
    for i in range(R):
        res.append(reader(f, *args, **kwargs))
    return res

def solve(solver, fn, out_fn=None):
    in_fn = fn + '.in'
    if out_fn is None:
        out_fn = fn + '.out'
    with open(in_fn, 'r') as fi:
        with open(out_fn, 'w') as fo:
            T = read_int(fi)
            for i in range(T):
                case = read_case(fi)
                res = solver(case)
                write_case(fo, i, res)

################################################################################

def read_case(f):
    N = read_int(f)
    Cs = []
    for i in range(N):
        (C, S, P) = read_words(f)
        Cs.append((C, int(S), int(P)))
    return (N, Cs)

def write_case(f, i, res):
    f.write('Case #%d: '%i)
    f.write('%s'%res)
    f.write('\n')

################################################################################

INF = float('inf')

import heapq

def solve_small(case):
    (N, Cs) = case
    col = []
    for i in range(N):
        (c1, s1, p1) = Cs[i]
        for j in range(i+1, N):
            (c2, s2, p2) = Cs[j]
            if s1 == s2:
                if abs(p1-p2) < 5:
                    heapq.heappush(col, (-1, True, i, j))
                continue
            t1 = (p2-p1+5)/(s1-s2)
            t2 = (p2-p1-5)/(s1-s2)
            if t1 > t2:
                (t1, t2) = (t2, t1)
            if t2 < 0:
                continue
            if t1 < 0:
                t1 = -1
            heapq.heappush(col, (t1, True, i, j))
            heapq.heappush(col, (t2, False, i, j))
    l = [None] * N
    act = []
    for i in range(N):
        act.append(set())
    cnt = 0
    while col:
        (t, c, i, j) = heapq.heappop(col)
        if c:
            act[i].add(j)
            act[j].add(i)
        else:
            act[i].remove(j)
            act[j].remove(i)
        if t == -1:
            l[i] = Cs[i][0] == 'L'
            l[j] = Cs[j][0] == 'L'
            continue
        if c:
            if l[i] is None:
                if l[j] is None:
                    l[i] = (cnt, True)
                    l[j] = (cnt, False)
                    cnt += 1
                elif l[j] is True:
                    l[i] = False
                elif l[j] is False:
                    l[i] = True
                else:
                    (k, b) = l[j]
                    l[i] = (k, not b)
            elif l[i] is True:
                if l[j] is None:
                    l[j] = False
                elif l[j] is True:
                    return t
                elif l[j] is False:
                    pass
                else:
                    (k, b) = l[j]
                    for x in range(N):
                        if isinstance(l[x], tuple) and l[x][0] == k:
                            l[x] = b != l[x][1]
            elif l[i] is False:
                if l[j] is None:
                    l[j] = True
                elif l[j] is True:
                    pass
                elif l[j] is False:
                    return t
                else:
                    (k, b) = l[j]
                    for x in range(N):
                        if isinstance(l[x], tuple) and l[x][0] == k:
                            l[x] = b == l[x][1]
            else:
                (k, b) = l[i]
                if l[j] is None:
                    l[j] = (k, not b)
                elif l[j] is True:
                    for x in range(N):
                        if isinstance(l[x], tuple) and l[x][0] == k:
                            l[x] = b != l[x][1]
                elif l[j] is False:
                    for x in range(N):
                        if isinstance(l[x], tuple) and l[x][0] == k:
                            l[x] = b == l[x][1]
                else:
                    (k_, b_) = l[j]
                    if k == k_:
                        if b == b_:
                            return t
                        else:
                            continue
                    for x in range(N):
                        if isinstance(l[x], tuple) and l[x][0] == k:
                            l[x] = (k_, not b ^ b_ ^ l[x][1])
        else: #end col
            if not act[i]:
                l[i] = None
            if not act[j]:
                l[j] = None
    return 'Possible'

solve_large = solve_small

##def solve_large(case):

DEBUG = 'i'

from run import *

See also

• Wikipedia: Google Code Jam
• Google Code Jam Statistics

Das Lastenheft könnt ihr unter Linux einfach mit folgendem Befehl erstellen, wenn ihr in diesem Ordner seid:

make

Änderungsvorschläge sind willkommen! Ich werde die hier gespeicherte Version wohl noch einige male updaten.

Siehe auch

• Softwaretechnik I, S. 36
• Beispiel der Uni Paderborn
• Jet Another SWT-I Resume, ab S. 8

Installation

Für die Installation von Java, Subversion (SVN), Eclipse und Checkstyle samt Dokumentation muss folgendes in der Konsole eingegeben werden:

sudo apt-get install openjdk-6-jre openjdk-6-jdk openjdk-6-source openjdk-6-demo openjdk-6-doc openjdk-6-jre-headless openjdk-6-jre-lib subversion libapache2-svn eclipse checkstyle checkstyle-doc

Dann werden etwa 276 MB an Archiven heruntergeladen und 662 MB an zusätzlichen Packeten installiert. Bei meiner Internetverbindung (DSL 1000 ) hat das ca 40 Minuten gedauert.

CheckStyle

Siehe eclipse-cs.sourceforge.net mit detaillierten Installationsanweisungen.

Subversive

Siehe eclipse.org: Download Suversive.
Diese Erklärung ist aber nicht so toll.

Nach der Installation und dem Neustart von Eclipse muss man das “Subversive Connector Kit” auswählen. Kurz in der Konsole

svn --version

eingeben. Bei mir ist anscheinend Subversion in der Version 1.6.12 installiert. Also wähle ich “SVN Kit 1.3.7″.

Zuerst muss man den SVN Connector installieren:

http://community.polarion.com/projects/subversive/download/eclipse/2.0/update-site/

Das macht man wie mit CheckStyle.

Dann muss man Subversive installieren:

http://download.eclipse.org/technology/subversive/0.7/update-site/

Auch hier macht man es wie mit CheckStyle.

Sobald alles klappt, sieht es etwa so aus:

Subversive plugin in Eclipse

Commit mit Subversive unter Eclipse

Grundeinstellungen

Als erstes sollte man mal auf “Window” -> “Open Perspective” -> “Java” klicken.

Siehe auch

• Ubuntu Downloads
• Oracle Java – Manuelle Installation unter Ubuntu.
• Weitere UbuntuUsers Artikel: Eclipse, Subversion
• Software Versioning Cheat Sheet (Subversion / GIT)
• Wikipedia: Eclipse, Subversion
• Wiki Books: Java Standard: Erste Schritte (habe ich NICHT gelesen! Aber für unsere Physiker ist das eventuell hilfreich.)

Rechenregeln für Determinanten

Man darf eine Zeile mit einer Konstanten a multiplizieren, muss dann aber die Determinante durch a teilen:

\(
det \begin{pmatrix}
3 & 2 & 12 & 5 \\
2 & 1 & 6 & 4 \\
2 & 0 & 2 & -3\\
2 & 2 & 7 & 4
\end{pmatrix}
\begin{array}{c} | \cdot 2 \\ | \cdot 3 \\ | \cdot 3 \\ | \cdot 3 \end{array}
= \frac{1}{2} \cdot (\frac{1}{3})^3 \cdot
det \begin{pmatrix}
6 & 4 & 24 & 10 \\
6 & 3 & 18 & 12 \\
6 & 0 & 6 & -9\\
6 & 6 & 21 & 12
\end{pmatrix}
\)

Man darf zwei Zeilen / Spalten tauschen, muss dann aber die Determinante mit (-1) multiplizieren:
\(det \begin{pmatrix}
6 & 4 & 24 & 10 \\
6 & 3 & 18 & 12 \\
6 & 0 & 6 & -9\\
6 & 6 & 21 & 12
\end{pmatrix} \begin{array}{c} \cdot \\ \cdot \\ \leftarrow \\ \leftarrow \end{array} = -
det \begin{pmatrix}
6 & 4 & 24 & 10 \\
6 & 3 & 18 & 12 \\
6 & 6 & 21 & 12 \\
6 & 0 & 6 & -9
\end{pmatrix} =
det \begin{pmatrix}
6 & 24 & 4 & 10 \\
6 & 18 & 3 & 12 \\
6 & 21 & 6 & 12 \\
6 & 6 & 0 & -9
\end{pmatrix}\)

Man darf eine Zeile mit einer Konstanten multiplizieren und auf eine beliebige andere Zeile addieren (wie beim Gauss-Verfahren)

Man darf eine Zeile und eine Spalte zugleich entfernen (Entwicklung nach Spalte / Zeile xy), muss dann aber folgendermaßen ausgleichen:
Entwicklung nach der k-ten Spalte: \(D(a_1, … , a_n) = \sum_{j=1}^{n}(-1)^{k+j}a_{jk}D_{jk}\)
Entwicklung nach der i-ten Zeile: \(det A = \sum_{k=1}^n (-1)^{i+k}a_{ik}D_{ik}\)
Direkt entfernen, ohne etwas weiteres zu beachten, kann man die Zeile, wenn in dieser Zeile nur eine 1 steht und diese 1 an einer ungeraden Spalte (1, …, n) ist.
Eine Spalte kann man direkt entfernen, wenn in der Spalte nur an einer Stelle eine 1 steht und diese 1 an einer ungeraden Zeile (1, …, n) steht.

Berechnung des charakteristischen Polynoms

Das charakteristische Polynom einer Abbildungsmatrix A ist der Wert folgender Determinanten:
\(det(\lambda \cdot E_n – A)\), wobei \(E_n\) die Einheitsmatrix ist.

Beispiel

Siehe Wikipedia.

Berechnung am PC

Mit Wolfram|Alpha kann man das charakteristische Polynom berechnen und auch direkt die Eigenwerte.

Wozu das Ganze?

An dem charakteristischem Polynom kann man direkt die Eigenwerte ablesen. Existiert eine Basis aus Eigenvektoren für den Vektorraum, dann ist eine Matrix diagonalsiierbar. Wenn eine Matrix in Diagonalform ist, dann kann man damit besonders gut rechnen.

Siehe auch

• Wikipedia: Determinante, Charakteristisches Polynom, Eigenwertproblem, Diagonalmatrix
• Skript von Herrn Prof. Dr. Leuzinger, S. 131 – 142: Determinanten.