init

.gitignore

@@ -0,0 +1 @@
+main

.vscode/c_cpp_properties.json

@@ -0,0 +1,16 @@
+{
+    "configurations": [
+        {
+            "name": "Linux",
+            "includePath": [
+                "${workspaceFolder}/**"
+            ],
+            "defines": [],
+            "compilerPath": "/usr/bin/gcc",
+            "cStandard": "c11",
+            "cppStandard": "gnu++14",
+            "intelliSenseMode": "linux-gcc-x64"
+        }
+    ],
+    "version": 4
+}

.vscode/settings.json

@@ -0,0 +1,44 @@
+{
+  "files.associations": {
+    "iostream": "cpp",
+    "array": "cpp",
+    "atomic": "cpp",
+    "*.tcc": "cpp",
+    "cctype": "cpp",
+    "clocale": "cpp",
+    "cmath": "cpp",
+    "cstdarg": "cpp",
+    "cstddef": "cpp",
+    "cstdint": "cpp",
+    "cstdio": "cpp",
+    "cstdlib": "cpp",
+    "cwchar": "cpp",
+    "cwctype": "cpp",
+    "deque": "cpp",
+    "unordered_map": "cpp",
+    "vector": "cpp",
+    "exception": "cpp",
+    "algorithm": "cpp",
+    "memory": "cpp",
+    "memory_resource": "cpp",
+    "optional": "cpp",
+    "string": "cpp",
+    "string_view": "cpp",
+    "system_error": "cpp",
+    "tuple": "cpp",
+    "type_traits": "cpp",
+    "utility": "cpp",
+    "fstream": "cpp",
+    "initializer_list": "cpp",
+    "iosfwd": "cpp",
+    "istream": "cpp",
+    "limits": "cpp",
+    "new": "cpp",
+    "ostream": "cpp",
+    "sstream": "cpp",
+    "stdexcept": "cpp",
+    "streambuf": "cpp",
+    "typeinfo": "cpp",
+    "thread": "cpp"
+  }
+}

.vscode/tasks.json

@@ -0,0 +1,29 @@
+{
+  "tasks": [
+    {
+      "type": "cppbuild",
+      "label": "C/C++: g++ Aktive Datei kompilieren",
+      "command": "/usr/bin/g++",
+      "args": [
+        "-pthread",
+        "-fdiagnostics-color=always",
+        "-g",
+        "${file}",
+        "-o",
+        "${fileDirname}/${fileBasenameNoExtension}"
+      ],
+      "options": {
+        "cwd": "${fileDirname}"
+      },
+      "problemMatcher": [
+        "$gcc"
+      ],
+      "group": {
+        "kind": "build",
+        "isDefault": true
+      },
+      "detail": "Vom Debugger generierte Aufgabe."
+    }
+  ],
+  "version": "2.0.0"
+}

README.md

@@ -0,0 +1,49 @@
+# Tic-Tac-Toe Simulator
+
+## Aufbau des 64-bit Feldes eines Spielers
+```
+       x                 --y--
+   0  1  2  3  16 17 18 19  32 33 34 35  48 49 50 51
+z  4  5  6  7  20 21 22 23  36 37 38 39  52 53 54 55
+   8  9 10 11  24 25 26 27  40 41 42 43  56 57 58 59
+  12 13 14 15  28 29 30 31  44 45 46 47  60 61 62 63
+
+```
+## Win conditions
+```
+ 0  5 10 15
+16 21 26 31
+...
+
+ 3  6  9 12
+...
+
+ 0 17 34 51
+ 4 21 38 55
+...
+
+ 3 18 33 48
+...
+
+ 0 20 40 60
+ 1 21 41 61
+...
+
+12 24 36 48
+13 25 37 49
+...
+
+ 0 21 42 63
+ 3 22 41 60
+12 25 38 51
+15 26 37 48
+```
+
+## Wins für den 1. Spieler (aus 1000000 Spielen)
+
+```
+572453 536084 536313 572186
+537366 566733 566637 536793
+536987 566019 565855 536289
+571080 536828 536191 573755
+```

main.cpp

