La secuencia de juego de la vida más larga y no repetitiva

16

Dado un número entero positivo N, determine el patrón de inicio en una cuadrícula N x N que produzca la secuencia no repetida más larga según las reglas del Juego de la Vida, y termine con un patrón fijo (ciclo de longitud 1), jugado en un toro.

El objetivo no es el programa más corto, sino el más rápido.

Como el mundo es finito, eventualmente terminarás en un bucle, repitiendo así un estado ya visitado. Si este ciclo tiene período 1, entonces el patrón inicial es un candidato válido.

Salida: patrón de inicio y número total de estados únicos en la secuencia (incluido el patrón de inicio).

Ahora, el 1x1-toro es especial, ya que una célula puede considerarse vecina a sí misma o no, pero en la práctica, no hay problema, una sola célula viva en cualquier caso simplemente morirá (de hacinamiento o soledad). Por lo tanto, la entrada 1 produce una secuencia de longitud 2, la secuencia es una célula viva y luego muerta para siempre.

La motivación para esta pregunta es que es un análogo de la función de castor ocupado, pero definitivamente menos complejo, ya que tenemos un límite en la memoria. Esta será una buena secuencia para incluir también en OEIS.

Para N = 3, la longitud de la secuencia es 3, cualquier patrón en el lado izquierdo alcanza un cuadrado de 3x3 completamente negro, y luego muere. (Todos los patrones que forman parte de 1 ciclo se eliminan).

Gráfico de estados

Por Alexandersson
fuente
1
Ah, esta bien. El mejor código es el que logra calcular la longitud de secuencia para el N más grande dentro de, digamos 2 horas. La complejidad obvia es 2 ^ (N ^ 2), por lo que si es posible mejorar esto, sería bueno.
Según Alexandersson el
1
En tamaños no triviales, cada patrón es parte de una clase de isomorfismo de patrones 8N ^ 2, por lo que si hay una forma rápida de canonicalizar, eso da un impulso moderado.
Peter Taylor
1
¿Se ha agregado esta secuencia a OEIS?
mbomb007
1
No que yo sepa, estaría feliz de verlo allí.
Por Alexandersson
1
He enviado esta secuencia (2, 2, 3, 10, 52, 91) a la OEIS como A294241 .
Peter Kagey

Respuestas:

13

C ++ hasta N = 6

3x3 answer 3: 111 000 000                                                                                        
4x4 answer 10: 1110 0010 1100 0000                                                                               
5x5 answer 52: 11010 10000 11011 10100 00000                                                                     
6x6 answer 91: 100011 010100 110011 110100 101000 100000                                                         

Esta técnica se centra en una función rápida de estado siguiente. Cada placa se representa como una máscara de bits de N ^ 2 bits, y se utilizan trucos de bits para calcular el siguiente estado para todas las celdas a la vez. nextcompila hasta aproximadamente 200 100 instrucciones de ensamblaje para N <= 8. Luego, simplemente hacemos el estándar try-all-states-hasta que se repitan y elegimos el más largo.

Toma unos segundos hasta 5x5, unas pocas horas para 6x6.

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <algorithm>
using namespace std;

#define N 6

typedef uint64_t board;

// board is N bits by N bits, with indexes like this (N=4):                                                        
//  0  1  2  3                                                                                                     
//  4  5  6  7                                                                                                     
//  8  9 10 11                                                                                                     
// 12 13 14 15                                                                                                     

#if N==3
#define LEFT_COL (1 + (1<<3) + (1<<6))
#define RIGHT_COL ((1<<2) + (1<<5) + (1<<8))
#define ALL 0x1ffULL
#elif N==4
#define LEFT_COL 0x1111ULL
#define RIGHT_COL 0x8888ULL
#define ALL 0xffffULL
#elif N==5
#define LEFT_COL (1ULL + (1<<5) + (1<<10) + (1<<15) + (1<<20))
#define RIGHT_COL ((1ULL<<4) + (1<<9) + (1<<14) + (1<<19) + (1<<24))
#define ALL 0x1ffffffULL
#elif N==6
#define LEFT_COL (1 + (1<<6) + (1<<12) + (1<<18) + (1<<24) + (1ULL<<30))
#define RIGHT_COL ((1<<5) + (1<<11) + (1<<17) + (1<<23) + (1<<29) + (1ULL<<35))
#define ALL 0xfffffffffULL
#else
#error "bad N"
#endif

