Code Golf: Conway Game of Life

https://stackoverflow.com/questions/3499538

29-09-2019
|

Question

Le défi: Écrivez le programme le plus court qui met en oeuvre de John H. Conway Jeu de la vie automate cellulaire. [ lien ]

EDIT: Après environ une semaine de compétition, j'ai choisi un vainqueur: pdehaan , pour avoir réussi à battre la solution Matlab par un caractère avec perl.

Pour ceux qui ne l'ont pas entendu parler de jeu de la vie, vous prenez une grille (idéalement infini) de cellules carrées. Les cellules peuvent être en vie (remplies) ou morts (vide). Nous déterminons les cellules qui sont en vie à l'étape suivante du temps en appliquant les règles suivantes:

Toute cellule en temps réel avec moins de deux voisins vivants meurt, comme si elle est causée par la sous-population.
Toute cellule vivante avec plus de trois voisins vivants meurt, comme par le surpeuplement.
Toute cellule vivante avec deux ou trois voisins vivent une vie à la prochaine génération.
Toute cellule morte avec exactement trois voisins vivants devient une cellule vivante, comme par reproduction.

Votre programme sera lu dans un fichier texte ASCII de caractères 40x80 spécifié comme argument de ligne de commande, ainsi que le nombre d'itérations (N) à effectuer. Enfin, il affichera un fichier ASCII out.txt l'état du système après N itérations.

Voici un exemple avec la gestion des fichiers pertinents:

in.txt:

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

Itérer 100 fois:

Q:\>life in.txt 100

Resultant sortie (out.txt)

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

Les règles:

Vous devez utiliser le fichier d'E / S pour lire / écrire les fichiers.
Vous devez accepter un fichier d'entrée et le nombre d'itérations comme arguments
Vous devez générer out.txt (Ecraser si elle existe) dans le format spécifié
Vous ne pas nécessité de traiter les bords de la carte (enveloppants, infini grilles .etc)
EDIT:. Vous faire besoin d'avoir des sauts de ligne dans votre fichier de sortie

Le gagnant sera déterminé par le nombre de caractères.

Bonne chance!

La solution

perl, 127 129 135 caractères

Nous avons réussi à dépouiller un couple plus de personnages ...

$/=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

Autres conseils

Mathematica - 179 163 154 151 caractères

    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"] &

Les espaces ajoutés pour une meilleure lisibilité

Invoke avec

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

Animation:

text alt

Vous pouvez également obtenir un graphique de la moyenne de population au fil du temps:

text alt

Un beau motif pour générer des planeurs de Wikipedia

Mathematica utilise un cellulaire Automaton pour générer des nombres aléatoires utilisant règle 30.

Matlab 7.8.0 (R2009a) - 174 171 161 150 138 131 128 124 caractères

Syntaxe de la fonction: (124 caractères)

Voici le plus facile à lire la version (avec les nouvelles lignes inutiles et des espaces ajouté pour une meilleure mise en forme):

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),'')

Et voici comment le programme est exécuté à partir de la commande Fenêtre Matlab:

l('in.txt',100)

syntaxe de commande: (130 caractères)

Après un commentaire au sujet de l'appel de fonctions avec une syntaxe de commande, je creuse un peu plus loin et a découvert que les fonctions de Matlab peut en fait invoqué avec un format de ligne de commande (avec certaines restrictions). Vous apprenez quelque chose de nouveau chaque jour!

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),'')

Et voici comment le programme est exécuté à partir de la commande Fenêtre Matlab:

l in.txt 100

Défi supplémentaire: GIF Tweetable maker - 136 caractères

Je pensais que pour le plaisir que je verrais si je pouvais vider la sortie vers un fichier GIF au lieu d'un fichier texte, tout en conservant le nombre de caractères inférieure à 140 (à savoir « tweetable »). Voici le code bien formaté:

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')

