## Mandelbrot Set ASCII Viewer

The Mandelbrot Set is the set of all complex points which, when one iteratively and infinitely applies the function $f_c(z)=z^2+c$, converge to a value. This simple rule results in stunning complexity and beauty.
Many Mandelbrot Set animations use regularly colored pixels to represent the number of iterations needed at the fractal’s edges to escape converging. Yet this mathematical object can also be represented as ASCII characters — similar to what I did in my Curses Cam post. The characters are chosen according to their opaqueness. A full stop (‘.’) looks lighter than a dollar sign (‘$’), so they represent a smaller or larger number of iterations needed. The order of characters used is taken from this post by Paul Borke. As there are only 70 characters used, each frame is being rendered twice to determine the minimum number of iterations needed by every point in that frame. Thereby the full visual character range is used. The characters shown below represent a Mandelbrot Set still. To see the zoom in action, either run the program (listed below) or take a look at this Mandelbrot Set ASCII journey.  ..................''''''''"">>II''''...... ..................''''''''^^,,ii::^^''''...... ..................''''''''^^::ww$$++,,''''...... ................''''''''^^^^""::$$::""^^''''...... ..............''''''""{{;;XXuuUU,,,,""''...... ............''''^^,,rr<<$$--........ ........''^^""LL$$$$__""''...... ..''''''^^!!"""",,""""::__$$ll""''........ ''''^^::__IIYYii::llpp^^''........ ''"";;[[$$++__$$^^''''...... ^^^^,,;;>>ww''''...... "",,,,II$$nn$$$$""''''...... "",,,,II$$nn""''''...... ^^^^,,;;>>ww''''...... ''"";;[[$$++__$$^^''''...... ''''^^::__IIYYii::llpp^^''........ ..''''''^^!!"""",,""""::__$$ll""''........ ........''^^""LL$$$$__""''...... ............''''^^,,rr$$$$<<$$--........ ..............''''''""{{;;XXuuUU,,,,""''...... ................''''''''^^^^""::$$::""^^''''...... ..................''''''''^^::ww$$++,,''''...... ..................''''''''^^,,ii::^^''''...... The fractal viewer is written in Python 2.7 and works by determining the terminal’s size and then printing a string of according size. This creates the illusion of a moving image, as the terminal will hopefully always perfectly scroll so that only one frame is visible at a time. In the code’s first non-comment line one can change the complex point at the image’s center, (really, its conjugate, which is partially irrelevant as the set is symmetric along the real axis) the initial zoom value (complex distance above the image’s center), the zoom factor (the factor by which the zoom value gets multiplied after a frame), the total number of frames (-1 means there is no upper limit), the delay between frames (in seconds, can be floating-point) and the color characters used. The program’s source code may not be particularly easy to read, yet it does its job and only requires seven non-comment lines! The code is shown below, though the .py file can also be downloaded. To achieve the JavaScript animation linked to above, I wrote a simple Python converter which takes in the fractal renderer’s output and it spits out an HTML page. This converter’s code is not listed, though the .py file can be downloaded. Instructions on how to use the converter can be seen in its source code. # Python 2.7 Code; Jonathan Frech, 15th and 16th of June 2017 P,Z,F,N,D,K=-.707+.353j,3,.9,-1,.1," .'^\",:;Il!i><~+_-?][}{1)(|\\/tfjrxnuvczXYUJCLQ0OZmwqpdbkhao*#MW&8%B@$"
def C(c):
global m;z,i=0j,-1
while abs(z)<=2 and i<len(K)-1+M:z,i=z*z+c,i+1
m=min(m,i);return K[i-M]*2
while n<N or N==-1:h=Z*2.;w=h*W/H;R=lambda:"\n\n"*(n!=0)+"\n".join("".join(C(P-complex(w/2-w*x/W,h/2-h*y/H))for x in range(W))for y in range(H));M,m=0,len(K);R();M=max(M,m);S.write(R());S.flush();Z,n=Z*F,n+1;time.sleep(D)