static inline board north(board b) {
  return (b >> N) + (b << N*N-N);
}
static inline board south(board b) {
  return (b << N) + (b >> N*N-N);
}
static inline board west(board b) {
  return ((b & ~LEFT_COL) >> 1) + ((b & LEFT_COL) << N-1);
}
static inline board east(board b) {
  return ((b & ~RIGHT_COL) << 1) + ((b & RIGHT_COL) >> N-1);
}

board next(board b) {
  board n1 = north(b);
  board n2 = south(b);
  board n3 = west(b);
  board n4 = east(b);
  board n5 = north(n3);
  board n6 = north(n4);
  board n7 = south(n3);
  board n8 = south(n4);

  // add all the bits bitparallel-y to a 2-bit accumulator with overflow
  board a0 = 0;
  board a1 = 0;
  board overflow = 0;
#define ADD(x) overflow |= a0 & a1 & x; a1 ^= a0 & x; a0 ^= x;

  a0 = n1; // no carry yet
  a1 ^= a0 & n2; a0 ^= n2; // no overflow yet
  a1 ^= a0 & n3; a0 ^= n3; // no overflow yet
  ADD(n4);
  ADD(n5);
  ADD(n6);
  ADD(n7);
  ADD(n8);
  return (a1 & (b | a0)) & ~overflow & ALL;
}
void print(board b) {
  for (int i = 0; i < N; i++) {
    for (int j = 0; j < N; j++) {
      printf("%d", (int)(b >> i*N+j & 1));
    }
    printf(" ");
  }
  if (b >> N*N) printf("*");
  printf("\n");
}

int main(int argc, char *argv[]) {
  // Somewhere in the starting pattern there are a 1 and 0 together.  Using translational                          
  // and rotational symmetry, we can put these in the first two bits.  So we need only consider                    
  // 1 mod 4 boards.                                                                                               

  board steps[10000];
  int maxsteps = -1;
  for (board b = 1; b < 1ULL << N*N; b += 4) {
    int nsteps = 0;
    board x = b;
    while (true) {
      int repeat = steps + nsteps - find(steps, steps + nsteps, x);
      if (repeat > 0) {
        if (repeat == 1 && nsteps > maxsteps) {
          printf("%d: ", nsteps);
          print(b);
          maxsteps = nsteps;
        }
        break;
      }
      steps[nsteps++] = x;
      x = next(x);
    }
  }
}
Keith Randall
fuente
1
Puede obtener una mejora moderada nextal contar en lugar de ordenar. #define H(x,y){x^=y;y&=(x^y);}y luego algo así comoH(n1,n2);H(n3,n4);H(n5,n6);H(n7,n8);H(n1,n3);H(n5,n7);H(n2,n4);H(n6,n8);H(n1,n5);H(n3,n7);H(n2,n6);H(n2,n3);H(n2,n5); return n2 & (b | n1) & ~(n3|n4|n5|n6|n7|n8) & ALL;
Peter Taylor
¡Una solución realmente genial!
Según Alexandersson el
@PeterTaylor: gracias, implementé (un esquema diferente para) el conteo, guardé un montón de instrucciones.
Keith Randall el
9

