Daniel's Solutions to FiveThirtyEight.com's The Riddler

using System;
using System.Collections.Generic;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Text;
using MIConvexHull;

namespace Sampler
{
   class Program
   {
      static void Main(string[] args)
      {
         // get all images in directory, sorted by name
         DirectoryInfo directory = new DirectoryInfo("/slices/");
         List<FileInfo> files = directory.GetFiles("*.gif").OrderBy(p => p.Name).ToList();
         int current = 0;
         List<Point> points = new List<Point>();
         StringBuilder pointcloudBuilder = new StringBuilder();
         int overallNumSamples = 0;

         foreach (FileInfo file in files)
         {
            Bitmap bitmap = new Bitmap(Image.FromFile(file.FullName));
            double z = current++;

            int numSamples = 0;

            for (int x = 0; x < bitmap.Width; x += 10)
            {
               for (int y = 0; y < bitmap.Height; y += 10)
               {
                  // perform sample
                  Color color = bitmap.GetPixel(x, y);

                  // add point to list, if needed
                  if (color.R < 250 || color.G < 250 || color.B < 250)
                  {
                     numSamples++;
                     points.Add(new Point(){x=x, y=y, z=z});
                     pointcloudBuilder.AppendLine($"{x} {y} {z}");
                  }
               }
            }

            overallNumSamples += numSamples;

            Console.WriteLine($"file {file.Name} had {numSamples} samples written");
         }

         double[][] vertices = new double[overallNumSamples][];

         for (int i = 0; i < vertices.Length; i++)
         {
            vertices[i] = new[] {points[i].x, points[i].y, points[i].z};
         }

         var convexHull = ConvexHull.Create(vertices);

         StringBuilder objBuilder = new StringBuilder();

         int vertexIndex = 1;

         foreach (DefaultConvexFace<DefaultVertex> face in convexHull.Result.Faces)
         {
            objBuilder.AppendLine($"v {face.Vertices[0].Position[0]} {face.Vertices[0].Position[1]} {face.Vertices[0].Position[2]}");
            objBuilder.AppendLine($"v {face.Vertices[1].Position[0]} {face.Vertices[1].Position[1]} {face.Vertices[1].Position[2]}");
            objBuilder.AppendLine($"v {face.Vertices[2].Position[0]} {face.Vertices[2].Position[1]} {face.Vertices[2].Position[2]}");
            objBuilder.AppendLine($"f {vertexIndex++} {vertexIndex++} {vertexIndex++}");
         }

         // write point list to file
         File.WriteAllText("pointcloud.txt", pointcloudBuilder.ToString());
         File.WriteAllText("convexhull.obj", objBuilder.ToString());
      }
   }

   class Point
   {
      public double x, y, z;
   }
}

private static readonly string[] States = new string[]
{
   "AL", "AK", "AS", "AZ", "AR", "CA", "CO", "CT", "DE", "DC", "FM", "FL", "GA", "GU", "HI", "ID", "IL", "IN", "IA", "KS", "KY", "LA", "ME", "MH", "MD", "MA", "MI", "MN", "MS", "MO", "MT", "NE", "NV", "NH", "NJ", "NM", "NY", "NC", "ND", "MP", "OH", "OK", "OR", "PW", "PA", "PR", "RI", "SC", "SD", "TN", "TX", "UT", "VT", "VI", "VA", "WA", "WV", "WI", "WY"
};

private static List<Transition> GetTransitions()
{
   List<Transition> transitions = new List<Transition>();

   foreach (string firstState in States)
   {
      char second = firstState[1];
      foreach (string secondState in States)
      {
         char first = secondState[0];
         if (first == second && firstState != secondState)
         {
            transitions.Add(new Transition() { x = firstState, y = secondState});
         }
      }
   }
   return transitions;
}

using System;
using System.Collections.Generic;
using System.Linq;

namespace StateNameStrings
{
   class Program
   {
      private static readonly string[] States = new string[]
      {
         "AL", "AK", "AS", "AZ", "AR", "CA", "CO", "CT", "DE", "DC", "FM", "FL", "GA", "GU", "HI", "ID", "IL", "IN", "IA", "KS", "KY", "LA", "ME", "MH", "MD", "MA", "MI", "MN", "MS", "MO", "MT", "NE", "NV", "NH", "NJ", "NM", "NY", "NC", "ND", "MP", "OH", "OK", "OR", "PW", "PA", "PR", "RI", "SC", "SD", "TN", "TX", "UT", "VT", "VI", "VA", "WA", "WV", "WI", "WY"
      };

      static void Main(string[] args)
      {
         List<Transition> allTransitions = GetTransitions();

         string overallLongest = string.Empty;

         foreach (var state in States)
         {
            List<Transition> startingChain = new List<Transition>();
            string longest = string.Empty;
            TryNextRecursive(startingChain, state);

            void TryNextRecursive(List<Transition> chain, string currentLongest)
            {
               // get the current node
               string startingState = chain.LastOrDefault()?.y ?? state;

               // get available transitions from current node
               List<Transition> nextTransitions = allTransitions
                  .Where(p => p.x == startingState)
                  .Except(chain)
                  .ToList();

               while (nextTransitions.Any())
               {
                  // if a transition is available, try it
                  Transition next = nextTransitions.First();
                  nextTransitions.Remove(next);
                  string proposed = currentLongest + next.y.Substring(1, 1);

                  if (!IsDoubled(proposed))
                  {
                     chain.Add(next);
                     TryNextRecursive(chain, proposed);
                  }
               }

               if (currentLongest.Length > longest.Length)
               {
                  longest = currentLongest;
               }
            }
            Console.WriteLine($"{state} => {longest}");
            if (longest.Length > overallLongest.Length)
            {
               overallLongest = longest;
            }
         }
         Console.WriteLine($"Overall longest: {overallLongest}");
      }

      private static bool IsDoubled(string proposed)
      {
         for (int i = 0; i < proposed.Length - 1; i++)
         {
            string sentinel = proposed.Substring(i, 2);
            for (int j = i + 1; j < proposed.Length - 1; j++)
            {
               string potentialMatch = proposed.Substring(j, 2);
               if (sentinel == potentialMatch)
                  return true;
            }
         }
         return false;
      }

      private static List<Transition> GetTransitions()
      {
         List<Transition> transitions = new List<Transition>();

         foreach (string firstState in States)
         {
            char second = firstState[1];
            foreach (string secondState in States)
            {
               char first = secondState[0];
               if (first == second && firstState != secondState)
               {
                  transitions.Add(new Transition() { x = firstState, y = secondState});
               }
            }
         }
         return transitions;
      }
   }

   class Transition
   {
      public string x, y;
   }
}