Welcome to the Lounge

Test length  48 th : 526646 526,646
Test length  49 th : 686646 686,646
Test length  50 th : 894810 894,810
 51st  length : 1,166,642
 52nd  length : 1,521,070
 53rd  length : 1,983,164
 54th  length : 2,585,639
 55th  length : 3,371,142
 56th  length : 4,395,278
 57th  length : 5,730,540
 58th  length : 7,471,449
 59th  length : 9,741,236
 60th  length : 12,700,573
 61st  length : 16,558,941
 62nd  length : 21,589,461
 63rd  length : 28,148,228
 64th  length : 36,699,513
 65th  length : 47,848,635
 66th  length : 62,384,802
 67th  length : 81,336,981
 68th  length : 106,046,733
 69th  length : 138,263,181
 70th  length : 180,266,818
 71st  length : 235,030,941
 72nd  length : 306,432,122
 73rd  length : 399,524,610
 74th  length : 520,898,113
 75th  length : 679,144,257
 76th  length : 885,464,758
 77th  length : 1,154,464,356
 78th  length : 1,505,184,637
 79th  length : 1,962,451,918
 80th  length : 2,558,634,627
 81st  length : 3,335,934,550
 82nd  length : 4,349,374,155
 83rd  length : 5,670,691,453
 84th  length : 7,393,418,089
 85th  length : 9,639,500,137
 86th  length : 12,567,930,256
 87th  length : 16,386,002,249
 88th  length : 21,363,984,700
 89th  length : 27,854,252,387
 90th  length : 36,316,229,718
 91st  length : 47,348,911,849
 92nd  length : 61,733,265,560
 93rd  length : 80,487,511,283
 94th  length : 104,939,199,534
 95th  length : 136,819,183,789
 96th  length : 178,384,141,824
 97th  length : 232,576,318,416
 98th  length : 303,231,797,036
 99th  length : 395,352,043,407
100th  length : 515,457,942,582