Veo los siguientes posibles enfoques de solución:

  • Teoría pesada Sé que hay literatura sobre la vida en un toro, pero no he leído mucho.
  • Fuerza bruta hacia delante: para cada tablero posible, verifique su puntaje. Esto es básicamente lo que hacen los enfoques de Matthew y Keith, aunque Keith reduce el número de tableros para verificar en un factor de 4.
    • Optimización: representación canónica. Si podemos verificar si un tablero está en representación canónica mucho más rápido de lo que se necesita para evaluar su puntaje, obtenemos una aceleración de un factor de aproximadamente 8N ^ 2. (También hay enfoques parciales con clases de equivalencia más pequeñas).
    • Optimización: DP. Guarde en caché el puntaje de cada tabla, de modo que en lugar de guiarlos hasta que converjan o diverjan, simplemente caminamos hasta encontrar una tabla que hayamos visto antes. En principio, esto daría una aceleración por un factor del puntaje promedio / duración del ciclo (tal vez 20 o más), pero en la práctica es probable que estemos intercambiando mucho. Por ejemplo, para N = 6 necesitaríamos capacidad para 2 ^ 36 puntajes, que a un byte por puntaje es de 16 GB, y necesitamos acceso aleatorio, por lo que no podemos esperar una buena localidad de caché.
    • Combina los dos. Para N = 6, la representación canónica completa nos permitiría reducir el caché DP a aproximadamente 60 megapuntos. Este es un enfoque prometedor.
  • Fuerza bruta hacia atrás. Esto parece extraño al principio, pero si suponemos que podemos encontrar fácilmente bodegones y que podemos invertir fácilmente la Next(board)función, vemos que tiene algunos beneficios, aunque no tantos como esperaba originalmente.
    • No nos molestamos con tablas divergentes en absoluto. No es un gran ahorro, porque son bastante raros.
    • No necesitamos almacenar puntuaciones para todos los tableros, por lo que debería haber menos presión de memoria que el enfoque DP directo.
    • Trabajar hacia atrás es bastante fácil variando una técnica que vi en la literatura en el contexto de enumerar bodegones. Funciona tratando cada columna como una letra en un alfabeto y luego observando que una secuencia de tres letras determina la del medio en la próxima generación. El paralelo con la enumeración de las naturalezas muertas es tan estrecha que los he refactorizado juntos en un método muy poco incómoda, Prev2.
    • Puede parecer que podemos canonizar las naturalezas muertas y obtener algo como la aceleración 8N ^ 2 por un costo muy bajo. Sin embargo, empíricamente todavía obtenemos una gran reducción en el número de tableros considerados si canonicalizamos en cada paso.
    • Una proporción sorprendentemente alta de tableros tiene una puntuación de 2 o 3, por lo que todavía hay presión de memoria. Me pareció necesario canonizar sobre la marcha en lugar de construir la generación anterior y luego canonizar. Puede ser interesante reducir el uso de memoria haciendo una búsqueda de profundidad primero en lugar de amplitud, pero hacerlo sin desbordar la pila y sin hacer cálculos redundantes requiere un enfoque de co-rutina / continuación para enumerar los tableros anteriores.

No creo que la microoptimización me permita ponerme al día con el código de Keith, pero por interés, publicaré lo que tengo. Esto resuelve N = 5 en aproximadamente un minuto en una máquina de 2 GHz usando Mono 2.4 o .Net (sin PLINQ) y en aproximadamente 20 segundos usando PLINQ; N = 6 carreras por muchas horas.

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

namespace Sandbox {
    class Codegolf9393 {
        internal static void Main() {
            new Codegolf9393(4).Solve();
        }

        private readonly int _Size;
        private readonly uint _AlphabetSize;
        private readonly uint[] _Transitions;
        private readonly uint[][] _PrevData1;
        private readonly uint[][] _PrevData2;
        private readonly uint[,,] _CanonicalData;

        private Codegolf9393(int size) {
            if (size > 8) throw new NotImplementedException("We need to fit the bits in a ulong");

            _Size = size;
            _AlphabetSize = 1u << _Size;

            _Transitions = new uint[_AlphabetSize * _AlphabetSize * _AlphabetSize];
            _PrevData1 = new uint[_AlphabetSize * _AlphabetSize][];
            _PrevData2 = new uint[_AlphabetSize * _AlphabetSize * _AlphabetSize][];
            _CanonicalData = new uint[_Size, 2, _AlphabetSize];

            InitTransitions();
        }