@@ -0,0 +1,140 @@
+#include <iostream>
+#include <stdlib.h>
+#include <bits/stdc++.h>
+#include <thread>
+using namespace std;
+
+class Game {
+  unsigned long white = 0, black = 0;
+
+  public:
+  void print() {
+    for(int i=0; i<4; i++) {
+      for(int j=0; j<4; j++) {
+        for(int k=0; k<4; k++) {
+          bool w = white >> (k + i*4 + j*16) & 1;
+          bool b = black >> (k + i*4 + j*16) & 1;
+          cout << (b&&w ? 'E' : (w ? 'W' : (b ? 'B' : '.')));
+
+        }
+        cout << ' ';
+      }
+      cout << endl;
+    }
+    cout << endl;
+  }
+
+  int freeLocations() {
+    return ((white | black) >> 16*3) ^ 0xFFFF;
+  }
+
+  bool place(unsigned long & map) {
+    int locations = freeLocations();
+    if(locations == 0)
+      return false;
+    int choice;
+    do {
+      choice = rand() % 16;
+    } while ((locations & (1 << choice)) == 0);
+
+    for(int i=0; i<4; i++) {
+      if(((black|white) & 1UL << (i*16 + choice)) == 0) {
+          map |= 1UL << (i*16 + choice);
+        break;
+      }
+    }
+
+    return true;
+  }
+  int check(unsigned long set) {
+    for(int i=0; i<4; i++) {
+      for(int j=0; j<4; j++) {
+        // horizontal x
+        if((set >> (i*4 + j*16) & 15) == 15) return 1;
+        // vertical y
+        if((set >> (i + j*4) & 0x1000100010001UL) == 0x1000100010001UL) return 2;
+        // horizontal z
+        if((set >> (i + j*16) & 0x1111) == 0x1111) return 3;
+      }
+      // diagonal xz
+      if((set >> i*16 & 0x8421) == 0x8421) return 10;
+      if((set >> i*16 & 0x1248) == 0x1248) return 11;
+      // diagonal xy
+      if((set >> i*4 & 0x8000400020001UL) == 0x8000400020001UL) return 20;
+      if((set >> i*4 & 0x1000200040008UL) == 0x1000200040008UL) return 21;
+      // diagonal yz
+      if((set >> i & 0x1000010000100001UL) == 0x1000010000100001UL) return 30;
+      if((set >> i & 0x1001001001000UL) == 0x1001001001000UL) return 31;
+
+    }
+    // diagonal xyz
+    if((set & 0x8000040000200001UL) == 0x8000040000200001UL) return 40;
+    if((set & 0x1000020000400008UL) == 0x1000020000400008UL) return 41;
+    if((set & 0x8004002001000UL) == 0x8004002001000UL) return 50;
+    if((set & 0x1002004008000UL) == 0x1002004008000UL) return 51;
+
+    return 0;
+  }
+
+  int play(int startPosition) {
+    white = 1 << startPosition;
+    black = 0;
+    while(freeLocations()) {
+      place(black);
+      //print();
+      int result = check(black);
+      if(result) {
+        return -result;
+      }
+      place(white);
+      //print();
+      result = check(white);
+      if(result) {
+        return result;
+      }
+    }
+  }
+};
+
+
+void do_work(int startPosition) {
+  int whiteCount=0, blackCount=0, draw=0, x=0, y=0, z=0, xy=0, xz=0, yz=0, xyz=0;
+  for(int i=1; i<=1000000; i++) {
+    Game game;
+    int result = game.play(startPosition);
+    if(result > 0)
+      whiteCount++;
+    if(result < 0)
+      blackCount++;
+    if(result == 0)
+      draw++;
+    else if(abs(result) == 1)
+      x++;
+    else if(abs(result) == 2)
+      y++;
+    else if(abs(result) == 3)
+      z++;
+    else if(abs(result) < 20)
+      xz++;
+    else if(abs(result) < 30)
+      xy++;
+    else if(abs(result) < 40)
+      yz++;
+    else
+      xyz++;
+    
+  }
+  printf(
+    "Start position: %d White: %d Black: %d Draw: %d x: %d y: %d z: %d xz: %d xy: %d yz: %d xyz: %d\n", 
+    startPosition, whiteCount, blackCount, draw, x, y, z, xz, xy, yz, xyz);
+}
+
+int main() {
+  list<thread> threads;
+  for(int i=0; i<16; i++) {
+    threads.push_front(thread(do_work, i));
+  }
+  for(auto &t : threads) {
+    t.join();
+  }
+}