Код Гольф:Игра жизни Конвея

StackOverflow https://stackoverflow.com/questions/3499538

Вопрос

Вызов: Напишите самую короткую программу, реализующую John H.У Конвея Игра в жизнь клеточный автомат.[Ссылка]

Редактировать: Примерно через неделю соревнований я выбрал победителя: пдехан, за то , что удалось превзойти решение Matlab с помощью один символ с perl.

Для тех, кто не слышал об Game of Life, вы берете сетку (в идеале бесконечную) из квадратных ячеек.Ячейки могут быть живыми (заполненными) или мертвыми (пустыми).Мы определяем, какие клетки живы на следующем этапе времени, применяя следующие правила:

  1. Любая живая клетка, имеющая менее двух живых соседей, погибает, как если бы это было вызвано недостаточной популяцией.
  2. Любая живая клетка с более чем тремя живыми соседями погибает, как бы из-за переполненности.
  3. Любая живая клетка с двумя или тремя живыми соседями продолжает жить до следующего поколения.
  4. Любая мертвая клетка, имеющая ровно трех живых соседей, становится живой клеткой, как бы путем размножения.

Ваша программа будет считывать текстовый файл ASCII размером 40x80 символов, указанный в качестве аргумента командной строки, а также количество итераций (N), которые необходимо выполнить.Наконец, он выведет в файл ASCII out.txt состояние системы после N итераций.

Вот пример запуска с соответствующими файлами:

in.txt:

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

Повторите 100 раз:

Q:\>life in.txt 100

Результирующий результат (out.txt)

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

Правила:

  • Вам необходимо использовать файловый ввод-вывод для чтения / записи файлов.
  • Вам нужно принять входной файл и количество итераций в качестве аргументов
  • Вам необходимо сгенерировать out.txt (перезаписать, если он существует) в указанном формате
  • Ты не надо нужно разобраться с краями доски (закругление, бесконечные сетки и т.д.)
  • Редактировать:Ты делай в вашем выходном файле должны быть новые строки.

Победитель будет определен по количеству персонажей.

Удачи вам!

Это было полезно?

Решение

Perl, 127. 129 135 Чарс

Удалось разделить еще пару персонажей ...

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

Другие советы

Математика - 179 163 154 151 Чарс 

    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"] &
Пробелы, добавленные для читабельности

Вызвать с

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

Анимация:

alt text

Вы также можете получить график среднего населения с течением времени:

alt text

Хороший рисунок для генерации планеров из Википедия

aa

Насколько мне известно Mathematica использует сотовый автомат для генерации случайных чисел с использованием Правило 30.

MATLAB 7.8.0 (R2009a) - 174 171 161 150 138 131 128 124 символа

Синтаксис функции:(124 символа)

Вот более простая для чтения версия (с добавлением ненужных новых строк и пробелов для лучшего форматирования):

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

И вот как программа запускается из командного окна MATLAB:

l('in.txt',100)

Синтаксис команды:(130 символов)

После комментария о вызове функций с помощью командного синтаксиса я копнул немного глубже и обнаружил, что функции MATLAB может на самом деле быть вызывается с помощью формата командной строки (с некоторыми ограничениями).Каждый день ты узнаешь что-то новое!

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

И вот как программа запускается из командного окна MATLAB:

l in.txt 100


Дополнительная проблема:Создатель GIF-файлов для твитов - 136 символов

Я подумал, что ради интереса посмотрю, смогу ли я выгрузить выходные данные в GIF-файл вместо текстового, сохраняя при этом количество символов ниже 140 (т.е."твиттер").Вот красиво отформатированный код:

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

Хотя ПЕРЕПИСАТЬ предполагается создать GIF, который по умолчанию зацикливается бесконечно, мой GIF зацикливается только один раз.Возможно, это ошибка, которая была исправлена в более новых версиях MATLAB.Итак, чтобы анимация длилась дольше и этапы эволюции было легче увидеть, я оставил задержку кадра равной значению по умолчанию (которое, кажется, составляет около половины секунды).Вот вывод GIF-файла с использованием Планерное Ружье Госпера узор:

alt text

Улучшения

  • Обновление 1: Изменил матрицу b из логического (т. е."boolean") введите числовое значение, чтобы избавиться от нескольких преобразований.
  • Обновление 2: Сократил код для загрузки файла и использовал функцию Магия как трюк для создания ядра свертки с меньшим количеством символов.
  • Обновление 3: Упростил логику индексации, заменил ~~b+0 с b/42, и заменен 'same' с 's' в качестве аргумента против КОНВ2 (и это, на удивление, все еще работало!).
  • Обновление 4: Наверное, мне следовало сначала поискать в Интернете, поскольку Лорен из MathWorks вел блог о гольфе и Игре в жизнь ранее в этом году.Я включил некоторые из обсуждавшихся там техник, которые потребовали от меня изменений b вернемся к логической матрице.
  • Обновление 5: A комментарий от Аслака Гринстеда в вышеупомянутом сообщении в блоге предлагается еще более короткий алгоритм как для логики, так и для выполнения свертки (с использованием функции ФИЛЬТР2), поэтому я "включил" (читай "скопировал") его предложения.;)
  • Обновление 6: Вырезаны два символа из инициализации b и переработал логику в цикле, чтобы сохранить 1 дополнительный символ.
  • Обновление 7: Эрик Сэмпсон указал в электронном письме, что я мог бы заменить cell2mat с char, сохраняя 4 символа.Спасибо, Эрик!