        private void InitTransitions() {
            HashSet<uint>[] tmpPrev1 = new HashSet<uint>[_AlphabetSize * _AlphabetSize];
            HashSet<uint>[] tmpPrev2 = new HashSet<uint>[_AlphabetSize * _AlphabetSize * _AlphabetSize];
            for (int i = 0; i < tmpPrev1.Length; i++) tmpPrev1[i] = new HashSet<uint>();
            for (int i = 0; i < tmpPrev2.Length; i++) tmpPrev2[i] = new HashSet<uint>();

            for (uint i = 0; i < _AlphabetSize; i++) {
                for (uint j = 0; j < _AlphabetSize; j++) {
                    uint prefix = Pack(i, j);
                    for (uint k = 0; k < _AlphabetSize; k++) {
                        // Build table for forwards checking
                        uint jprime = 0;
                        for (int l = 0; l < _Size; l++) {
                            uint count = GetBit(i, l-1) + GetBit(i, l) + GetBit(i, l+1) + GetBit(j, l-1) + GetBit(j, l+1) + GetBit(k, l-1) + GetBit(k, l) + GetBit(k, l+1);
                            uint alive = GetBit(j, l);
                            jprime = SetBit(jprime, l, (count == 3 || (alive + count == 3)) ? 1u : 0u);
                        }
                        _Transitions[Pack(prefix, k)] = jprime;

                        // Build tables for backwards possibilities
                        tmpPrev1[Pack(jprime, j)].Add(k);
                        tmpPrev2[Pack(jprime, i, j)].Add(k);
                    }
                }
            }

            for (int i = 0; i < tmpPrev1.Length; i++) _PrevData1[i] = tmpPrev1[i].ToArray();
            for (int i = 0; i < tmpPrev2.Length; i++) _PrevData2[i] = tmpPrev2[i].ToArray();

            for (uint col = 0; col < _AlphabetSize; col++) {
                _CanonicalData[0, 0, col] = col;
                _CanonicalData[0, 1, col] = VFlip(col);
                for (int rot = 1; rot < _Size; rot++) {
                    _CanonicalData[rot, 0, col] = VRotate(_CanonicalData[rot - 1, 0, col]);
                    _CanonicalData[rot, 1, col] = VRotate(_CanonicalData[rot - 1, 1, col]);
                }
            }
        }

        private ICollection<ulong> Prev2(bool stillLife, ulong next, ulong prev, int idx, ICollection<ulong> accum) {
            if (stillLife) next = prev;

            if (idx == 0) {
                for (uint a = 0; a < _AlphabetSize; a++) Prev2(stillLife, next, SetColumn(0, idx, a), idx + 1, accum);
            }
            else if (idx < _Size) {
                uint i = GetColumn(prev, idx - 2), j = GetColumn(prev, idx - 1);
                uint jprime = GetColumn(next, idx - 1);
                uint[] succ = idx == 1 ? _PrevData1[Pack(jprime, j)] : _PrevData2[Pack(jprime, i, j)];
                foreach (uint b in succ) Prev2(stillLife, next, SetColumn(prev, idx, b), idx + 1, accum);
            }
            else {
                // Final checks: does the loop round work?
                uint a0 = GetColumn(prev, 0), a1 = GetColumn(prev, 1);
                uint am = GetColumn(prev, _Size - 2), an = GetColumn(prev, _Size - 1);
                if (_Transitions[Pack(am, an, a0)] == GetColumn(next, _Size - 1) &&
                    _Transitions[Pack(an, a0, a1)] == GetColumn(next, 0)) {
                    accum.Add(Canonicalise(prev));
                }
            }

            return accum;
        }

        internal void Solve() {
            DateTime start = DateTime.UtcNow;
            ICollection<ulong> gen = Prev2(true, 0, 0, 0, new HashSet<ulong>());
            for (int depth = 1; gen.Count > 0; depth++) {
                Console.WriteLine("Length {0}: {1}", depth, gen.Count);
                ICollection<ulong> nextGen;

                #if NET_40
                nextGen = new HashSet<ulong>(gen.AsParallel().SelectMany(board => Prev2(false, board, 0, 0, new HashSet<ulong>())));
                #else
                nextGen = new HashSet<ulong>();
                foreach (ulong board in gen) Prev2(false, board, 0, 0, nextGen);
                #endif

                // We don't want the still lifes to persist or we'll loop for ever
                if (depth == 1) {
                    foreach (ulong stilllife in gen) nextGen.Remove(stilllife);
                }

                gen = nextGen;
            }
            Console.WriteLine("Time taken: {0}", DateTime.UtcNow - start);
        }

