language-agnostic - online - life of conway

Code Golf: el juego de la vida de Conway (24)

Haskell - 284 272 232 caracteres

import System main=do f:n:_<-getArgs;s<-readFile f;writeFile"out.txt"$t s$read n p ''/n''_=''/n'' p ''X''2=''X'' p _ 3=''X'' p _ _=''.'' t r 0=r t r n=t[p(r!!m)$sum[1|d<-1:[80..82],s<-[1,-1],-m<=d*s,m+d*s<3240,''X''==r!!(m+d*s)]|m<-[0..3239]]$n-1

El desafío: escriba el programa más corto que implemente el autómata celular Game of Life de John H. Conway. [ link ]

EDITAR: Después de aproximadamente una semana de competición, he seleccionado un vencedor: pdehaan , por lograr vencer la solución de Matlab por un personaje con perl.

Para aquellos que no han oído hablar de Game of Life, toman una grilla (idealmente infinita) de celdas cuadradas. Las células pueden estar vivas (llenas) o muertas (vacías). Determinamos qué células están activas en el siguiente paso del tiempo aplicando las siguientes reglas:

Cualquier celda viva con menos de dos vecinos vivos muere, como si estuviera causada por la población insuficiente.
Cualquier celda viva con más de tres vecinos vivos muere, como por sobrepoblación.
Cualquier célula viva con dos o tres vecinos vivos vive para la próxima generación.
Cualquier celda muerta con exactamente tres vecinos vivos se convierte en una célula viva, como por reproducción.

Su programa leerá en un archivo de texto ASCII de 40x80 caracteres especificado como un argumento de línea de comandos, así como también el número de iteraciones (N) a realizar. Finalmente, generará un archivo ASCII out.txt el estado del sistema después de N iteraciones.

Aquí hay un ejemplo ejecutado con archivos relevantes:

in.txt:

................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ..................................XX............................................ ..................................X............................................. .......................................X........................................ ................................XXXXXX.X........................................ ................................X............................................... .................................XX.XX...XX..................................... ..................................X.X....X.X.................................... ..................................X.X......X.................................... ...................................X.......XX................................... ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................

Iterar 100 veces:

Q:/>life in.txt 100

Salida resultante (out.txt)

................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ..................................XX............................................ ..................................X.X........................................... ....................................X........................................... ................................XXXXX.XX........................................ ................................X.....X......................................... .................................XX.XX...XX..................................... ..................................X.X....X.X.................................... ..................................X.X......X.................................... ...................................X.......XX................................... ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................

Las normas:

Necesita usar archivos E / S para leer / escribir los archivos.
Necesita aceptar un archivo de entrada y el número de iteraciones como argumentos
Necesita generar out.txt (sobrescribir si existe) en el formato especificado
No necesita ocuparse de los bordes del tablero (envolvente, cuadrículas infinitas .etc)
EDITAR: Necesita tener nuevas líneas en su archivo de salida.

El ganador estará determinado por el recuento de caracteres.

¡Buena suerte!

JavaScript / Node.js - 233 236 caracteres

a=process.argv f=require(''fs'') m=46 t=f.readFileSync(a[2]) while(a[3]--)t=[].map.call(t,function(c,i){for(n=g=0;e=[-82,-81,-80,-1,1,80,81,82][g++];)t[i+e]>m&&n++ return c<m?c:c==m&&n==3||c>m&&n>1&&n<4?88:m}) f.writeFile(''out.txt'',t)

Mathematica - 179 163 154 151 caracteres

