Asciify

Most images nowadays are represented using pixels. They are square, often relatively small and numerous, come in (2^8)^3 different colors and thereby do a good job being the fundamental building block of images. But one can imagine more coarse-grained and differently shaped pixels.
An interesting fact is, that in most monotype fonts two characters placed right next to each other (for example ‘$$’) occupy roughly a square area. So simple ASCII characters can indeed be used to approximately describe any ordinary image.
Asciify does exactly this; it takes in an image and some optional parameters and maps the pixels’ intensity onto a character set. Both the large and small default character sets are taken from a post by Paul Bourke.

Asciified kirby
Kirby grafitti

In conjunction with asciify.py, I wrote index.py, which asciifies a bunch of images and results in their html form; it also creates an index. All images asciified for this post can be viewed through this index.

Converting an image to its asciified form works best when there is a lot of contrast in the image. Because of this, some pre-processing of the image may be required for best results (all images shown where only cropped or rotated). The built-in color functionality also only knows of 8 colors, so bright and different colors look the best, as they interestingly differentiate from one another. The asciified image’s size also plays a role, the larger it is, the better the characters blend into one and appear to be one image.

Asciified cube
AoLong 3^3 cube

Asciify is operated on a command prompt; python asciify.py img.png. To parse arguments, the built-in python module argparse is used. The images are opened and read using the Python Imaging Library module PIL, which needs to be installed for this program to work.
Optional arguments include --size N, where the maximum size can be specified, --invert and --smallcharset, which can sometimes increase the asciified image’s visual appeal and --html, which will output an html file to be viewed in a browser. To see the program’s full potential, simply run python asciify.py --help.
Source code for both asciify.py and index.py can be downloaded, the first is also listed below.

The two examples above use the color mode, though certain images also work in default black and white mode, such as this spider I photographed.

Asciified spider
Spider

Then again, the colored text also has its charm, especially when the source image has bright colors and a lot of contrast.

Asciified boat
Sailboat

# Python 2.7 Code
# Jonathan Frech 3rd, 4th of March 2017
#      rewritten 12th of April 2017
#         edited 13th of April, 13th, 14th, 15th of July 2017

Continue reading

Seventeen