        private ulong Canonicalise(ulong board)
        {
            // Find the minimum board under rotation and reflection using something akin to radix sort.
            Isomorphism canonical = new Isomorphism(0, 1, 0, 1);
            for (int xoff = 0; xoff < _Size; xoff++) {
                for (int yoff = 0; yoff < _Size; yoff++) {
                    for (int xdir = -1; xdir <= 1; xdir += 2) {
                        for (int ydir = 0; ydir <= 1; ydir++) {
                            Isomorphism candidate = new Isomorphism(xoff, xdir, yoff, ydir);

                            for (int col = 0; col < _Size; col++) {
                                uint a = canonical.Column(this, board, col);
                                uint b = candidate.Column(this, board, col);

                                if (b < a) canonical = candidate;
                                if (a != b) break;
                            }
                        }
                    }
                }
            }

            ulong canonicalValue = 0;
            for (int i = 0; i < _Size; i++) canonicalValue = SetColumn(canonicalValue, i, canonical.Column(this, board, i));
            return canonicalValue;
        }

        struct Isomorphism {
            int xoff, xdir, yoff, ydir;

            internal Isomorphism(int xoff, int xdir, int yoff, int ydir) {
                this.xoff = xoff;
                this.xdir = xdir;
                this.yoff = yoff;
                this.ydir = ydir;
            }

            internal uint Column(Codegolf9393 _this, ulong board, int col) {
                uint basic = _this.GetColumn(board, xoff + col * xdir);
                return _this._CanonicalData[yoff, ydir, basic];
            }
        }

        private uint VRotate(uint col) {
            return ((col << 1) | (col >> (_Size - 1))) & (_AlphabetSize - 1);
        }

        private uint VFlip(uint col) {
            uint replacement = 0;
            for (int row = 0; row < _Size; row++)
                replacement = SetBit(replacement, row, GetBit(col, _Size - row - 1));
            return replacement;
        }

        private uint GetBit(uint n, int bit) {
            bit %= _Size;
            if (bit < 0) bit += _Size;

            return (n >> bit) & 1;
        }

        private uint SetBit(uint n, int bit, uint value) {
            bit %= _Size;
            if (bit < 0) bit += _Size;

            uint mask = 1u << bit;
            return (n & ~mask) | (value == 0 ? 0 : mask);
        }

        private uint Pack(uint a, uint b) { return (a << _Size) | b; }
        private uint Pack(uint a, uint b, uint c) {
            return (((a << _Size) | b) << _Size) | c;
        }

        private uint GetColumn(ulong n, int col) {
            col %= _Size;
            if (col < 0) col += _Size;
            return (_AlphabetSize - 1) & (uint)(n >> (col * _Size));
        }

        private ulong SetColumn(ulong n, int col, uint value) {
            col %= _Size;
            if (col < 0) col += _Size;

            ulong mask = (_AlphabetSize - 1) << (col * _Size);
            return (n & ~mask) | (((ulong)value) << (col * _Size));
        }
    }
}
Peter Taylor
fuente
También estoy trabajando en otra versión para caminar hacia atrás desde puntos fijos. Ya he enumerado los puntos fijos hasta N = 8 (para N = 8 hay 84396613 de ellos antes de la canonicalización). Tengo un trabajo previo simple, pero es demasiado lento. Parte del problema es solo el tamaño de las cosas, para N = 6 el tablero vacío tiene 574384901 predecesores (antes de la canonicalización).
Keith Randall el
1
3 días y 11 horas para confirmar que 91 es la respuesta para 6x6.
Peter Taylor
1

Factor

USING: arrays grouping kernel locals math math.functions math.parser math.order math.ranges math.vectors sequences sequences.extras ;
IN: longest-gof-pattern