string Morris(int S, int N)
        {            
            string projectPath = System.IO.Path.GetFullPath(@"..\..\..\");
            using (BinaryWriter writer = new BinaryWriter(File.Open(projectPath + "input.txt", FileMode.Create)))
            {
                writer.Write(S > 2);
                writer.Write(S == 2);
            }


            for (int i = 1; i < N; i++)
            {
                Debug.WriteLine(i+1);

                using (BinaryReader reader = new BinaryReader(File.Open(projectPath + "input.txt", FileMode.Open)))
                {
                    int count = 1;
                    bool currMSB = reader.ReadBoolean();
                    bool currLSB = reader.ReadBoolean();

                    bool nextMSB, nextLSB;

                    using (BinaryWriter writer = new BinaryWriter(File.Open(projectPath + "output.txt", FileMode.Create)))
                    {
                        while (reader.BaseStream.Position != reader.BaseStream.Length)
                        {
                            nextMSB = reader.ReadBoolean();
                            nextLSB = reader.ReadBoolean();

                            if ((currMSB == nextMSB) && (currLSB == nextLSB))
                            {
                                count++;
                            }
                            else
                            {
                                writer.Write(count > 2);
                                writer.Write(count == 2);
                                writer.Write(currMSB);
                                writer.Write(currLSB);

                                currMSB = nextMSB;
                                currLSB = nextLSB;
                                count = 1;
                            }

                        }
                        writer.Write(count > 2);
                        writer.Write(count == 2);
                        writer.Write(currMSB);
                        writer.Write(currLSB);
                    }
                }

                File.Delete(projectPath + "input.txt");
                System.IO.File.Copy(projectPath + "output.txt", projectPath + "input.txt");
                System.IO.File.WriteAllText(projectPath + "output.txt", string.Empty);
            }


            StringBuilder output = new StringBuilder();
            using (BinaryReader reader = new BinaryReader(File.Open(projectPath + "input.txt", FileMode.Open)))
            {
                bool nextMSB, nextLSB;
                while (reader.BaseStream.Position != reader.BaseStream.Length)
                {
                    nextMSB = reader.ReadBoolean();
                    nextLSB = reader.ReadBoolean();
                    if (nextMSB)
                        output.Append("3");
                    else
                    {
                        if (nextLSB)
                            output.Append("2");
                        else
                            output.Append("1");
                    }

                }
            }

            return output.ToString();
        }

string MorrisBitVector32(int S, int N)
      {
          //Need the mask for accessing the individual bits
          int[] _masks = new int[32];
          {
              _masks[0] = BitVector32.CreateMask();
          }
          for (int i = 1; i < 32; i++)
          {
              _masks[i] = BitVector32.CreateMask(_masks[i - 1]);
          }

          //Hopefully setes the path to the project folder
          string projectPath = System.IO.Path.GetFullPath(@"..\..\..\");


          using (BinaryWriter writer = new BinaryWriter(File.Open(projectPath + "input.txt", FileMode.Create)))
          {
              BitVector32 v = new BitVector32();
              // Standard 3 = 11, 2=10,1=01 and
              // 00 is not more numbers in this BitVector32
              v[_masks[0]] = S >= 2;
              v[_masks[1]] = S != 2;
              //Writes a 32bit integer to the file
              writer.Write(v.Data);
          }


          for (int i = 1; i < N; i++)
          {
              Debug.WriteLine(i + 1);

              using (BinaryReader reader = new BinaryReader(File.Open(projectPath + "input.txt", FileMode.Open)))
              {
                  // Initiates variables for each N run
                  bool currMSB, currLSB, firstRun;
                  firstRun = true;
                  currMSB = false;
                  currLSB = false;
                  int count = 0;
                  int k = 0;
                  BitVector32 outputBits = new BitVector32();

                  using (BinaryWriter writer = new BinaryWriter(File.Open(projectPath + "output.txt", FileMode.Create)))
                  {

                      while (reader.BaseStream.Position != reader.BaseStream.Length)
                      {
                          BitVector32 inputBits = new BitVector32(reader.ReadInt32());
                          if (firstRun)
                          {
                              count = 1;
                              currMSB = inputBits[_masks[0]];
                              currLSB = inputBits[_masks[1]];
                          }


                          bool nextMSB, nextLSB;
                          for (int j = (firstRun ? 2 : 0); j < 32; j += 2)
                          {
                              nextMSB = inputBits[_masks[j]];
                              nextLSB = inputBits[_masks[j + 1]];

                              // If both values are zero that means that there
                              // are no more values in the BitVector32
                              if (!(nextLSB || nextMSB))
                              {
                                  break;
                              }

                              // The values continue
                              if ((currMSB == nextMSB) && (currLSB == nextLSB))
                              {
                                  count++;
                              }

                              // New values found sore and perhaps write to file
                              else
                              {
                                  if (k == 32)
                                  {
                                      //BitVector32 is full, need to store and create a new one
                                      writer.Write(outputBits.Data);
                                      outputBits = new BitVector32();
                                      k = 0;

                                      outputBits[_masks[k]] = count >= 2;
                                      k++;
                                      outputBits[_masks[k]] = count != 2;
                                      k++;
                                      outputBits[_masks[k]] = currMSB;
                                      k++;
                                      outputBits[_masks[k]] = currLSB;
                                      k++;
                                      currMSB = nextMSB;
                                      currLSB = nextLSB;
                                      count = 1;
                                  }
                                  else
                                  {
                                      //More room left in the BitVector32
                                      outputBits[_masks[k]] = count >= 2;
                                      k++;
                                      outputBits[_masks[k]] = count != 2;
                                      k++;
                                      outputBits[_masks[k]] = currMSB;
                                      k++;
                                      outputBits[_masks[k]] = currLSB;
                                      k++;
                                      currMSB = nextMSB;
                                      currLSB = nextLSB;
                                      count = 1;
                                  }
                              }

                              // Used to initiate the current number
                              if (firstRun)
                                  firstRun = false;
                          }
                      }

                      //Write out the remaining data
                      if (k == 32)
                      {
                          writer.Write(outputBits.Data);
                          outputBits = new BitVector32();
                          k = 0;

                          outputBits[_masks[k]] = count >= 2;
                          k++;
                          outputBits[_masks[k]] = count != 2;
                          k++;
                          outputBits[_masks[k]] = currMSB;
                          k++;
                          outputBits[_masks[k]] = currLSB;
                          k++;
                          writer.Write(outputBits.Data);
                      }
                      else
                      {

                          outputBits[_masks[k]] = count >= 2;
                          k++;
                          outputBits[_masks[k]] = count != 2;
                          k++;
                          outputBits[_masks[k]] = currMSB;
                          k++;
                          outputBits[_masks[k]] = currLSB;
                          k++;
                          writer.Write(outputBits.Data);
                      }
                  }
              }

              // Exchange the input and output files
              File.Delete(projectPath + "input.txt");
              System.IO.File.Copy(projectPath + "output.txt", projectPath + "input.txt");
              System.IO.File.WriteAllText(projectPath + "output.txt", string.Empty);
          }


          StringBuilder output = new StringBuilder();
          using (BinaryReader reader = new BinaryReader(File.Open(projectPath + "input.txt", FileMode.Open)))
          {
              bool nextMSB, nextLSB;
              while (reader.BaseStream.Position != reader.BaseStream.Length)
              {
                  BitVector32 InputData = new BitVector32(reader.ReadInt32());
                  for (int i = 0; i < 32; i+=2)
                  {
                      nextMSB = InputData[_masks[i]];
                      nextLSB= InputData[_masks[i+1]];

                      if (!(nextLSB || nextMSB))
                          break;

                      if (nextMSB && nextLSB)
                          output.Append("3");
                      else
                      {
                          if (nextMSB)
                              output.Append("2");
                          else
                              output.Append("1");
                      }

                  }
              }
          }

          return output.ToString();
      }

level 1 size = 1
level 2 size = 2
level 3 size = 2
level 4 size = 4
level 5 size = 6
level 6 size = 6
level 7 size = 8
level 8 size = 10
level 9 size = 14
level 10 size = 20
level 11 size = 26
level 12 size = 34
level 13 size = 46
level 14 size = 62
level 15 size = 78
level 16 size = 102
level 17 size = 134
level 18 size = 176
level 19 size = 226
level 20 size = 302
level 21 size = 408
level 22 size = 528
level 23 size = 678
level 24 size = 904
level 25 size = 1182
level 26 size = 1540
level 27 size = 2012
level 28 size = 2606
level 29 size = 3410
level 30 size = 4462
level 31 size = 5808
level 32 size = 7586
level 33 size = 9898
level 34 size = 12884
level 35 size = 16774
level 36 size = 21890
level 37 size = 28528
level 38 size = 37158
level 39 size = 48410
level 40 size = 63138
level 41 size = 82350
level 42 size = 107312
level 43 size = 139984
level 44 size = 182376
level 45 size = 237746
level 46 size = 310036
level 47 size = 403966
level 48 size = 526646
level 49 size = 686646
level 50 size = 894810
level 51 size = 1166642
level 52 size = 1520986
level 53 size = 1982710
level 54 size = 2584304
level 55 size = 3369156
level 56 size = 4391702
level 57 size = 5724486
level 58 size = 7462860
level 59 size = 9727930
level 60 size = 12680852
level 61 size = 16530884
level 62 size = 21549544
level 63 size = 28091184
level 64 size = 36619162
level 65 size = 47736936
level 66 size = 62226614
level 67 size = 81117366
level 68 size = 105745224
level 69 size = 137842560
level 70 size = 179691598
level 71 size = 234241786
level 72 size = 305351794
level 73 size = 398049970
level 74 size = 518891358
level 75 size = 676414798
level 76 size = 881752750
level 77 size = 1149440192
level 78 size = 1498380104
level 79 size = 1953245418
level 80 size = 2546222700
level 81 size = 3319186080
level 82 size = 4326816254
level 83 size = 5640348764
level 84 size = 7352630884
level 85 size = 9584715106
level 86 size = 12494412020
level 87 size = 16287462624
level 88 size = 21231903676
level 89 size = 27677468012
level 90 size = 36079732206
level 91 size = 47032657188
level 92 size = 61310766500
level 93 size = 79923316046
level 94 size = 104186199146
level 95 size = 135814773100
level 96 size = 177045063068
level 97 size = 230791944956
level 98 size = 300854953626
level 99 size = 392187941864
level 100 size = 511247092564
finished computation at Fri Dec  1 16:48:41 2017
elapsed time: 7205.75secs