Bien que IMWRITE est censé créer un GIF qui boucle indéfiniment par défaut, mon GIF est seulement une fois mise en boucle. Peut-être est un bug qui a été corrigé dans les versions plus récentes de Matlab. Donc, pour faire l'animation durent plus longtemps et faire les étapes d'évolution plus facile à voir, je suis parti le retard de trame à la valeur par défaut (ce qui semble être autour d'une demi-seconde). Voici la sortie GIF en utilisant le modèle de la Gosper Planeur Gun:

Améliorations

Mise à jour 1:. Changement de la matrice b à partir d'un type logique (à savoir "booléen") à un numérique pour se débarrasser de quelques conversions

Mise à jour 2: Raccourcissement le code pour le chargement du fichier et utilisé la fonction MAGIC comme une astuce pour créer le noyau de convolution dans moins de caractères.

Mise à jour 3: simplifié la logique d'indexation, remplacé ~~b+0 avec b/42 et remplacé 'same' avec 's' comme argument CONV2 de (et étonnamment fonctionnait toujours!).

Mise à jour 4: Je suppose que je devrais avoir cherché en ligne d'abord, depuis Loren de la MathWorks blogué sur le golf et le jeu de la vie plus tôt cette année. J'ai intégré quelques-unes des techniques y ont discuté, ce qui m'a obligé à changer b revenir à une matrice logique.

Mise à jour 5: commentaire de Aslak Grinsted au-dessus après le blog mentionné suggère un algorithme encore plus court pour les deux la logique et effectuer la convolution (en utilisant la fonction FILTER2 ), donc je "Incorporée"(lire "copié") sa suggestions. ;)

Update 6:. rasée deux caractères à partir de l'initialisation de b et retravaillé la logique dans la boucle pour enregistrer 1 caractère supplémentaire

Mise à jour 7: Eric Sampson a souligné dans un e-mail que je pourrais remplacer cell2mat avec char, économiser 4 caractères. Merci Eric!

Ruby 1.9 - ~~189~~ ~~178~~ ~~159~~ ~~155~~ 153 caractères

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

Edit: Poignées avec 4 nouvelles lignes.
moins caractères Peut enlever 7 plus (v<?.?v:) si vous le permettez clobber de nouvelles lignes lorsque les cellules vivantes atteignent les bords.

Python - 282 caractères

pourrait ainsi obtenir le roulement à billes ...

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 caractères

D'accord, le code 210 caractères est une sorte de tricherie.

#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')

Vous ne sera probablement pas en mesure de copier et coller ce code et obtenir au travail. Il est censé être Latin-1 (ISO-8859-1), mais je crois qu'elle a été perverti dans un endroit Windows 1252 le long du chemin. En outre, votre navigateur peut avaler quelques-uns des caractères non-ASCII.

Donc, si ça ne marche pas, vous pouvez générer le fichier de plain-vieux caractères 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()))

Le résultat de ceci est un 210 caractères valide fichier source Python. Tout ce que je l'ai fait ici est utilisé la compression zip sur le code source Python d'origine. Le vrai triche est que je suis en utilisant des caractères non-ASCII dans la chaîne résultante. Il est encore un code valide, il est juste lourd.

La version pèse noncompressed 234 caractères, ce qui est encore respectable, je pense.

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))

Désolé pour le défilement horizontal, mais tous les sauts de ligne dans ce qui précède sont nécessaires, et je les ai compté comme un caractère chacun.

Je ne voudrais pas essayer de lire le code golfed. Les noms de variables sont choisis au hasard pour obtenir la meilleure compression. Oui. Je suis sérieux. Une meilleure forme et version commentée suit:

# 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))

Désolé, Pythoneux, pour le support de C-ish mise en forme, mais je tentais de faire comprendre ce que chaque support se refermait.

Haskell - ~~284~~ ~~272~~ 232 caractères

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

F #, 496

Je pourrais réduire ce beaucoup, mais je aime ce qu'il est encore dans le stade de baseball et assez lisible.

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

EDIT

428

Sur demande, voici mon prochain coup:

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

C'est une réduction de 14% avec un peu au golf de base. Je ne peux pas empêcher de penser que je perdre en utilisant un 2D-tableau / chaînes-de-tableau plutôt qu'un tableau 1D, mais ne se sentent pas comme le faire maintenant transformer. Notez que je lis avec élégance le fichier 3200 fois pour initialiser mon tableau:)

