jfrech.com
jblog
table of contents

Slitherlink Solver

2017-02-11, post № 159

programming, Python, #2016, #puzzle, #shell

Slitherlink is a neat puzzle in which you are presented with a number matrix and the goal is to draw one connected, not interlooping line in between the cells. The number in each cell determines exactly how many line segments must be drawn around each cell (𝟢, 𝟣, 𝟤 or 𝟥). When a cell does not contain any number, the number of line segments adjacent to this cell are unrestricted.

*  *  *  *  *  *          *--*  *  *--*--*
     2  1  3              |  | 2  1| 3   |
*  *  *  *  *  *          *  *--*  *--*  *
        2  2  2           |     | 2  2| 2|
*  *  *  *  *  *          *--*  *--*  *  *
     2              ->       | 2   |  |  |
*  *  *  *  *  *          *  *--*  *--*  *
  1  3  1     1             1  3| 1     1|
*  *  *  *  *  *          *--*--*  *--*  *
  3     2     3           | 3     2|  | 3|
*  *  *  *  *  *          *--*--*--*  *--*

A sample 5x5 Slitherlink with solution.

Slitherlink was invented by the Japanese publisher Nikoli in 1989. It has many other names than “Slitherlink”, yet I prefer this descriptive name. Imagining a snake slithering along the board, seeking to link up with itself is a bit charming.

As with most of these puzzles that have simple rules and are fairly easy to work out by hand — on small scales that is —, writing a solver for them can prove to be more difficult than one may expect.

The first solving strategy I tried out was to brute force the problem. Using the Slitherlink from above as an example, there would be 5\cdot 5=25 different cells with 2\cdot 5\cdot 5+5+5=60 line segments. With each line segment either being drawn or not, there are 2^{60}\approx 1.15\cdot 10^{18} different boards to check. With one board being checked per nanosecond the solver would take \frac{2^{60}}{10^9}\approx 1.15\cdot 10^9 seconds or 𝟥𝟨.𝟧𝟨 years. Brute force is definitely not a viable way to conquer Slitherlink.

After this harsh discovery, I needed a better way to approach solving a given Slitherlink puzzle. Doing some research, I even discovered that Slitherlink is an NP-complete problem (see this paper [1] by Stefan Herting), whereby it — assuming \text{P}\neq\text{NP} — is not even possible to write a solving algorithm which takes polynomial time.
However, solving small Slitherlink puzzles is fortunately possible in a reasonable time frame.

The strategy I used in the solver consists of pre-programmed rules — figured out by humans — which determine parts of the board based on special arrangements and enforcing the puzzle’s rules (such as that there must only be one line). Using those clues, the solver partly solves a given Slitherlink until there are no more known rules to advance. At that point the solver guesses for a given line segment to be either crossed (marking it cannot be drawn) or drawn, building a tree.
Conflicting attempts (where the solver wrongly guessed, then later — through applying the given rules — determines the attempt as flawed) are thrown away, only leaving possible solved scenarios. Because each Slitherlink has one unique solution, this process ultimately results in one surviving attempt, which then is checked for correctness and printed out as the solution.
A list of Slitherlink rules can be found in this Wikipedia article.

Using the above described method, my solver takes roughly 𝟢.𝟢𝟧 seconds on an Intel Core i7 (𝟦.𝟢𝟢 GHz) to solve the example 𝟧 ⨉ 𝟧 Slitherlink. A 𝟣𝟢 ⨉ 𝟣𝟢 Slitherlink takes around 𝟣.𝟨 seconds whereas it takes 𝟥𝟤 seconds to solve a 𝟣𝟧 ⨉ 𝟣𝟧 Slitherlink. The non-polynomial time is clearly recognisable. [2]

My solver best runs in a bash shell [3], as it uses ANSI escape sequences to give the solved line a vivid blue and is entirely written in Python as well as fully text-based. The source code is listed below.