Ruby 1.9 - 189 178 159 155 153 Chars

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

Редактировать:Обрабатывает новые линии с 4 частями меньше.
Может удалить еще 7 (v<?.?v:) Если вы позволите ему Clobber Newlines, когда живые клетки достигают краев.

Python - 282 Chars

может также получить шарика ...

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 символы

Хорошо, код 210-символа-это своего рода мошенничество.

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

Вы, вероятно, не сможете скопировать и вставить этот код и заставить его работать. Предполагается, что это будет латинская 1 (ISO-8859-1), но я думаю, что он был извращен в Windows-1252 где-то по пути. Кроме того, ваш браузер может проглотить некоторых персонажей, не относящихся к ASCII.

Так что, если это не работает, вы можете генерировать файл от простых 7-битных символов:

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

Результатом этого является действительный исходный файл Python Python 210-символа. Все, что я сделал здесь, это используется сжатие на молнии на исходном исходном коде Python. Настоящий чит в том, что я использую не ASCII символы в результирующей строке. Это все еще действительный код, это просто громоздкий.

Некомпрессивная версия весит 234 символа, что, я думаю, все еще является респектабельным.

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

Извините за горизонтальный свиток, но требуются все новички в вышеперечисленном, и я считал их по одному персонажу каждый.

Я бы не пытался прочитать гольф код. Имена переменной выбраны случайным образом для достижения наилучшего сжатия. Да я серьезно. Следует лучше отформатированная и комментированная версия:

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

Извините, Pythonistas, для форматирования кронштейна C-ISH, но я пытался понять то, что закрывалось каждый кронштейн.

Haskell - 284 272 232 символа

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

Я мог бы снизить это, но мне это нравится, так как это все еще в балкомпарк и довольно читаемо.

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

РЕДАКТИРОВАТЬ

428

По просьбе, вот мой следующий удар:

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

Это сокращение на 14% с некоторым основным гольфом. Я не могу не чувствовать, что я теряю, используя 2D-массив / массив строк, а не 1D массив, но не хочется делать это преобразование сейчас. Обратите внимание, как я элегантно читаю файл 3200 раз, чтобы инициализировать мой массив :)

Рубин 1.8: 178 175 символов

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

Новые строки имеют большое значение (хотя все они могут быть заменены точкой с запятой).

Редактировать: исправлена проблема с переводом строки и урезаны 3 символа.

Java, 441... 346

  • Обновление 1 Удалено внутреннее "если" и еще больше уродства
  • Обновление 2 Исправлена ошибка и получен персонаж
  • Обновление 3 Используя намного больше памяти и массивов, игнорируя при этом некоторые проблемы с границами.Вероятно, несколько символов можно было бы сохранить.
  • Обновление 4 Сэкономил несколько символов.Спасибо Балуску.
  • Обновление 5 Несколько незначительных изменений, чтобы опуститься ниже 400 и сделать его еще немного уродливее.
  • Обновление 6 Теперь все так жестко закодировано, что с таким же успехом можно прочитать точное количество за один раз.Плюс еще несколько сбережений.
  • Обновление 7 Перенесите запись в файл, чтобы сохранить символ.Плюс несколько странных моментов.

Просто поиграл с решением BalusC.Ограниченная репутация означает, что я не смог ничего добавить в качестве комментария к нему.

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

Более читаемая (?) версия:

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

Скала - 467 364 339 Чарс

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

Я думаю, что есть много возможностей для улучшения ...

Редактировать Да, это:

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

Редактировать И у меня такое чувство еще больше выжимать ...

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

В следующем решении используется мой собственный язык программирования, специфичный для домена, который я назвал NULL: 

3499538

Если вам интересно, как это работает: мой язык состоит только из одной ставки на программу. Заявление представляет собой идентификатор нитки стоковой двери, принадлежащий к коде гольф-нить. Мой компилятор компилирует это в программу, которая ищет лучшее решение JavaScript (с SO API) загружает его и запускает его в веб-браузере.