a = {2, 2, 2}; s = Export["out.txt", CellularAutomaton[{224, {2, {a, {2, 1, 2}, a}}, {1,1}}, (ReadList[#1, Byte, RecordLists → 2>1] - 46)/ 42, #2]〚#2〛 /. {0 → ".", 1 → "X"}, "Table"] & Espacios agregados para la legibilidad

Invocar con

s["c:/life.txt", 100]

Animación:

También puede obtener un gráfico de la población media a lo largo del tiempo:

Un bonito patrón para generar planeadores de Wikipedia

AFAIK Mathematica usa un autómata celular para generar números aleatorios usando la regla 30.

C - 300

Solo me preguntaba cuánto más pequeña y fea podría ser mi solución java en C. Reduce a 300 incluyendo las líneas nuevas para los bits del preprocesador. ¡Deja la memoria libre al sistema operativo! Podría ahorrar ~ 20 suponiendo que el SO se cerrará y purgará el archivo también.

#include<stdio.h> #include<stdlib.h> #define A(N)j[-N]/88+j[N]/88 int main(int l,char**a){ int t=3240,i=atoi(a[2])*t+t; char*b=malloc(i+t),*j; FILE*f; fread(j=b+t,1,t,fopen(a[1],"r")); for(;j-b-i;j++[t]=*j>10?l==3|l+*j==90?88:46:10) l=A(1)+A(80)+A(81)+A(82); fwrite(j,1,t,f=fopen("out.txt","w")); fclose(f); }

F #, 496

Podría reducir esto mucho, pero me gusta, ya que todavía está en el estadio y es bastante legible.

open System.IO let mutable a:_[,]=null let N y x= [-1,-1;-1,0;-1,1;0,-1;0,1;1,-1;1,0;1,1] |>Seq.sumBy(fun(i,j)->try if a.[y+i,x+j]=''X'' then 1 else 0 with _->0) [<EntryPoint>] let M(r)= let b=File.ReadAllLines(r.[0]) a<-Array2D.init 40 80(fun y x->b.[y].[x]) for i=1 to int r.[1] do a<-Array2D.init 40 80(fun y x-> match N y x with|3->''X''|2 when a.[y,x]=''X''->''X''|_->''.'') File.WriteAllLines("out.txt",Array.init 40(fun y-> System.String(Array.init 80(fun x->a.[y,x])))) 0

EDITAR

428

A pedido, esta es mi próxima puñalada:

open System let mutable a,k=null,Array2D.init 40 80 [<EntryPoint>] let M r= a<-k(fun y x->IO.File.ReadAllLines(r.[0]).[y].[x]) for i=1 to int r.[1] do a<-k(fun y x->match Seq.sumBy(fun(i,j)->try if a.[y+i,x+j]=''X''then 1 else 0 with _->0)[-1,-1;-1,0;-1,1;0,-1;0,1;1,-1;1,0;1,1]with|3->''X''|2 when a.[y,x]=''X''->''X''|_->''.'') IO.File.WriteAllLines("out.txt",Array.init 40(fun y->String(Array.init 80(fun x->a.[y,x])))) 0

Eso es una reducción del 14% con algunos campos de golf básicos. No puedo evitar sentir que estoy perdiendo usando una matriz 2D / array-of-strings en lugar de una matriz 1D, pero no tengo ganas de hacerlo ahora. Tenga en cuenta cómo leo elegantemente el archivo 3200 veces para inicializar mi matriz :)

Java, 556 532 517 496 472 433 428 420 418 381 caracteres

Actualización 1 : reemplazó 1st StringBuffer por Appendable y 2nd por char[] . Guardado 24 caracteres.
Actualización 2: encontró una forma más corta de leer el archivo en char[] . Guardado 15 caracteres.
Actualización 3: reemplazó uno if/else por ?: Y fusionó char[] y declaraciones int . Guardado 21 caracteres.
Actualización 4: reemplazado (int)f.length() y c.length por s . Guardado 24 caracteres.
Actualización 5: mejoras realizadas según sugerencias de Molehill. El principal era la codificación de la longitud del char para poder deshacerme de File . Guardado 39 caracteres.
Actualización 6: refactorización menor. Guardado 6 caracteres.
Actualización 7: se sustituyó el valor Integer#valueOf() por un new Integer() y se refactorizó para el ciclo. Guardado 8 caracteres.
Actualización 8: Cálculo vecino mejorado. Guardado 2 caracteres.
Actualización 9: Lectura optimizada de archivos ya que la longitud del archivo ya está codificada. Guardado 37 caracteres.

import java.io.*;class L{public static void main(String[]a)throws Exception{int i=new Integer(a[1]),j,l,s=3240;int[]p={-82,-81,-80,-1,1,80,81,82};char[]o,c=new char[s];for(new FileReader(a[0]).read(c);i-->0;c=o)for(o=new char[j=s];j-->0;){l=0;for(int n:p)l+=n+j>-1&n+j<s?c[n+j]/88:0;o[j]=c[j]>13?l==3|l+c[j]==90?88:''.'':10;}Writer w=new FileWriter("out.txt");w.write(c);w.close();}}

Versión más legible:

import java.io.*; class L{ public static void main(String[]a)throws Exception{ int i=new Integer(a[1]),j,l,s=3240; int[]p={-82,-81,-80,-1,1,80,81,82}; char[]o,c=new char[s]; for(new FileReader(a[0]).read(c);i-->0;c=o)for(o=new char[j=s];j-->0;){ l=0;for(int n:p)l+=n+j>-1&n+j<s?c[n+j]/88:0; o[j]=c[j]>10?l==3|l+c[j]==90?88:''.'':10; } Writer w=new FileWriter("out.txt");w.write(c);w.close(); } }

Cerrar después de escribir es obligatoriamente obligatorio, de lo contrario, el archivo se deja en blanco. De lo contrario, habría guardado otros 21 caracteres.

Además, también podría guardar un char adicional cuando uso 46 lugar de ''.'' , pero tanto javac como Eclipse se sacuden con un error de compilación. Posible pérdida de precisión . Cosas raras.

Nota: ¡esto espera un archivo de entrada con /n nuevas líneas, no /r/n como Windows usa por defecto!

MATLAB 7.8.0 (R2009a) - 174 171 161 150 138 131 128 124 caracteres

Sintaxis de la función: (124 caracteres)

Aquí está la versión más fácil de leer (con nuevas líneas innecesarias y espacios en blanco agregados para un mejor formato):

function l(f,N), b=char(importdata(f))>46; for c=1:N, b=~fix(filter2(ones(3),b)-b/2-3); end; dlmwrite(''out.txt'',char(b*42+46),'''')

Y así es como se ejecuta el programa desde la ventana de comandos de MATLAB:

l(''in.txt'',100)

Sintaxis del comando: (130 caracteres)

Después de un comentario sobre llamar funciones con una sintaxis de comando, profundicé un poco más y descubrí que las funciones de MATLAB pueden invocarse con un formato de línea de comandos (con algunas restricciones). ¡Tu aprendes algo nuevo cada dia!

function l(f,N), b=char(importdata(f))>46; for c=1:eval(N), b=~fix(filter2(ones(3),b)-b/2-3); end; dlmwrite(''out.txt'',char(b*42+46),'''')

Y así es como se ejecuta el programa desde la ventana de comandos de MATLAB:

l in.txt 100

Desafío adicional: creador de GIF con Tweetable - 136 caracteres

Pensé por diversión que vería si pudiera volcar la salida a un archivo GIF en lugar de un archivo de texto, manteniendo el número de caracteres por debajo de 140 (es decir, "tweetable"). Aquí está el código con formato agradable:

function l(f,N), b=char(importdata(f))>46; k=ones(3); for c=1:N+1, a(:,:,:,c)=kron(b,k); b=~fix(filter2(k,b)-b/2-3); end; imwrite(~a,''out.gif'')

Aunque se supone que IMWRITE crea un GIF que se itera infinitamente de manera predeterminada, mi GIF solo hace bucles una vez. Tal vez este es un error que se ha corregido en las versiones más recientes de MATLAB. Por lo tanto, para que la animación dure más y para que los pasos de evolución sean más fáciles de ver, dejé la demora de fotogramas en el valor predeterminado (que parece ser de alrededor de medio segundo). Aquí está la salida GIF usando el patrón Gosper Glider Gun :

Mejoras

Actualización 1: Se cambió la matriz b de un tipo lógico (es decir, "booleano") a uno numérico para deshacerse de unas pocas conversiones.
Actualización 2: acorté el código para cargar el archivo y usé la función MAGIC como un truco para crear el kernel de convolución en menos caracteres.
Actualización 3: simplificó la lógica de indexación, reemplazó ~~b+0 con b/42 , y reemplazó ''same'' con ''s'' como argumento para CONV2 (¡y sorprendentemente todavía funcionó!).
Actualización 4: Creo que debería haber buscado en línea primero, ya que Loren de The MathWorks blogueó sobre el golf y el Juego de la vida a principios de este año. Incorporé algunas de las técnicas discutidas allí, que me obligaron a cambiar b a una matriz lógica.
Actualización 5: Un comentario de Aslak Grinsted en la publicación de blog mencionada anteriormente sugiere un algoritmo aún más corto tanto para la lógica como para realizar la convolución (usando la función FILTER2 ), así que "incorporé" (léase "copié") sus sugerencias. ;)
Actualización 6: Recortó dos caracteres de la inicialización de b y volvió a trabajar la lógica en el ciclo para guardar 1 carácter adicional.
Actualización 7: Eric Sampson señaló en un correo electrónico que podría reemplazar cell2mat con char , guardando 4 caracteres. Gracias Eric!

PHP - 365 328 322 caracteres.

list(,$n,$l) = $_SERVER["argv"]; $f = file( $n ); for($j=0;$j<$l;$j++){ foreach($f as $k=>$v){ $a[$k]=""; for($i=0;$i < strlen( $v );$i++ ){ $t = 0; for($m=-1;$m<2;$m++){ for($h=-1;$h<2;$h++){ $t+=ord($f[$k + $m][$i + $h]); } } $t-=ord($v[$i]); $a[$k] .= ( $t == 494 || ($t == 452 && ord($v[$i])==88)) ? "X" : "." ; } } $f = $a; } file_put_contents("out.txt", implode("/n", $a ));

Estoy seguro de que esto se puede mejorar, pero tenía curiosidad de cómo se vería en PHP. Tal vez esto inspire a alguien que tenga un poco más de experiencia en golf de código.

Lista de uso actualizada () en lugar de $ var = $ _SERVER ["argv"] para ambos argumentos. Bonito Don
Actualizado + = y - = este me hizo / facepalm, no puedo creer que lo extrañé
Salida de archivo actualizada para usar file_put_contents () otra buena captura de Don
Inicialización eliminada actualizada de vars $ q y $ w que no se estaban utilizando

Python - 282 caracteres

bien podría hacer rodar la pelota ...

import sys _,I,N=sys.argv;R=range(3e3);B=open(I).read();B=set(k for k in R if''A''<B[k]) for k in R*int(N): if k<1:b,B=B,set() c=sum(len(set((k+o,k-o))&b)for o in(1,80,81,82)) if(c==3)+(c==2)*(k in b):B.add(k) open(''out.txt'',''w'').write(''''.join(''.X/n''[(k in B)-(k%81<1)]for k in R))

Python 2.x - 210/234 caracteres

De acuerdo, el código de 210 caracteres es una especie de trampa.

#coding:l1 exec''xÚ=ŽA/nÂ@E÷sŠº1ƒÆscS‰ØL™Æª··âî¿GÈÿÜ´1iÖ½;Sçu.~H®J×Þ-‰Ñ%ª.wê,šÖ§J®dê˜²>cÉZË¢Vä€»Eîa¿,vKAËÀåÌƒ<»Gce‚ÿ‡ábUt¹)G%£êŠ…óbÒüíÚ¯GÔ/n×Xši&Ä‡:})äðtÏÄJÎòDˆÐÿG¶''.decode(''zip'')

Probablemente no podrá copiar y pegar este código y hacerlo funcionar. Se supone que es Latin-1 (ISO-8859-1), pero creo que se volvió pervertido en Windows-1252 en algún momento del camino. Además, su navegador puede tragarse algunos de los caracteres que no son ASCII.

Entonces, si no funciona, puede generar el archivo a partir de caracteres simples de 7 bits:

s = """ 23 63 6F 64 69 6E 67 3A 6C 31 0A 65 78 65 63 27 78 DA 3D 8E 41 5C 6E C2 40 0C 45 F7 73 8A BA 31 13 AD 83 15 11 11 C6 73 08 63 17 05 53 89 D8 4C 99 C6 AA B7 B7 AD E2 EE BF 47 C8 FF DC B4 31 69 D6 BD 3B 53 E7 75 2E 7E 48 AE 4A D7 DE 90 8F 2D 89 AD D1 25 AA 2E 77 16 EA 2C 9A D6 A7 4A AE 64 EA 98 B2 3E 63 C9 5A CB A2 56 10 0F E4 03 80 BB 45 16 0B EE 04 61 BF 2C 76 0B 4B 41 CB C0 E5 CC 83 03 3C 1E BB 47 63 65 82 FF 87 E1 62 55 1C 74 B9 29 47 25 A3 EA 03 0F 8A 07 85 F3 62 D2 FC ED DA AF 11 47 D4 2F 6E D7 58 9A 69 26 C4 87 3A 7D 29 E4 F0 04 74 CF C4 4A 16 CE F2 1B 44 88 1F D0 FF 47 B6 27 2E 64 65 63 6F 64 65 28 27 7A 69 70 27 29 """ with open(''life.py'', ''wb'') as f: f.write(''''.join(chr(int(i, 16)) for i in s.split()))

El resultado de esto es un archivo fuente de Python válido de 210 caracteres. Todo lo que he hecho aquí es compresión zip usada en el código fuente original de Python. El verdadero truco es que estoy usando caracteres que no son ASCII en la cadena resultante. Todavía es un código válido, es engorroso.

La versión no comprimida pesa 234 caracteres, lo cual sigue siendo respetable, creo.

import sys f,f,n=sys.argv e=open(f).readlines() p=range for v in p(int(n)):e=[''''.join(''.X''[8+16*(e[t][i]!=''.'')>>sum(n!=''.''for v in e[t-1:t+2]for n in v[i-1:i+2])&1]for i in p(80))for t in p(40)] open(''out.txt'',''w'').write(''/n''.join(e))

Perdón por el desplazamiento horizontal, pero se requieren todas las líneas nuevas en el cuadro anterior, y las he contado como un solo carácter.

No trataría de leer el código golfed. Los nombres de las variables se eligen al azar para lograr la mejor compresión. Si hablo en serio. Una versión mejor formateada y comentada sigue:

# get command-line arguments: infile and count import sys ignored, infile, count = sys.argv # read the input into a list (each input line is a string in the list) data = open(infile).readlines() # loop the number of times requested on the command line for loop in range(int(count)): # this monstrosity applies the rules for each iteration, replacing # the cell data with the next generation data = [''''.join( # choose the next generation''s cell from ''.'' for # dead, or ''X'' for alive ''.X''[ # here, we build a simple bitmask that implements # the generational rules. A bit from this integer # will be chosen by the count of live cells in # the 3x3 grid surrounding the current cell. # # if the current cell is dead, this bitmask will # be 8 (0b0000001000). Since only bit 3 is set, # the next-generation cell will only be alive if # there are exactly 3 living neighbors in this # generation. # # if the current cell is alive, the bitmask will # be 24 (8 + 16, 0b0000011000). Since both bits # 3 and 4 are set, this cell will survive if there # are either 3 or 4 living cells in its neighborhood, # including itself 8 + 16 * (data[y][x] != ''.'') # shift the relevant bit into position >> # by the count of living cells in the 3x3 grid sum(character != ''.'' # booleans will convert to 0 or 1 for row in data[y - 1 : y + 2] for character in row[x - 1 : x + 2] ) # select the relevant bit & 1 ] # for each column and row for x in range(80) ) for y in range(40) ] # write the results out open(''out.txt'',''w'').write(''/n''.join(data))

Lo siento, Pythonistas, por el formato de corchete C-ish, pero estaba tratando de dejar en claro qué se estaba cerrando cada corchete.

Ruby 1.9 - 189 178 159 155 153 caracteres

f,n=$* c=IO.read f n.to_i.times{i=0;c=c.chars.map{|v|i+=1 v<?.?v:(''...X''+v)[[83,2,-79].map{|j|c[i-j,3]}.to_s.count ?X]||?.}*''''} File.new(''out.txt'',?w)<<c

Editar: maneja las líneas nuevas con 4 caracteres menos.
Puede eliminar 7 más ( v<?.?v: :) si le permite marcar trincheras nuevas cuando las células vivas alcanzan los bordes.

perl, 127 129 135 caracteres

Se las arregló para quitarse un par de personajes más ...

$/=pop;@b=split'''',<>;map{$n=-1;@b=map{++$n;/ /?$_:($t=grep/X/,@b[map{$n+$_,$n-$_}1,80..82])==3|$t+/X/==3?X:''.''}@b}1..$/;print@b

C ++ - 492 454 386

mi primer código de golf;)

#include<fstream> #define B(i,j)(b[i][j]==''X'') int main(int i,char**v){for(int n=0;n<atoi(v[2]);++n){std::ifstream f(v[1]);v[1]="out.txt";char b[40][83];for(i=0;i<40;++i)f.getline(b[i],83);std::ofstream g("out.txt");g<<b[0]<<''/n'';for(i=1;i<39;++i){g<<''.'';for(int j=1;j<79;++j){int k=B(i-1,j)+B(i+1,j)+B(i,j-1)+B(i,j+1)+B(i-1,j-1)+B(i+1,j+1)+B(i+1,j-1)+B(i-1,j+1);(B(i,j)&&(k<2||k>3))?g<<''.'':(!B(i,j)&&k==3)?g<<''X'':g<<b[i][j];}g<<"./n";}g<<b[0]<<''/n'';}}

Una versión algo revisada, que reemplaza parte de la lógica con una tabla de búsqueda + algunos otros trucos menores:

#include<fstream> #define B(x,y)(b[i+x][j+y]==''X'') int main(int i,char**v){for(int n=0;n<atoi(v[2]);++n){std::ifstream f(v[1]);*v="out.txt";char b[40][83], O[]="...X.....";for(i=0;i<40;++i)f>>b[i];std::ofstream g(*v);g<<b[0]<<''/n'';for(i=1;i<39;++i){g<<''.'';for(int j=1;j<79;++j){O[2]=b[i][j];g<<O[B(-1,0)+B(1,0)+B(0,-1)+B(0,1)+B(-1,-1)+B(1,1)+B(1,-1)+B(-1,1)];}g<<"./n";}g<<b[0]<<''/n'';}}

Java, 441 ... 346

Actualización 1 Eliminada interna si y más fealdad
Actualización 2 Se corrigió un error y se ganó un personaje
Actualización 3 Usando mucha más memoria y matrices mientras se ignoran algunos problemas de límites. Probablemente se podrían guardar algunos caracteres.
Actualización 4 Guardado algunos caracteres. Gracias a BalusC.
Actualización 5 Algunos cambios menores para ir por debajo de 400 y hacerlo simplemente un poco más feo.
Actualización 6 Ahora las cosas están tan codificadas que también pueden leer en la cantidad exacta de una vez. Además de algunos ahorros más.
Actualización 7 Encadena la escritura al archivo para guardar un carácter. Además de algunos bits extraños.

Simplemente jugando con la solución de BalusC. Reputación limitada significa que no pude agregar nada como comentario a la suya.

class M{public static void main(String[]a)throws Exception{int t=3240,j=t,i=new Integer(a[1])*t+t;char[]b=new char[i+t],p={1,80,81,82};for(new java.io.FileReader(a[0]).read(b,t,t);j<i;){char c=b[j],l=0;for(int n:p)l+=b[j+n]/88+b[j-n]/88;b[j+++t]=c>10?(l==3|l+c==90?88:''.''):c;}new java.io.FileWriter("out.txt").append(new String(b,j,t)).close();}}

Versión más legible (?):

class M{ public static void main(String[]a)throws Exception{ int t=3240,j=t,i=new Integer(a[1])*t+t; char[]b=new char[i+t],p={1,80,81,82}; for(new java.io.FileReader(a[0]).read(b,t,t);j<i;){ char c=b[j],l=0; for(int n:p)l+=b[j+n]/88+b[j-n]/88; b[j+++t]=c>10?(l==3|l+c==90?88:''.''):c; } new java.io.FileWriter("out.txt").append(new String(b,j,t)).close(); } }

Perl – 214 chars

What, no perl entries yet?

$i=pop;@c=<>;@c=map{$r=$_;$u='''';for(0..79) {$K=$_-1;$R=$r-1;$u.=((&N.(&N^"/0/W/0").&N)=~y/X// |(substr$c[$r],$_,1)eq''X'')==3?''X'':''.'';}$u}keys@c for(1..$i); sub N{substr$c[$R++],$K,3}open P,''>'',''out.txt'';$,=$/;print P@c

Run with:

conway.pl infile #times

La siguiente solución usa mi propio lenguaje de programación específico de dominio personalizado que he llamado NULL:

3499538

En caso de que se esté preguntando cómo funciona esto, mi lenguaje consta de solo una declaración por programa. La declaración representa una identificación de subproceso de que pertenece a un hilo de golf de código. Mi compilador compila esto en un programa que busca la mejor solución de javascript (con la API SO), lo descarga y lo ejecuta en un navegador web.

El tiempo de ejecución podría ser mejor para los nuevos hilos (puede tomar algo de tiempo para que aparezca la primera respuesta de Javascript subida), pero al alza solo requiere muy pocas habilidades de codificación.

MOMENTOS: 314 caracteres

L(F,N,R=40,C=80) N (F,N,R,C) O F:"RS" U F D C F .F I=1:1:R R L F J=1:1:C S G(0,I,J)=($E(L,J)="X") F A=0:1:N-1 F I=1:1:R F J=1:1:C D S G(A+1,I,J)=$S(X=2:G(A,I,J),X=3:1,1:0) .S X=0 F i=-1:1:1 F j=-1:1:1 I i!j S X=X+$G(G(A,I+i,J+j)) S F="OUT.TXT" O F:"WNS" U F D C F .F I=1:1:R F J=1:1:C W $S(G(N,I,J):"X",1:".") W:J=C ! Q

ét voilà you may want to use this html file. no file input, but a textarea that does the job! there is also some html and initiation and vars. the main routine has only 235 characters. It''s hand-minified JS.

<!DOCTYPE html> <html><body><textarea id="t" style="width:600px;height:600px;font-family:Courier"> </textarea></body><script type="text/javascript">var o,c,m=new Array(3200), k=new Array(3200),y,v,l,p;o=document.getElementById("t");for(y=0;y<3200;y++) {m[y]=Math.random()<0.5;}setInterval(function(){p="";for(y=0;y<3200;y++){c=0; for(v=-1;v<2;v+=2){c+=m[y-1*v]?1:0;for(l=79;l<82;l++)c+=m[y-l*v]?1:0;} k[y]=c==3||m[y]&&c==2;}p="";for(y=0;y<3200;y++){p+=(y>0&&y%80==0)?"/n":""; m[y]=k[y];p+=(m[y]?"O":"-");}o.innerHTML=p;},100);</script></html>

Another Java attempt, 361 chars

class L{public static void main(final String[]a)throws Exception{new java.io.RandomAccessFile("out.txt","rw"){{int e=88,p[]={-1,1,-80,80,-81,81,-82,82},s=3240,l=0,i=new Byte(a[1])*s+s,c;char[]b=new char[s];for(new java.io.FileReader(a[0]).read(b);i>0;seek(l=++l%s),i--){c=b[l];for(int n:p)c+=l+n>=0&l+n<s?b[l+n]/e:0;write(c>13?(c==49|(c|1)==91?e:46):10);}}};}}

And a little more readable

class L { public static void main(final String[]a) throws Exception { new java.io.RandomAccessFile("out.txt","rw"){{ int e=88, p[]={-1,1,-80,80,-81,81,-82,82},s=3240,l=0,i=new Byte(a[1])*s+s,c; char[] b = new char[s]; for (new java.io.FileReader(a[0]).read(b);i>0;seek(l=++l%s),i--) { c=b[l]; for (int n:p) c+=l+n>=0&l+n<s?b[l+n]/e:0; write(c>13?(c==49|(c|1)==91?e:46):10); } }}; } }

Very similar to Molehill''s version. I''ve tried to use a different FileWriter and to count the cell''s neighbors without an additional variable. Unfortunately, RandomAccessFile is a pretty long name and it is required that you pass an file access mode.

R 340 caracteres

cgc<-function(i="in.txt",x=100){ require(simecol) z<-file("in.txt", "rb") y<-matrix(data=NA,nrow=40,ncol=80) for(i in seq(40)){ for(j in seq(80)){ y[i,j]<-ifelse(readChar(z,1) == "X",1,0) } readChar(z,3) } close(z) init(conway) <- y times(conway)<-1:x o<-as.data.frame(out(sim(conway))[[100]]) write.table(o, "out.txt", sep="", row.names=FALSE, col.names=FALSE) } cgc()

Siento que es un poco engañoso tener un complemento en el paquete que haga el autómata real para ti, pero voy con eso porque todavía tuve que lidiar con matrices y cosas para leer en el archivo con ''X'' en lugar de 1.

Este es mi primer ''código de golf'', interesante ...

RUST - 469 characters Don''t know if I should post this here, (this post is 3 years old) but anyway, my try on this, in rust (0.9):

use std::io::fs::File;fn main(){ let mut c=File::open(&Path::new(std::os::args()[1])).read_to_end(); for _ in range(0,from_str::<int>(std::os::args()[2]).unwrap()){ let mut b=c.clone();for y in range(0,40){for x in range(0,80){let mut s=0; for z in range(x-1,x+2){for t in range(y-1,y+2){ if z>=0&&t>=0&&z<80&&t<40&&(x !=z||y !=t)&&c[t*81+z]==88u8{s +=1;}}} b[y*81+x]=if s==3||(s==2&&c[y*81+x]==88u8){88u8} else {46u8};}}c = b;} File::create(&Path::new("out.txt")).write(c);}

For people interested, here is the code before some agressive golfing:

use std::io::fs::File; fn main() { let f = std::os::args()[1]; let mut c = File::open(&Path::new(f)).read_to_end(); let n = from_str::<int>(std::os::args()[2]).unwrap(); for _ in range(0,n) { let mut new = c.clone(); for y in range(0,40) { for x in range(0,80) { let mut sum = 0; for xx in range(x-1,x+2){ for yy in range(y-1,y+2) { if xx >= 0 && yy >= 0 && xx <80 && yy <40 && (x != xx || y != yy) && c[yy*81+xx] == 88u8 { sum = sum + 1; } } } new[y*81+x] = if sum == 3 || (sum == 2 && c[y*81+x] == 88u8) {88u8} else {46u8}; } } c = new; } File::create(&Path::new("out.txt")).write(c); }

Ruby 1.8: ~~178~~ 175 caracteres

f,n=$*;b=IO.read f n.to_i.times{s=b.dup s.size.times{|i|t=([82,1,-80].map{|o|b[i-o,3]||''''}*'''').count ''X'' s[i]=t==3||b[i]-t==?T??X:?.if s[i]>13};b=s} File.new(''out.txt'',''w'')<<b

Las líneas nuevas son significativas (aunque todas pueden reemplazarse con punto y coma).

Editar: solucionó el problema de la nueva línea y recortó 3 caracteres.

Scala: ~~467~~ ~~364~~ 339 caracteres

object G{def main(a:Array[String]){val l=io.Source.fromFile(new java.io.File(a(0)))getLines("/n")map(_.toSeq)toSeq val f=new java.io.FileWriter("out.txt") f.write((1 to a(1).toInt).foldLeft(l){(t,_)=>(for(y<-0 to 39)yield(for(x<-0 to 79)yield{if(x%79==0|y%39==0)''.''else{val m=t(y-1) val p=t(y+1);val s=Seq(m(x-1),m(x),m(x+1),t(y)(x-1),t(y)(x+1),p(x-1),p(x),p(x+1)).count(''X''==_) if(s==3|(s==2&t(y)(x)==''X''))''X''else''.''}})toSeq)toSeq}map(_.mkString)mkString("/n")) f.close}}

Creo que hay mucho margen de mejora ...

[Editar] Sí, es:

object G{def main(a:Array[String]){var l=io.Source.fromFile(new java.io.File(a(0))).mkString val f=new java.io.FileWriter("out.txt") var i=a(1).toInt while(i>0){l=l.zipWithIndex.map{case(c,n)=>if(c==''/n'')''/n''else{val s=Seq(-83,-82,-81,-1,1,81,82,83).map(_+n).filter(k=>k>=0&k<l.size).count(l(_)==''X'') if(s==3|(s==2&c==''X''))''X''else''.''}}.mkString i-=1} f.write(l) f.close}}

[Editar] Y tengo la sensación de que todavía hay más que exprimir ...

object G{def main(a:Array[String]){val f=new java.io.FileWriter("out.txt") f.write(((1 to a(1).toInt):/(io.Source.fromFile(new java.io.File(a(0))).mkString)){(_,m)=>m.zipWithIndex.map{case(c,n)=> val s=Seq(-83,-82,-81,-1,1,81,82,83)count(k=>k+n>=0&k+n<m.size&&m(k+n)==''X'') if(c==''/n'')c else if(s==3|s==2&c==''X'')''X''else''.''}.mkString}) f.close}}

One of the classic patterns

*** ..* .*

My avatar was created using my version of the Game of Life using this pattern and rule(note that it is not 23/3):

#D Thanks to my daughter Natalie #D Try at cell size of 1 #R 8/1 #P -29 -29 .********************************************************* *.*******************************************************.* **.*****************************************************.** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** ****************************.*.**************************** *********************************************************** ****************************.*.**************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** **.*****************************************************.** *.*******************************************************.* .*********************************************************

IMHO - as I learned Conway''s Game of Life the trick wasn''t writing short code, but code that could do complex life forms quickly. Using the classic pattern above and a wrapped world of 594,441 cells the best I could ever do was around 1,000 generations / sec.

Another simple pattern

********** . ................* .................** ................**.......**********

And gliders

........................*........... ......................*.*........... ............**......**............** ...........*...*....**............** **........*.....*...**.............. **........*...*.**....*.*........... ..........*.....*.......*........... ...........*...*.................... ............**......................