Today it is the first day of July in the year 2017. On this day there is a point in time which can be represented as 1.7.2017, 17:17:17.
To celebrate this symbolically speaking 17-heavy day, I created a list of 17 integer sequences which all contain the number 17.
All sequences were generated using a Python program; the source code can be viewed below or downloaded. Because the following list is formatted using LaTex, the program’s plaintext output can also be downloaded.

  1. Prime numbers n.
    \{2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, \dots\}
  2. Odd positive integers n whose number of goldbach sums (all possible sums of two primes) of n+1 and n-1 are equal to one another.
    \{5, 7, 15, 17, 19, 23, 25, 35, 75, 117, 177, 207, 225, 237, 321, 393, 453, 495, 555, 567, \dots\}
  3. Positive integers n who are part of a Pythagorean triple excluding 0: n^2=a^2+b^2 with integers a,b>0.
    \{5, 10, 13, 15, 17, 20, 25, 26, 29, 30, 34, 35, 37, 39, 40, 41, 45, 50, 51, 52, \dots\}
  4. Positive integers n where \lfloor (n!)^{\frac{1}{n}} \rfloor is prime
    \{4, 5, 6, 7, 8, 12, 13, 17, 18, 19, 28, 29, 33, 34, 35, 44, 45, 46, 49, 50, \dots\}
  5. Positive integers n with distance 1 to a perfect square.
    \{1, 2, 3, 5, 8, 10, 15, 17, 24, 26, 35, 37, 48, 50, 63, 65, 80, 82, 99, 101, \dots\}
  6. Positive integers n where the number of perfect squares including 0 less than n is prime.
    \{2, 3, 4, 5, 6, 7, 8, 9, 17, 18, 19, 20, 21, 22, 23, 24, 25, 37, 38, 39, \dots\}
  7. Prime numbers n where either n-2 or n+2 (exclusive) are prime.
    \{3, 7, 11, 13, 17, 19, 29, 31, 41, 43, 59, 61, 71, 73, 101, 103, 107, 109, 137, 139, \dots\}
  8. Positive integers n whose three-dimensional vector’s (n, n, n) floored length is prime, \lfloor \sqrt{3 \cdot n^2} \rfloor is prime.
    \{2, 3, 8, 10, 11, 17, 18, 24, 25, 31, 39, 41, 46, 48, 60, 62, 63, 76, 91, 100, \dots\}
  9. Positive integers n who are the sum of a perfect square and a perfect cube (excluding 0).
    \{2, 5, 9, 10, 12, 17, 24, 26, 28, 31, 33, 36, 37, 43, 44, 50, 52, 57, 63, 65, \dots\}
  10. Positive integers n whose decimal digit sum is the cube of a prime.
    \{8, 17, 26, 35, 44, 53, 62, 71, 80, 107, 116, 125, 134, 143, 152, 161, 170, 206, 215, 224, \dots\}
  11. Positive integers n for which \text{decimal\_digitsum}(n)+n is a perfect square.
    \{2, 8, 17, 27, 38, 72, 86, 135, 161, 179, 216, 245, 275, 315, 347, 432, 467, 521, 558, 614, \dots\}
  12. Prime numbers n for which \text{decimal\_digitsum}(n^4) is prime.
    \{2, 5, 7, 17, 23, 41, 47, 53, 67, 73, 97, 103, 113, 151, 157, 163, 173, 179, 197, 199, \dots\}
  13. Positive integers n where decimal_digitsum(2 \cdot n) is a substring of n.
    \{9, 17, 25, 52, 58, 66, 71, 85, 90, 104, 107, 115, 118, 123, 137, 142, 151, 156, 165, 170, \dots\}
  14. Positive integers n whose decimal reverse is prime.
    \{2, 3, 5, 7, 11, 13, 14, 16, 17, 20, 30, 31, 32, 34, 35, 37, 38, 50, 70, 71, \dots\}
  15. Positive integers n who are a decimal substring of n^n.
    \{1, 5, 6, 9, 10, 11, 16, 17, 19, 21, 24, 25, 28, 31, 32, 33, 35, 36, 37, 39, \dots\}
  16. Positive integers n whose binary expansion has a prime number of 1‘s.
    \{3, 5, 6, 7, 9, 10, 11, 12, 13, 14, 17, 18, 19, 20, 21, 22, 24, 25, 26, 28, \dots\}
  17. Positive integers n whose 7-segment representation uses a prime number of segments.
    \{1, 2, 3, 5, 7, 8, 12, 13, 15, 17, 20, 21, 26, 29, 30, 31, 36, 39, 47, 48, \dots\}

# Python 2.7.7 Code
# Jonathan Frech, 29th, 30th  of June 2017

Continue reading

Tau Day MMXVII

Today it is June the 28th which means that it is \tau day!
The irrational and transcendental constant \tau is what defines \pi = \frac{\tau}{2}, which obviously makes it an important constant. To celebrate this day, I created a C program which calculates \tau by randomly creating 9-dimensional points inside the 9-dimensional hypercube and testing if they are inside the 9-dimensional hypersphere with its center located at (0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5).

Today’s \tau time is 3:18:53 as \tau = 6.2831853 \dots. As one does not know if the time is specified as ante or post meridiem, there are actually two perfectly acceptable \tau times.

            ;b$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$b
        h$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ 
     .$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$+ 
    $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$  
  ,$$$$$$$$$kn}~I"`($$$$$$$x````````````````   
 )$$$m             $$$$$$$$                    
+$$c              q$$$$$$$>                    
$$                $$$$$$$$                     
                 $$$$$$$$.                     
                '$$$$$$$$                      
                $$$$$$$$                       
               ?$$$$$$$a                       
               $$$$$$$$                        
              Q$$$$$$$f                        
              $$$$$$$$                         
             $$$$$$$$i                         
             $$$$$$$$                          
            $$$$$$$$;                          
            $$$$$$$$                           
           J$$$$$$$w                           
           $$$$$$$$;             $$~           
           $$$$$$$$             $$$            
          '$$$$$$$$C          "$$$             
           $$$$$$$$$w       '$$$$              
           $$$$$$$$$$$$$$$$$$$$B               
            $$$$$$$$$$$$$$$$$$.                
             $$$$$$$$$$$$$$$'                  
                8$$$$$$$q                      