Other people also have written solvers, including puzzle generators, such as kakuro-online or appspot. The latter even supports different polygons as the Slitherlink base.

Source code: slitherlink-solver.py

Double-Slit Experiment

2017-01-28, post № 158

ImageMagick, programming, Python PIL, #animation, #flight, #gif, #light, #physics

Light is a fascinating thing in our universe. We perceive it as color, warmth and vision. Yet it does things one may not expect it to do. One of the experiments that called for a better physical model of light was the double slit experiment. In this experiment, a laser is shone through two closely adjacent slits and projected on the screen behind. Using old physical models, one would expect to see one or maybe two specs of light on the screen, when in reality there appear alternating dark and bright spots.

To explain why this seemingly strange phenomenon is occurring, one can either see light as photons and comprehend that a photon presumably follows every possible path there is in the entire universe and then — through it being observed — randomly chooses one path and thus creates stripes (according to the theory of quantum mechanics) or one can see light as simply being a wave.

For more information on the double-slit experiment, I refer to this Wikipedia entry.

The animation shown below describes light as a wave. The green vectors represent the light wave’s phase at the points on the light beam, the yellow vector represents the addition of both of the slit’s light beam’s phase when hitting the screen and the red dots at the screen represent the light’s brightness at that point (defined by the yellow vector’s length).
To create the animation, Python and a Python module called PIL were used to create single frames which were then stitched together by ImageMagick to create an animated gif.

double-slit-experiment.gif
Source code: double-slit-experiment.gif

Mandelbrot Set II

2017-01-14, post № 157

Java, mathematics, programming, #compiled, #filled Julia set, #generalized filled Julia set, #generalized Mandelbrot set, #Julia, #speed increase, #viewer

Over a year ago, I published my first Mandelbrot Set viewer, a Python program using Pygame. Since then, I have published a rather short program highlighting errors that can occur when calculating the set (Mandelbrot Set Miscalculations).
Since my first viewer was written in Python, which is an interpreted programming language, and I wanted to make my viewer faster, I decided to write one in Java. I was hoping for a speed increase since Java is compiled and thus should run at higher speeds. I was not disappointed. The new Java-based viewer runs noticeably faster and additionally I added a lot of new features, all listed below.

Controls

  • Left-clicking and dragging draws a zoom frame, single left-clicking removes the frame,
  • Right-clicking (and optionally dragging) moves the zoom frame,
  • ‘Space’ zooms into the zoom frame,
  • ‘F1’ moves one step back the zoom history,
  • ‘F2’ shows the path a complex number at the cursor’s position follows when the function is iteratively applied,
  • ‘F3’ shows the \mathbb{R} and i\,\mathbb{R} axis,
  • ‘F4’ displays the current cursor’s corresponding complex number,
  • ‘F5’ toggles between showing and hiding the menu (text in the left upper corner describing the viewer’s functions and current states),
  • ‘F6’ increments the exponent (going from f_c(z)=z^2+c to f_c(z)=z^5+c in whole-number steps),
  • ‘F7’ toggles between the Mandelbrot set and the filled Julia set,
  • ‘F8’ toggles between previewing a small filled Julia set at the cursor’s position based upon the cursor’s complex number,
  • ‘F9’ completely resets the zoom and zoom history,
  • ‘F11’ (or ‘F’) toggles between fullscreen and windowed mode,
  • ‘F12’ quits the application,
  • ‘L’ increases the color depth (starting at 𝟤𝟧𝟨 and increasing in steps of 𝟤𝟧𝟨),
  • ‘Q’ saves the current image to disk.

To use this application, you can either trust me and download the .jar-file or view the source code listed below, verify it and compile the program yourself.
The program will start in fullscreen mode, to change to windowed mode, just press ‘F11’ (as listed above).