Среда выполнения может быть лучше для новых потоков (для появления первого ответа JavaScript может потребоваться некоторое время, но с другой стороны, это требует лишь очень небольших навыков кодирования.

JavaScript/node.js - 233 236 персонажи

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.

Просто задавался вопросом, насколько меньше и уроднее, мое решение Java может пойти на C. Сокращено до 300, включая новички для препроцессорных битов. Листья освобождает память в ОС! Можно сохранить ~ 20, предполагая, что ОС закроет и промывает файл.

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

Момуники: 314 символов

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

Джава, 556 532 517 496 472 433 428 420 418 381 Чарс

  • Обновление 1: заменил 1 -й StringBuffer по Appendable и 2 -й char[]. Анкет Сохранено 24 символа.

  • Обновление 2: нашел более короткий способ прочитать файл в char[]. Анкет Сохранено 15 символов.

  • Обновление 3: заменил один if/else по ?: и слился char[] и int декларации. Сэкономил 21 Chars.

  • Обновление 4: заменены (int)f.length() и c.length по s. Анкет Сохранено 24 символа.

  • Обновление 5: Сделал улучшения в соответствии с намеками на Молихилл. Основным был жесткий кодирование длины чара, чтобы я мог избавиться от File. Анкет Сэкономил 39 Chars.

  • Обновление 6: незначительный рефакторинг. Сохранено 6 символов.

  • Обновление 7: заменены Integer#valueOf() по new Integer() и рекакторов для цикла. Сохранено 8 символов.

  • Обновление 8: Улучшенный соседский расчет. Сохранено 2 символа.

  • Обновление 9: Оптимизированное чтение файлов, так как длина файла уже жестко кодирована. Сэкономил 37 Chars.

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

Более читаемая версия:

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

Закрытие после записи абсолютно обязательно, а файл остается пустым. В противном случае это было бы спасти еще 21 символ.

Далее я мог бы также сэкономить еще один символ, когда я использую 46 вместо '.', но как Javac и Eclipse Jerks с ошибкой компиляции Возможная потеря точности. Анкет Странные вещи.

Примечание: это ожидает входной файл с \n Ньюлайн, нет \r\n Как использует окна по умолчанию!

Php - 365 328 322 символов.

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

Я уверен, что это может быть улучшено, но мне было любопытно, что он будет выглядеть в PHP. Может быть, это вдохновляет кого-то, у кого есть немного большего опыта для гольфа кода.

  • Обновленный Используйте список () вместо $ var = $ _server ["ARGV"] для обоих ARGS. Хороший дон
  • Обновленный += и -= это заставило меня /facepalm хех не могу поверить, что я пропустил это
  • Обновленный Вывод файла для использования file_put_contents () Еще один хороший улов Дона
  • Обновленный Удаленная инициализация vars $ q и $ w они не использовались

R 340 Chars.

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

Я чувствую, что это немного обманывает, чтобы иметь добавление в упаковке, который делает для вас фактические автоматы, но я иду с ним, потому что мне все еще пришлось разбить с помощью матриц и прочего, чтобы читать в файле с «X» вместо 1.

Это мой первый «кодовый гольф», интересно ....

C ++ - 492 454 386

мой первый код гольф;)

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

Несколько пересмотренная версия, заменив часть логики на поиск таблицы+несколько других незначительных трюков:

#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 символов

Что, нет Perl записей еще? 

$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

Бежать с: 

conway.pl infile #times

Еще одна попытка Java, 361 символ

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

И немного более читаемо

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

Очень похоже на версию Молехилла. Я попытался использовать другой автор файлов и подсчитать соседей ячейки без дополнительной переменной. К сожалению, RandomAccessFile это довольно длинное имя, и требуется, чтобы вы передали режим доступа к файлу.

Ржавчина - 469 символовНе знаю, должен ли я опубликовать это здесь, (этот пост 3 года) Но в любом случае, моя попытка на этом, в ржавчине (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);}

Для людей заинтересована, вот код перед каким -то агрессивным гольфу:

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

ét voilà Вы можете использовать этот HTML -файл. Нет ввода файла, но текстовая модель, которая выполняет задание! Существует также некоторый HTML и инициация и VARS. Основная рутина имеет только 235 символов. Это ручная передача 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>

Один из классических паттернов

***
..*
.*

Мой аватар был создан с использованием моей версии Game of Life с использованием этого шаблона и правила (обратите внимание, что оно не равно 23/3).:

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

ИМХО - как я узнал из книги Конвея "Игра в жизнь", фокус заключался не в написании короткого кода, а в коде, который мог быстро создавать сложные формы жизни.Используя классический шаблон выше и обернутый мир из 594441 ячейки, лучшее, что я когда-либо мог сделать, составляло около 1000 поколений в секунду.

Еще один простой шаблон

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

И планеры

........................*...........
......................*.*...........
............**......**............**
...........*...*....**............**
**........*.....*...**..............
**........*...*.**....*.*...........
..........*.....*.......*...........
...........*...*....................
............**......................
Лицензировано под: CC-BY-SA с атрибуция
Не связан с StackOverflow
scroll top