Ruby 1.8: ~~178~~ 175 caractères

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

sont importants sauts de ligne (bien que tous peuvent être remplacés w / points-virgules.)

Edit:. fixe la question de la nouvelle ligne, et préparèrent 3 caractères

Java, ~~441 ...~~ 346

Mise à jour 1 Suppression intérieure si et plus laideur

Mise à jour 2 Correction d'un bug et a gagné un caractère

Mise à jour 3 Utiliser beaucoup plus de mémoire et des réseaux tout en ignorant des problèmes de limites. Probablement quelques caractères pourraient être sauvés.

Mise à jour 4 enregistrés quelques caractères. Merci à BalusC.

Mise à jour 5 Quelques changements mineurs d'aller en dessous de 400 et en font juste que plus laid bits supplémentaire.

Mise à jour 6 maintenant Les choses sont si bien codés en dur peut aussi lire dans le montant exact en une seule fois. De plus quelques économies.

Mise à jour 7 Chaîne de l'écriture au fichier pour enregistrer char. De plus quelques bits impairs.

Il suffit de jouer avec la solution de BalusC. des moyens de réputation limitée, je ne pourrais pas ajouter quoi que ce soit comme un commentaire à son.

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();}}

La version plus lisible (?):

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(); } }

Scala - ~~467~~ ~~364~~ 339 caractères

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}}

Je pense qu'il ya beaucoup de place à l'amélioration ...

[Modifier] Oui, il est:

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}}

[Modifier] et j'ai le sentiment qu'il ya encore beaucoup à faire sortir ...

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}}

La solution suivante utilise mon propre langage de programmation spécifique à domaine personnalisé que j'ai appelé NULL:

3499538

Dans le cas où vous vous demandez comment fonctionne: Ma langue se compose de seulement d'un statment par programme. La déclaration représente un ID de fil StackOverflow appartenant à un fil de golf de code. Mon compilateur compile ce dans un programme qui cherche la meilleure solution javascript (avec l'API SO), télécharge et exécute dans un navigateur Web.

Runtime pourrait être mieux pour les nouveaux threads (il peut prendre un certain temps pour la première réponse upvoted Javascript à paraître), mais à la hausse, il ne nécessite que très peu de compétences de codage.

Javascript / Node.js - 233 ~~236~~ caractères

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)

C - 300

Il suffit de se demandait comment beaucoup plus petit et plus laid que ma solution java pourrait aller en C. Réduit à 300, y compris les nouvelles lignes pour les bits de préprocesseur. Feuilles libérer la mémoire au système d'exploitation! Pourrait sauver ~ 20 en supposant le système d'exploitation va fermer et vider aussi le fichier.

#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); }

Oreillons: 314 caractères

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

Java, ~~556~~ ~~532~~ ~~517~~ ~~496~~ ~~472~~ ~~433~~ ~~428~~ ~~420~~ ~~418~~ 381 caractères

Mise à jour 1 : 1er remplacé par StringBuffer Appendable et 2 par char[]. 24 caractères sauvé.

Mise à jour 2: a trouvé un moyen plus court pour lire le fichier en char[]. 15 caractères enregistrée.

Mise à jour 3: a remplacé un if/else par ?: et a fusionné les déclarations de char[] et int. 21 caractères sauvé.

Mise à jour 4: remplacé (int)f.length() et c.length par s. 24 caractères sauvé.

Mise à jour 5: améliorations apportées par les conseils de Molehill. Major a été un hardcoding la longueur char pour que je puisse me débarrasser de File. 39 caractères sauvé.

Mise à jour 6: mineur refactoring. Enregistré 6 caractères.

Mise à jour 7: remplacé Integer#valueOf() par new Integer() et refondus pour la boucle. Enregistré 8 caractères.

Mise à jour 8: Calcul du voisin amélioré. 2 sauvé caractères.

Mise à jour 9: Optimisation lecture de fichiers depuis la longueur du fichier est déjà codé en dur. Sauvé 37 caractères.

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();}}

Version plus lisible:

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(); } }

Fermeture après l'écriture est absoletely obligatoire, sinon le fichier est laissé vide. Il aurait par ailleurs sauvé 21 autres caractères.