mandelbrot-set-ii-0_mandelbrot_tl-3.5555555555555554-2.0i_br3.5555555555555554+2.0i.png
mandelbrot-set-ii-1_julia_-0.5629629629629629+0.47777777777777786i_tl-3.5555555555555554-2.0i_br3.5555555555555554+2.0i.png
mandelbrot-set-ii-2_mandelbrot_tl-3.5555555555555554-2.0i_br3.5555555555555554+2.0i.png
mandelbrot-set-ii-3_mandelbrot_tl0.732913241572962-0.151610056431476i_br0.7334855905959307-0.15128791342783118i.png
mandelbrot-set-ii-4_julia_0.7332134267115711+0.1514433175990339i_tl-3.5555555555555554-2.0i_br3.5555555555555554+2.0i.png
Source code: Main.java
Extra assets: mandelbrot-set-ii-5_mandelbrot_tl-3.5555555555555554-2.0i_br3.5555555555555554+2.0i.png, mandelbrot-set-ii_extra_00.png, mandelbrot-set-ii_extra_01.png, mandelbrot-set-ii_extra_02.png, mandelbrot-set-ii_extra_03.png, mandelbrot-set-ii_extra_04.png, mandelbrot-set-ii_extra_05.png, mandelbrot-set-ii_extra_05_a-half.png, mandelbrot-set-ii_extra_06.png, mandelbrot-set-ii_extra_06_a-half.png, mandelbrot-set-ii_extra_07.png, mandelbrot-set-ii_extra_07_a-half.png, mandelbrot-set-ii_extra_08.png, mandelbrot-set-ii_extra_09.png, mandelbrot-set-ii_extra_10.png, mandelbrot-set-ii_extra_11_Fractal-at-25fe8ea8.png, mandelbrot-set-ii_extra_12_mandelbrot_tl-1.8-1.2i_br1.8+1.2i.png, mandelbrot-set-ii_extra_13_mandelbrot_tl-1.8-1.2i_br_1.8+1.2i.png, mandelbrot-set-ii_extra_14_julia_c-0.4800000000000002+0.6366666666666666i_tl-1.8-1.2i_br1.8+1.2i.png, mandelbrot-set-ii_extra_15_mandelbrot_tl0.05333333333333323-0.6333333333333333i_br0.3599999999999999-0.4622222222222222i.png, mandelbrot-set-ii_extra_21_julia_c-0.5266666666666668+0.4033333333333333i_tl-1.8-1.2i_br1.8+1.2i.png, mandelbrot-set-ii_extra_22_julia_c-0.5466666666666666+0.2844444444444445i_tl-2.1333333333333333-1.2i_br2.1333333333333333+1.2i.png, mandelbrot-set-ii_extra_23_julia_c-0.5466666666666666+0.2844444444444445i_tl0.8800000000000003-0.046666666666666634i_br1.1911111111111112+0.1266666666666667i.png, mandelbrot-set-ii_extra_24_mandelbrot_tl-0.2174531103962005-0.7228248243121531i_br-0.21745053052484012-0.7228231210961094i.png, mandelbrot-set-ii_extra_25_mandelbrot_tl-0.21745176527993842-0.7228241924663124i_br-0.21745173948122481-0.7228241754341519i.png, mandelbrot-set-ii_extra_26_mandelbrot_tl-3.5555555555555554-2.0i_br3.5555555555555554+2.0i.png, mandelbrot-set-ii_extra_27.png, mandelbrot-set-ii_extra_28.png

New Year

2016-12-31, post № 156

art, haiku, poetry, #2017, #Silvester

Aiming at the sky.
Stunningly empty vastness …
Sound of explosion.

Christmas

2016-12-24, post № 155

art, haiku, poetry, programming, Python, #ascii, #ascii art, #star tree, #tree, #xmas

Christmas tree gets chopped,
Excitement fills the people.
Forming winter mood.

         *         
        ***        
       *****       
      *******      
     *********     
    ***********    
   *************   
  ***************  
 ***************** 
       *****       

Advent IV

2016-12-18, post № 154

art, haiku, poetry, #nature, #sleep