:: neighbors ( x y game -- neighbors )
game length :> len 
x y game -rot 2array {
    { -1 -1 }
    { -1 0 }
    { -1 1 }
    { 0 -1 }
    { 0 1 }
    { 1 -1 }
    { 1 0 }
    { 1 1 }
} [
    v+ [
        dup 0 <
        [ dup abs len mod - abs len mod ] [ abs len mod ]
        if
    ] map
] with map [ swap [ first2 ] dip nth nth ] with map ;

: next ( game -- next )
dup [
    [
        neighbors sum
        [ [ 1 = ] [ 2 3 between? ] bi* and ]
        [ [ 0 = ] [ 3 = ] bi* and ] 2bi or 1 0 ?
    ] curry curry map-index
] curry map-index ;

: suffixes ( seq -- suffixes )
{ }
[ [ [ suffix ] curry map ] [ 1array 1array ] bi append ]
reduce ;

! find largest repeating pattern
: LRP ( seq -- pattern )
dup length iota
[ 1 + [ reverse ] dip group [ reverse ] map reverse ] with
map dup [ dup last [ = ] curry map ] map
[ suffixes [ t [ and ] reduce ] map [ ] count ] map
dup supremum [ = ] curry find drop swap nth last ;

: game-sequence ( game -- seq )
1array [
    dup [
        dup length 2 >
        [ 2 tail-slice* [ first ] [ last ] bi = not ]
        [ drop t ] if
    ] [ LRP length 1 > not ] bi and
] [ dup last next suffix ] while ;

: pad-to-with ( str len padstr -- rstr )
[ swap dup length swapd - ] dip [ ] curry replicate ""
[ append ] reduce prepend ;

:: all-NxN-games ( n -- games )
2 n sq ^ iota [
    >bin n sq "0" pad-to-with n group
    [ [ 48 = 0 1 ? ] { } map-as ] map
] map ;

: longest-gof-pattern ( n -- game )
all-NxN-games [ game-sequence ] map [ length ] supremum-by but-last ;

Algunas estadísticas de tiempo:

IN: longest-gof-pattern [ 3 longest-gof-pattern ] time dup length . . 
Running time: 0.08850873500000001 seconds

3
{
   { { 1 1 1 } { 0 0 0 } { 0 0 0 } }
   { { 1 1 1 } { 1 1 1 } { 1 1 1 } }
   { { 0 0 0 } { 0 0 0 } { 0 0 0 } }
}

IN: longest-gof-pattern [ 4 longest-gof-pattern ] time dup length . . 
Running time: 49.667698828 seconds

10
{
  { { 0 1 1 0 } { 0 1 0 0 } { 0 1 0 0 } { 1 1 0 1 } }
  { { 0 1 1 0 } { 0 1 0 0 } { 0 1 0 0 } { 0 0 0 1 } }
  { { 0 1 1 0 } { 0 1 0 0 } { 0 0 1 0 } { 1 1 0 0 } }
  { { 0 1 1 0 } { 0 1 0 0 } { 0 0 1 0 } { 0 0 0 1 } }
  { { 0 1 1 0 } { 0 1 0 0 } { 0 0 1 0 } { 1 1 0 1 } }
  { { 0 1 1 0 } { 0 1 0 0 } { 0 0 1 1 } { 0 0 0 1 } }
  { { 0 1 0 1 } { 0 1 0 1 } { 0 0 1 1 } { 1 1 0 1 } }
  { { 1 1 0 1 } { 1 1 0 1 } { 0 0 0 0 } { 1 1 0 0 } }
  { { 1 1 0 1 } { 1 1 0 1 } { 0 0 1 1 } { 1 1 1 1 } }
  { { 0 0 0 0 } { 0 0 0 0 } { 0 0 0 0 } { 0 0 0 0 } }
}

Y la prueba 5 estrelló el REPL. Hmph La parte más ineficiente del programa es probablemente la función secuencia del juego. Tal vez pueda mejorarlo más tarde.

Matthew Rolph
fuente
¡Frio! Creo que su salida es 1 demasiado grande, para patrones de 3x3, la secuencia no repetida más larga tiene una longitud 3, no 4 ...
Por Alexandersson