## A285494

The On-Line Encyclopedia of Integer Sequences gets regularly updated with new integer sequences. One of the recent updates was contributed by me, A285494.

A285494 is the list of all numbers $k$ so that its digit sum equals its number of distinct prime factors.
A number’s digit sum is the sum of all of its decimal digits. The number $62831853$, for example, has a digit sum of $6+2+8+3+1+8+5+3 = 36$.
A number’s number of distinct prime factors is the number of different prime numbers that multiply together to result in the original number. As an example, $62831853 = 3^2 \cdot 7 \cdot 127 \cdot 7853$, so it has five prime factors of which four are distinct.
Thereby one can conclude that $62831853$ is not an entry in this sequence, as $36 \neq 4$.

The sequence is certainly infinite, as the number $k = 2 \cdot 10^n$ with $n \in \mathbb{N}^*$ has a digit sum of $2 + (0 \cdot n) = 2$ and — because $k = 2^{n+1} \cdot 5^n$ — exactly two distinct prime factors.

In the encyclopedia entry, I provided a Mathematica one-liner to compute the first few entries of this sequence. Since then, I have also written a Python two-liner to achieve the same goal.

(* Mathematica *)
Select[Range[2,10000],Total[IntegerDigits[#]]==Length[FactorInteger[#]]&]
Out = {20, 30, 102, 120, 200, 300, 1002, 1200, 2000, 2001, 2002, 3000, 3010}

# Python 2.7
>>> def p(n):exec"i,f=2,set()\nwhile n>1:\n\tif n%i==0:f.add(i);n/=i;i=1\n\ti+=1";return len(f)
>>> print filter(lambda n:p(n)==sum(map(int,str(n))),range(2,10001))
[20, 30, 102, 120, 200, 300, 1002, 1200, 2000, 2001, 2002, 3000, 3010]


## T-3PO — Tic-Tac-Toe Played Optimally

Tic-Tac-Toe, noughts and crosses, Xs and Os, three in a row or whatever you want to call it may be the simplest perfect information game that is enjoyable by humans. Two players set their pieces (X or O) on an 3×3 grid, alternating their turns. The first player to get three of their pieces in a line, wins. If no player succeeds to get a line, the game ends in a draw.

Tic-Tac-Toe’s simplicity may become clear, if you consider that skilled players — people who have played a few rounds — can reliably achieve a draw, thereby playing perfectly. Two perfect players playing Tic-Tac-Toe will — whoever starts — always tie, so one may call the game virtually pointless, due to there practically never being a winner.
Because of its simple rules and short maximal number of turns (nine) it is also a game that can be solved by a computer using brute-force and trees.

The first Tic-Tac-Toe-playing program I wrote is a Python shell script. It lets you, the human player, make the first move and then calculates the best possible move for itself, leading to it never loosing. On its way it has a little chat whilst pretending to think about its next move. The Python source code can be seen below or downloaded here.

The second Tic-Tac-Toe-playing program I wrote uses the exact same method of optimizing its play, though it lets you decide who should begin and is entirely written in JavaScript. You can play against it by following this link.

Both programs look at the entire space of possible games based on the current board’s status, assumes you want to win and randomly picks between the moves that either lead to a win for the computer or to a draw. I did not include random mistakes to give the human player any chance of winning against the computer. Other Tic-Tac-Toe-playing computers, such as Google’s (just google the game), have this functionality.

# Python 2.7.7 Code
# Jonathan Frech, 31st of March 2017
#          edited  1st of April 2017

## Bifurcation Diagram

Generating the famous fractal, which can be used to model populations with various cycles, generate pseudo-random numbers and determine one of nature’s fundamental constants, the Feigenbaum constant $\delta$.
The fractal nature comes from iteratively applying a simple function, $f(x) = \lambda \cdot x \cdot (1-x)$ with $0 \leq \lambda \leq 4$, and looking at its poles.
The resulting image looks mundane at first, when looking at $0 \leq \lambda \leq 3$, though the last quarter section is where the interesting things are happening (hence the image below only shows the diagram for $2 \leq \lambda \leq 4$).
From $\lambda = 3$ on, the diagram bifurcates, always doubling its number of poles, until it enters the beautiful realm of chaos and fractals.

For more on bifurcation, fractals and $\delta$, I refer to this Wikipedia entry and WolframMathworld.

# Python 2.7.7 Code
# Jonathan Frech, 24th of March 2017

## Pi Day MMXVII

Every year on March the 14th, for one day the world gets irrationally excited about the famous constant $\pi$. As is tradition, you try to calculate $\pi$ in unusual ways, demonstrating the constant’s ubiquity as it crops up in the most unexpected circumstances.

                        lnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn
nJw
v$$n$$$$z u$$mnn:       Y$$i .@$$$$,$$n           )$$* W$$$$m -n[$$$$. ]$$
h$$w$$Y
[         X$$"$$$$n '$${
.$8$$*$$$$} :$$+ #u $$% t$$ ;$$ u$$! $$W Y$$M .$$, f$$$$. Z$$$$Z nn w$$$$|$$( v$z
n$W $$1 'X8 Y$$ *$$8nnnn$$$p
$@. W$n
_$${ x$$$0> -n{. !|nt_.  A fairly well-known way to approximate pi is to randomly choose points in a square (often thought of as throwing darts at a square piece of cardboard), determine their distance to a circle’s center and do a division, as I did in my π Generator post. However, $\pi$ does not only appear in the formula for a circle’s area, $A=\pi \cdot r^2$, yet also in the formula for a sphere’s volume, $V=\frac{4}{3} \cdot \pi \cdot r^3$, and for all the infinite hyperspheres above dimension three (view this Wikipedia article for more about volumes of higher-dimensional spheres). In particular, the formula for the hypervolume of a hypersphere in four dimensions is defined as being $V=\frac{\pi^2}{2} \cdot r^4$. Using this formula, my Python script randomly chooses four-dimensional points (each in the interval $\left[0, 1\right)$), calculates their distance to the point $\left(0.5, 0.5, 0.5, 0.5\right)$ and determines if they are in the hypersphere around that point with radius $0.5$. By dividing the number of random points which lie in the hypersphere by the number of iterations used ($10^6$ in the example below), the script approximates the hypersphere’s hypervolume. By then rearranging the equation $V=\frac{\pi^2}{2} \cdot r^4$ with $r=0.5$ to $\pi=\sqrt{V\cdot 32}$, the desired constant can be approximated. $ python pi.py
3.14196371717

# Python 2.7.7 Code
# Jonathan Frech, 13th of March 2017

## A278328

The On-Line Encyclopedia of Integer Sequences (also known by its acronym, OEIS) is a database hosting hundreds of thousands of — as the name implies — integer sequences. Yet, despite the massive number of entries, I contributed a new integer sequence, A278328.

A278328 describes numbers whose absolute difference to their decimal reverse are square. An example would be $12$ or $21$ (both are the decimal reverse to each other), since $\left|12-21\right|=9$ and $9=3^2$.

Not a whole lot is known about the sequence, partly due to its definition only resulting in the sequence when using the decimal system, though it is known that there are infinitely many numbers with said property. Since there are infinitely many palindromes (numbers whose reverse is the number itself), $\left|n-n\right|=0$ and $0=0^2$.

Due to there — to my knowledge — not being a direct formula for those numbers, I wrote a Python script to generate them. On the sequence’s page, I posted a program which endlessly spews them out, though I later wrote a Python two-liner, which only calculates those members of the sequence in the range from $0$ to $98$ (shown below entered in a Python shell).

>>> import math
>>> filter(lambda n:math.sqrt(abs(n-int(str(n)[::-1])))%1 == 0, range(99))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 15, 21, 22, 23, 26, 32, 33, 34, 37, 40, 43, 44, 45, 48, 51, 54, 55, 56, 59, 62, 65, 66, 67, 73, 76, 77, 78, 84, 87, 88, 89, 90, 95, 98]

## Maze Solving

Mazes have been a subject of human interest for thousands of years. The Greeks used them to trap a bull-man hybrid, the French built them to show how they could impose order on nature, and even nowadays people enjoy wandering around corn mazes.
The algorithmic art of using computers to solve mazes — and even to find the shortest path through a maze –, however, has only emerged in the last couple of decades.

I was inspired by a recent Computerphile video in which Michael Pound talks about implementing different path finding algorithms for use in maze solving. And as he used Python — one of my favourite languages out there –, I thought I could give it a try and came up with this maze solver.

The mazes given to the solver (through a .png file) have to have a specific form. The maze needs to have a border all around (painted black) with two holes at the top and bottom, marking the maze’s start and exit (all path pixels are white).
Then the solver — using PIL — reads in the maze file, determines start and exit and starts at the maze’s start, labelling each maze path according to its shortest distance to the start. After it has found the exit, it stops looking at the maze and traces its origins back from the exit, marking the path it goes along as the maze’s optimal solution (highlighted in red).
The different hues of blue indicate the tile’s distance to the start, the white tiles are tiles the solver did not even look at.
The different shadings also reveal information about the maze. Mazes with only one solution tend to have sharp changes as there are parts of the maze separated by only one wall, yet separated by a huge walk distance through the maze. The one maze with multiple solutions (see upper right image below) — in contrast — has only gradual changes in hue.

To solve a 4 megapixel maze, the solver takes around 3 seconds, for a 16 megapixel maze around 14 seconds and for a 225 megapixel maze around 7 minutes and 22 seconds.
Performance was measured on an Intel Core i7 (4.00 GHz).

All mazes shown were downloaded from Michael Pound’s mazesolving GitHub repository, which were mostly generated using Daedalus.

The solver’s source code is listed below, though you can also download the .py file.

# Python 2.7.7 Code
# Jonathan Frech, 25th of Feburary 2017
#          edited 26th of February 2017
#          edited 27th of February 2017
#          edited 22nd of March    2017
#          edited 29th of March    2017

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 (0, 1, 2 or 3). 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} = 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} = 1.15 \cdot 10^9$ seconds or $36.56$ 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 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 0.05 seconds on an Intel Core i7 (4.00 GHz) to solve the example 5×5 Slitherlink. A 10×10 Slitherlink takes around 1.6 seconds whereas it takes 32 seconds to solve a 15×15 Slitherlink. The non-polynomial time is clearly recognisable.

My solver best runs in a bash shell, 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.

# Python 2.7.7 Code
# Jonathan Frech, 22nd of December 2016
# edited 23rd, 24th, 25th, 26th, 27th, 29th, 30th, 31st of December 2016
# edited 1st, 2nd, 3rd, 5th, 8th of January 2017
# edited 10th of February 2017

## Double-Slit Experiment

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.

# Jonathan Frech, 18th of January 2017
#          edited 19th of January 2017
#          edited 22nd of January 2017
#          edited 27th of January 2017

## Christmas

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

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

__ = 9;_ = chr;"istmas tree gets chopped"
exec _(95)+_(95)+_(95)+_(95)+_(61)+_(108)+_(97)+_(109)+_(98)+_(100)+_(97)+_(32)+_(120)+_(58)\
+_(114)+_(97)+_(110)+_(103)+_(101)+_(40)+_(120)+_(41)+_(10)+_(100)+_(101) +_(102)+_(32)\
+_(95)+_(40)+_(115)+_(41)+_(58)+_(112)+_(114)+_(105)+_(110)+_(116)+_(32)+_(115)
"itement fills the people"
for m in ____(__):"g winter";___ = m;"ood";_(" "*(__-___)+"*"*(2*___+1)+" "*(__-___))
_(" "*(1/2+__-__/4)+"*"*(__/2)+["","*"][1+2*__-__/2-2*(1/2+__-__/4)]+" "*(1/2+__-__/4))