The lakes are frozen.
All world seems barren and still.
Nature is asleep.

Orange

2016-12-17, post № 153

art, haiku, poetry, #color, #falling, #falling up, #fruit, #gif, #screw gravity

Orange on the floor,
Grows a tall tree beside it.
Falls up to its home.

orange.gif

Advent III

2016-12-11, post № 152

art, haiku, poetry, #Christmas, #fir, #tree

As a fir cone born.
As a goal to reach the sky.
As destiny death.

Advent II

2016-12-04, post № 151

art, haiku, poetry, #ice

Soft ice from above
Falls upon the barren land.
Coats the world in white.

Mandelbrot set miscalculations

2016-12-03, post № 150

Java, mathematics, programming, Python, #assignment, #complex numbers

While developing a Java program to create an image of the Mandelbrot set, I stumbled upon a small error which completely changes the set’s look. To fix this bug, you need to swap two lines of code.

The bug arises when trying to convert convenient Python features to Java.
To iteratively apply the function z\mapsto z^2+c, you update your complex number 𝑧 a certain amount of times. When you are not using a complex number class, but instead you use two floating point numbers (in Java doubles to gain precision) a and b to define the real and imaginary part (z=\texttt{a}+\texttt{b}\cdot i), logically both numbers need to be updated.
In Python you may write the following, when 𝑐 is defined as being a complex number with parts c and d (c=\texttt{c}+\texttt{d}).

a, b = a**2 - b**2 + c, 2 * a * b + d

Which seems to be very similar to those two lines.

a = a**2 - b**2 + c
b = 2 * a * b + d

But notice that in the first code snippet you define a tuple consisting of the real and imaginary part and then assign it to the variables. The first snippet really looks like this.

t = (a**2 - b**2 + c, 2 * a * b + d)
a, b = t

Using this assignment of variables, which corresponds to z\mapsto z^2+c, you get an image of the correct Mandelbrot set.

mandelbrot-set-miscalculations_mandelbrot-set-correct.png

In contrary, the second code snippet assigns the old a its new value, then uses this new a to define the value of new b, thus does not calculate z\mapsto z^2+c, which is equivalent to z\mapsto (\texttt{a}^2-\texttt{b}^2+\texttt{c})+(2\cdot\texttt{a}\cdot\texttt{b}+\texttt{d})\cdot i, but rather z\mapsto (\texttt{a}^2-\texttt{b}^2+\texttt{c})+(2\cdot\texttt{a}^2\cdot\texttt{b}-2\cdot\texttt{b}^3+2\cdot\texttt{b}\cdot\texttt{c}+\texttt{d})\cdot i.

In Java it would look like this.

a = a*a - b*b + c;
b = 2 * a * b + d;

Which results in this rather unusual depiction of the famous fractal.

mandelbrot-set-miscalculations_mandelbrot-set-miscalculation.png

You can easily avoid this bug when using two sets of variables to define old 𝑧 and new 𝑧, as shown in the following.

_a = a*a - b*b + c;
_b = 2 * a * b + d;
a = _a;
b = _b;

Or you can define variables \texttt{asqr}=\texttt{a}^2 and \texttt{bsqr}=\texttt{b}^2 and swap the assignment. Using variables for the squares of the parts of 𝑧 also helps to improve performance [1].

b = 2 * a * b + d;
a = asqr - bsqr + c;
asqr = a*a;
bsqr = b*b;
Source code: mandel.java

MMXVI

2016-12-01, post № 149

mathematics, #all days of December

The idea is to only use the year’s digits — preferably in order — and mathematical symbols (+,-,\cdot,\sqrt{},\lfloor\rfloor,\lceil\rceil,\dots) to create an equation that evaluates to a specific day of the month.
The 0th of December, 2016 would, for example, be 2\cdot 0\cdot 1\cdot 6, 2^0-1^6 or \lfloor\frac{2}{0+16}\rfloor.