De plus, je pouvais également enregistrer une plus omble chevalier quand je l'utilise 46 au lieu de '.', mais les deux javac et Eclipse saccades avec une erreur de compilation Perte possible de précision . trucs bizarres.

Remarque: ce attend un fichier d'entrée avec les nouvelles lignes de \n, ne \r\n que Windows par défaut utilisations

PHP -. ~~365~~ ~~328~~ 322 caractères

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 ));

Je suis sûr que cela peut être amélioré mais j'étais curieux de savoir ce qu'il ressemblerait en PHP. Peut-être que cela inspirera quelqu'un qui a un peu plus d'expérience golf de code.

Mise à jour Liste d'utilisation () au lieu de $ var = $ _SERVER [ "argv"] pour les deux args. Nice one Don

Mise à jour + = et - = celui-ci m'a fait / facepalm heh ne peux pas croire je l'ai raté

Mise à jour Sortie de fichier à file_put_contents d'utilisation () une autre bonne prise par Don

Mise à jour initialisation retiré de vars $ q et $ w ils ne sont pas utilisés

R 340 caractères

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()

Je pense qu'il est un peu tricher pour avoir un complément dans le paquet qui fait les automates réel pour vous, mais je vais avec elle parce que je devais encore somnambuler avec matricies et des choses à lire dans le fichier avec « X » au lieu de 1.

Ceci est mon premier 'golf de code', intéressant ....

c ++ - ~~492~~ ~~454~~ 386

mon premier golf de code;)

#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';}}

Une version révisée quelque peu, en remplaçant une partie de la logique avec une table de consultation + quelques autres trucs mineurs:

#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';}}

Perl - 214 caractères

Qu'est-ce, pas d'entrées perl encore?

$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

Exécuter avec:

conway.pl infile #times

Une autre tentative Java, 361 caractères

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);}}};}}

Et un peu plus lisible

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); } }}; } }

Très similaire à la version de Molehill. J'ai essayé d'utiliser un autre FileWriter et de compter les voisins de la cellule sans une variable supplémentaire. Malheureusement, RandomAccessFile est un nom assez long et il est nécessaire que vous passez un mode d'accès aux fichiers.

ROUILLE - 469 caractères Je ne sais pas si je dois poster cela ici, (ce poste est de 3 ans) mais de toute façon, mon essai sur ce point, dans la rouille (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);}

Pour les personnes intéressées, voici le code avant un peu au golf agressif:

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); }

Et voilà vous pouvez utiliser ce fichier html. pas d'entrée de fichier, mais une zone de texte qui fait le travail! il y a aussi un certain html et l'initiation et vars. la routine principale ne dispose que de 235 caractères. Il la main-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>

L'un des motifs classiques

*** ..* .*

Mon avatar a été créé en utilisant ma version du jeu de la vie en utilisant ce modèle et règle (notez que ce n'est pas 23/3):

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

à mon humble avis - comme je l'ai appris jeu de la vie de Conway l'affaire n'a pas été en train d'écrire un code court, mais le code qui pourrait faire des formes de vie complexes rapidement. En utilisant le schéma classique ci-dessus et un monde enveloppé de 594,441 cellules le mieux que je ne pourrais jamais faire était autour de 1000 générations / s.

Un autre modèle simple

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

et planeurs

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

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow

Code Golf: Conway Game of Life

perl, 127 129 135 caractères

Mathematica - 179 163 154 151 caractères

Matlab 7.8.0 (R2009a) - 174 171 161 150 138 131 128 124 caractères

Défi supplémentaire: GIF Tweetable maker - 136 caractères

Améliorations

Ruby 1.9 - 189 178 159 155 153 caractères

Python - 282 caractères

Python 2.x - 210/234 caractères

Haskell - 284 272 232 caractères

F #, 496

428

Java, 441 ... 346

Javascript / Node.js - 233 236 caractères

C - 300

Java, 556 532 517 496 472 433 428 420 418 381 caractères

PHP -. 365 328 322 caractères

c ++ - 492 454 386

Perl - 214 caractères