The formula used for calculating \tau is derived from a 9-dimensional hypersphere’s hypervolume formula V = \frac{32 \cdot \pi^4}{945} \cdot R^9 (see this Wikipedia article).
V = \frac{2^5 \cdot \tau^4 \cdot R^9}{945 \cdot 2^4} = \frac{2 \cdot R^9}{945} \cdot \tau^4
\tau^4 = \frac{V \cdot 945}{2 \cdot R^9}; R = 0.5
\tau^4 = \frac{V \cdot 945 \cdot 2^9}{2}
\tau = \sqrt[4]{V \cdot 241920}

The constant gets calculated to \tau^* = 6.293700. The real value is approximately \tau = 6.283185 \dots, which makes the percent error \left|\frac{\tau^*-\tau}{\tau}\right| = \left|\frac{6.293700-6.283185}{6.283185}\right| = 0.001673514 = 0.167\%.
Thereby this C program’s approximation is not too far off. The source code is listed below and can also be downloaded here. Instructions on how to compile it using GCC can be seen below or in the source code.

gcc tau.c -o tau -lm; ./tau
tau = 6.293700

Resources worth checking out regarding \tau are The Tau Manifesto and 2 Pi or Not 2 Pi?. I wish everybody a happy \tau day.


// C Code
// Jonathan Frech, 27th of June 2017

Continue reading

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$$++,,````''''......                      
................''''''''``^^^^""::$$$$$$::""^^``''''......                    
..............''''''````""{{;;XX$$$$$$$$uuUU,,,,""''......                    
............''''``````^^,,rr$$$$$$$$$$$$$$$$<<$$--``........                  
........''``````````^^""LL$$$$$$$$$$$$$$$$$$$$__""``''......                  
..''''''^^!!"""",,""""::__$$$$$$$$$$$$$$$$$$$$$$ll""''........                
''''````^^::__IIYYii::ll$$$$$$$$$$$$$$$$$$$$$$$$pp^^''........                
''``````"";;[[$$$$$$++__$$$$$$$$$$$$$$$$$$$$$$$$$$^^''''......                
``^^^^,,;;>>$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ww``''''......                
"",,,,II$$nn$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$""``''''......                
"",,,,II$$nn$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$""``''''......                
``^^^^,,;;>>$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ww``''''......                
''``````"";;[[$$$$$$++__$$$$$$$$$$$$$$$$$$$$$$$$$$^^''''......                
''''````^^::__IIYYii::ll$$$$$$$$$$$$$$$$$$$$$$$$pp^^''........                
..''''''^^!!"""",,""""::__$$$$$$$$$$$$$$$$$$$$$$ll""''........                
........''``````````^^""LL$$$$$$$$$$$$$$$$$$$$__""``''......                  
............''''``````^^,,rr$$$$$$$$$$$$$$$$<<$$--``........                  
..............''''''````""{{;;XX$$$$$$$$uuUU,,,,""''......                    
................''''''''``^^^^""::$$$$$$::""^^``''''......                    
  ..................''''''''``^^::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@$"
import os,time,sys;H,W,S,n=map(int,os.popen("stty size").read().split())+[sys.stdout,0];W/=2
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]

JSweeper

Adding to my collection of clones of popular, well-known games, I created back in November of 2016 a Java-implementation of the all-time Windows classic game, Minesweeper.

Minesweeper was pre-installed on every installation of Windows up to and including Windows 7 and has been ported to a variety of different systems. Because of this, nearly everyone has at least once in their life played Minesweeper or at least heard of it.
In Minesweeper you are presented with a square grid of covered tiles containing either numbers or mines. Your task is it to uncover all tiles which are not mines in the least amount of time. When you uncover a mine, it explodes and the game is lost. To aid in figuring out which tiles are mines and which are not, every tile that is not a mine tells you how many mines are in the neighbouring eight tiles. Tiles which have no neighbouring mines are drawn gray and uncover neighbouring non-mine tiles once uncovered.
More on Minesweeper can be found in this Wikipedia article — I am linking to the German version, as the current English version has major flaws and lacks crucial information. If you are so inclined, feel free to fix the English Minesweeper Wikipedia article.

In my clone, there are three pre-defined difficulty levels, directly ported from the original Minesweeper game, and an option to freely adjust the board’s width and height as well as the number of bombs which will be placed. Gameplay is nearly identical to the original, as my clone also uses a square grid and the tile’s numbers correspond to the number of bombs in the eight tiles surrounding that tile.
The game has a purposefully chosen pixel-look using a self-made font to go along with the pixel-style.

Controls

  • Arrow keys and enter to navigate the main menu
  • Arrow keys or mouse movement to select tiles
  • Space, enter or left-click to expose a tile
  • ‘f’ or right-click to flag a tile
  • ‘r’ to restart game when game is either won or lost
  • Escape to return to the main menu when game is either won or lost
  • F11 toggles fullscreen

To play the game, you can either download the .jar file or compile the source code for yourself. The source code is listed below and can be downloaded as a .java file.

Level select screen Successfully played an easy game A failed attempt at solving a hard game


// Java 1.6 / 1.8 code
// Jonathan Frech  5th of November, 2016
//         edited  7th of November, 2016
//         edited 11th of November, 2016
//         edited 13th of November, 2016
//         edited 14th of November, 2016
//         edited 15th of November, 2016
//         edited 17th of November, 2016
//         edited 19th of November, 2016
//         edited 19th of May     , 2017
//         edited 22nd of May     , 2017
//          * fixed max mine cap when
//            using custom settings

Continue reading

Multibrot Set

The Mandelbrot Set is typically defined as the set of all numbers c \in \mathbb{C} for which — with z_0 = 0, z_{n+1} = f_c(z_n) and f_c(z) = z^2 + c — the limit \lim\limits_{n \to \infty} z_n converges. Visualizations of this standard Mandelbrot Set can be seen in three of my posts (Mandelbrot Set, Mandelbrot Set Miscalculations and Mandelbrot Set II).

f_c(z)=z^2+cHowever, one can extend the fractal’s definition beyond only having the exponent 2 in the function to be f_c(z)=z^\text{exp}+c with \text{exp} \in \mathbb{R}. The third post I mentioned actually has some generalization as it allows for \text{exp} \in \{2,3,4,5\}, although the approach used cannot be extended to real or even rational numbers.

f_c(z)=z^3+cThe method I used in the aforementioned post consists of manually expanding (a+b\cdot i)^n for each n. The polynomial (a+b\cdot i)^3, for example, would be expanded to (a^3 - 3 \cdot a \cdot b^2) + (3 \cdot a^2 \cdot b - b^3) \cdot i.
This method is not only tedious, error-prone and has to be done for every exponent (of which there are many), it also only works for whole-number exponents. To visualize real Multibrots, I had to come up with an algorithm for complex number exponentiation.

f_c(z)=z^4+cLuckily enough, there are two main ways to represent a complex number, Cartesian form z = a+b\cdot i and polar form z = k\cdot e^{\alpha\cdot i}. Converting from Cartesian to polar form is simply done by finding the number’s vector’s magnitude k = \sqrt{a^2+b^2} and its angle to the x-axis \alpha = \mbox{atan2}(\frac{a}{b}). (The function \mbox{atan2} is used in favor of \arctan to avoid having to divide by zero. View this Wikipedia article for more on the function and its definition.)
Once having converted the number to polar form, exponentiation becomes easy as z^\text{exp} = (k \cdot e^{\alpha\cdot i})^\text{exp} = k^\text{exp} \cdot e^{\alpha \cdot \text{exp} \cdot i}. With the exponentiated z^\text{exp} in polar form, it can be converted back in Cartesian form with z^\text{exp} = k^\text{exp} \cdot (\cos{(\alpha \cdot \text{exp})} + \sin{(\alpha \cdot \text{exp})} \cdot i \big).

f_c(z)=z^5+cUsing this method, converting the complex number to perform exponentiation, I wrote a Java program which visualizes the Multibrot for a given range of exponents and a number of frames.
Additionally, I added a new strategy for coloring the Multibrot Set, which consists of choosing a few anchor colors and then linearly interpolating the red, green and blue values. The resulting images have a reproducible (in contrast to randomly choosing colors) and more interesting (in contrast to only varying brightness) look.

f_c(z)=z^6+cThe family of Multibrot Sets can also be visualized as an animation, showing the fractal with an increasing exponent. The animated gif shown below was created using ImageMagick’s convert -delay <ms> *.png multibrot.gif command to stitch together the various .png files the Java application creates. To speed up the rendering, a separate thread is created for each frame, often resulting in 100% CPU-usage. (Be aware of this should you render your own Multibrot Sets!)

f_c(z)=z^10+cTo use the program on your own, either copy the source code listed below or download the .java file. The sections to change parameters or the color palette are clearly highlighted using block comments (simply search for ‘/*’).
To compile and execute the Java application, run (on Linux or MacOS) the command javac multibrot.java; java -Xmx4096m multibrot in the source code’s directory (-Xmx4096m tag optional, though for many frames at high quality it may be necessary as it allows Java to use more memory).
If you are a sole Windows user, I recommend installing the Windows 10 Bash Shell.

Multibrot animation (probably loading...)


// Java 1.8 Code
// Jonathan Frech, 11th of September 2016
//          edited 17th of April     2017
//          edited 18th of April     2017
//          edited 20th of April     2017
//          edited 21st of April     2017
//          edited 22nd of April     2017

Continue reading

Easter MMXVII

Winds swirl through the air,
Water sloshes at the shore;
A peaceful island.


                           vunnnnnnnxvvczYX                         
                       uuxrjjft///tfjrnuvvcXXUU                     
                    cuxxrf/\|(|||/tttrnxuuvcczYYJL                  
                 cuuvnxrjt/\\\/\//tffrxnuvvcccXXYYCLC               
               cccvuunxjrttttttjjfrrxnnnvvcczXzXUUUJL0              
             cczvvvuuuxnrxrrrjrxrxnnuuuvvcczXXXXYXUJJLQZ            
           czzzXzvccvnuunnnnnnnnuuuvuvvccczzzXYXYUYUJCLQO           
          zzzzXzccvvvvvuunnnnunuunnuuucvzczzXXYXUYJUJJCQ0Oq         
         XXXXzzzzcccvvvvuuvunnnnnuuuvvvcczzXzXYXXYYUUCCL0Qmp        
        XXXzXzzzzzcccccvuunnnnnnnnunvucvzzzXzYXXYUUUUJJCL0OZq       
       XYYYYXXzczzzcczcvuuunxxnxxxnuuuvzzXXXXYXUYUUUUUCJCQ0Owp      
      YYUYXYYXXXXzczczcvvuunxxrrrxnnuvuzzzzXXXYYUUUUUUJJCCL0Omd     
     YYUUYUYUXXXXczzzzcvvvunxrxrrrxxnuvcczzXzYYXYXUYUUJJLQQ0OZmk    
    YUUJJJYUYYXUXYXzczzczuuxrjrrrjrxxccccczzXXXYUYUYUJUCCCL00mwdw   
    UJCJJJUYXYXXXzzXXzzvvnxxrjjjrjxxuvvczXzXYYYXXUYUUUJCJLLL0Zmpb   
   CLLCJJJCUUUXUUXXzzzccvvunxxrrxrnuuvzzzXYXXYYYUUUYJUJJJJLL0OZwda  
   QLQLCJCUUUUUUYYXXXXXzvuuxxxrrnxxuuvvccXzXYUYUYYYUUUUCCCLLQ0Zmpk  
  00QQLLLCUJUUUUUYYYXzzzccvuuxxxxnnuvczzcXXXXUUUUYYJUYUUJCLL0QOwqk* 
  Z0OQQLLJCJUUUYUYYYXXXzzcvvnunnuuvvvvczzzXXXYYYYUYUYUJJCJLL0QOmqpa 
 0ZmZ00QLLCCJCJUUUUYYXXzzcccvvuuuucvczXXXYXYYUUUYYYUUUJJJJC0L0ZOqpkM
 ZOZO0QLLLCCCJJJUUYYXYXXYXzccvvccvczzzzXXXYYYYYUYYUYUUUUJJCCQQOZwdk*
 wwmZ0OQCQCCJJJJUUUYUYYYYXXzzzcccczXXXzXXXXYYXUYYYUUJUUJJCULQQ0Zmpbo
 qmZZZ00QQLCJUJUUJUUUUUYYXXXXzcYXXzXUXYXYYYXUUUYUUUUUUUJCJCCQQOZmqb#
 dqpZZ00QQLLLLCCJJCUUUYUYUYUXYXYYYYYYYYYYUYYUYUYYUUUYUUUJJLLQ0Omwqb*
qpqwZZOO0QLQCCCJCUJYUUUUUUYXXYYYUUUUYUYYUYJUYUYUYYYUUUJJJULLQ00mwqba
pddpwmZ000QQCQCCLCJJCJUUJUJUUUUUUYUYJUUUUUYUYJUJUUUJUJUUCCLLQ0OOmpba
qkppwwmOOO0LQLLCCCCJJJJJJUJJJUCJUUUUUUUUUJUJJUJUJUUJUCCCCCLQ00OZqqh*
 kdbpmmZZO00QQQLQLCCCJCCUCJJJUJCUJJUUUUUJJUUUUJJYUJUUJJJCLLL00OZwqk#
 ahbdqwmmOZ0Q00LLLJCCCJJJCJJJJJCUJJJYUUJUUUUUUUUUUUJUJCJCLLQOQZmqdh#
 oohdqwwZZOO0QQLLQLQCCCCLLCLCCJJJJCUJUJJJJUUUUYUJJJCCCCCCCQ0OOmmpk#*
 d*abdqqwmmOOZ00OQLQ0LCLQCCCJCLCCCJCCJJUUUJUJUUJUJUJCCCCLCQOOmwpdh# 
  M#hkbqwmZmZOOO0Q00L0QLCLLQLLQLJCLCCJJCJCUJJJJJJJJCJJLLCQ0ZmwqpkaM 
   oohkddqwmmmOZOOO0LQL0LLQCL0LCLLLLLCJCJLJJJUUJJJJCCCLQ00OZmwqba*  
   WM*akbqppwmwZOZOQOO000LQLQQLCCLLLCCCCJJCCCCJCJCLCCCLQ0OZmppboo   
    MWohhdpwqwwmwOZZZOOO00QLQLQQLLLLLCCCLLLCLCLCLLJLLQ0ZOmmwdbaa    
     &W#hkbpqwqwqZZZZZZO000QQQ0QLLQLCLLCQCLQLLLLCLLQQL0ZZmwpbkap    
      8&#ohkbddpqwwmmmZOZOOO0OO0Q0Q0QLLQQLQLLQQ0QQQ00ZOmmqbdha      
       88WMohobdbpqpwwmqZZmZZZOQZO000Q0OQQQ00QQQ000OZmmqppkk*       
        M%8M#*okkbppdqqppmwZmmmwOOZZOO00O0O0O0O0OmZqqwqdbkho        
          B@8&M**ohkbbdqppqwqwwwwwZZZmZmOOOOOZZmmwwppbbkka          
            @@8&MW*ookkkbdpdpdqpqqwqpwZwZwwmqwqpppdpdkk*            
              $$%%&WM#*oahkkhkddppdpbqwpppppbpdkkbbhho              
                @$@B8&WM**#aoaahbkkhkhkbbkkbhhkhkkab                
                   $@%%8&WWM#M#*o**oooaoooaaaaook                   
                       @%%W&WWW#*##o*oa#**#M*                       
                             #88&&%8%&                              

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

Continue reading