Simulieren Sie ein 1D-Game-of-Life-Modell

12

Diese Frage hat sich gerade bei der Codeüberprüfung geändert, und ich dachte, Sie könnten sie als Codegolf-Herausforderung anpassen:

Sie erhalten eine nicht leere Liste von x Häusern, die als Boolesche Werte dargestellt werden. Jeden Tag konkurrieren die Häuser mit benachbarten. 1 steht für ein "aktives" Haus und 0 für ein "inaktives" Haus. Wenn die Nachbarn auf beiden Seiten eines bestimmten Hauses entweder beide aktiv oder beide inaktiv sind, wird dieses Haus am nächsten Tag inaktiv. Andernfalls wird es aktiv.

def get_state_as_pos(thelist, pos):
    if thelist[pos-1] == thelist[pos+1]:
        return 0
    else:
        return 1

Wenn wir zum Beispiel eine Gruppe von Nachbarn [0, 1, 0] hätten, würde das Haus bei [1] 0 werden, da sowohl das Haus links als auch rechts inaktiv sind. Die Zellen an beiden Enden prüfen auch die gegenüberliegende Seite, sodass sich die Nachbarn bei Index 0 bei Index length-1und Index n1 befinden und umgekehrt. Auch nach dem Aktualisieren der Zelle müssen Sie beim Aktualisieren der anderen Zellen den vorherigen Status berücksichtigen, damit die Statusinformationen jeder Zelle gleichzeitig aktualisiert werden.

Die Funktion nimmt das Array von Zuständen und eine Anzahl von Schritten auf und sollte den Zustand der Häuser nach der angegebenen Anzahl von Schritten ausgeben.

    input: states = [1, 0, 0, 0, 0, 1, 0, 0], steps = 1
   output should be [0, 1, 0, 0, 1, 0, 1, 1]

    input: states = [1, 1, 1, 0, 1, 1, 1, 1], steps = 2
intermediate state= [0, 0, 1, 0, 1, 0, 0, 0]
   output should be [0, 1, 0, 0, 0, 1, 0, 0]


    input: states = [1], steps=1
    output: states= [0]

Nehmen Sie die Liste und die Schritte nach Belieben und geben Sie die resultierende Liste über die Standard-E / A aus . Standardlücken sind verboten. Dies ist Codegolf, kürzeste Antwort in Bytes gewinnt!

jaaq
quelle
8
+1 für zelluläre Automaten. Ist das nicht Regel 90?
HighlyRadioactive
2
Sollte der erste Testfall nicht dazu führen [0, 1, 0, 0, 1, 0, 1, 1]?
TFeld
4
@jaaq Ich beziehe mich auf die Elementary Cellular Automata Rule (der Transformation zwischen jedem Schritt oder jeder Generation) # 90. Geben Sie "Regel 90" in Wolfram | Alpha ein.
HighlyRadioactive
12
Ausgabe der resultierenden Liste über STDOUT : Es wird dringend empfohlen, sich nur auf unsere Standard-E / A-Methoden zu verlassen .
Arnauld
5
@jaaq Nicht so viel Zufall, da es für jede Standard-1D-Zellularautomatik eine Regel # gibt. Dies liegt daran, dass 3 Bits 8 mögliche Zustände haben (linker Nachbar, Selbst, rechter Nachbar). Wenn Sie für jeden dieser Zustände sagen, dass ein bestimmtes Haus ein- oder ausgeschaltet ist, sind dies 8 wahre / falsche Werte, die zufällig perfekt auf ein Byte abgebildet werden. Daher kann Regel Nr. 0-255 als Kurzform verwendet werden, um einen dieser Regelsätze zu beschreiben, indem der binäre Ausdruck in jeder der 8 Situationen basierend auf der Position im Byte als der resultierende Haus-Ein / Aus-Zustand verwendet wird. Einige Regeln gelten als bemerkenswert, wie 90, daher die Anerkennung :)
Lunin

Antworten:

8

05AB1E , 14 13 10 9 6 Bytes

Basierend auf Shaggys Japt-Lösung

F©Á®À^

Probieren Sie es online aus!

F                  # repeat n times:
 ©Á                #  the list, rotated right
   ®À              #  the list, rotated left
     ^             #  xor (vectorizes)

Unnötig clevere 9-Byte-Lösung:

F¥DO.øü+É

Probieren Sie es online aus!

F                  # repeat n times:
                   #  (examples given for the initial state [0, 1, 1, 0, 1])
 ¥                 #  deltas of the list ([1, 0, -1, 1])
  D                #  duplicate
   O               #  sum (1)
    .ø             #  surround ([1, 1, 0, -1, 1, 1])
      ü+           #  pairwise addition ([2, 1, -1, 0, 2])
        É          #  modulo 2 ([0, 1, 1, 0, 0])
Grimmy
quelle
2

JavaScript (ES6), 57 Byte

Nimmt Eingabe als (steps)(array).

s=>g=a=>s--?g(a.map(_=>a[~-i++%l]^a[i%l],i=l=a.length)):a

Probieren Sie es online aus!

Arnauld
quelle
2

Japt -mh , 11 10 9 Bytes

E / A von Zuständen als Singleton-2D-Arrays.

VÇí^Zé2)é

Versuch es

VÇí^Zé2)é     :Implicit input of integer U=steps & array V=[states]
VÇ            :Modify the last element Z in V
  í           :Interleave with
    Zé2       :  Z rotated right twice and
   ^          :  Reduce each pair by XOR
       )      :End interleave
        é     :Rotate right once
              :Repeat U times and implicitly output V
Zottelig
quelle
2

Netzhaut , 51 Bytes

1A`
"$+"{`(.).*(.)
$2$&$1
(.)(?=.(\1|(.)))?
$#2*$#3

Probieren Sie es online aus! Übernimmt die Anzahl der Schritte in der ersten Zeile und eine Zeichenfolge von 0s und 1s in der zweiten Zeile. Erläuterung:

1A`

Löschen Sie die Anzahl der Schritte von der Eingabe.

"$+"{

Wiederholen Sie diese Anzahl mal.

`(.).*(.)
$2$&$1

Kopieren Sie die Endziffern an die anderen Enden, um das Umbrechen zu simulieren.

(.)(?=.(\1|(.)))?
$#2*$#3

Führen Sie die XOR-Operation aus.

Neil
quelle
2

APL (Dyalog Extended) , 12 Byte SBCS

Volles Programm. Fordert stdin auf, ein Array von Zuständen und dann die Anzahl der Schritte einzugeben. Druckt nach Standard.

1(⌽≠⌽⍢⌽)⍣⎕⊢⎕

Probieren Sie es online aus!

Auswertung der Eingabe von der Konsole (Array von Status)

 dafür bewerben…

1()⍣⎕ Die folgende stillschweigende Funktion, die jedes Mal mit 1dem linken Argument eingegeben wird :

⌽⍢⌽ Drehen Sie das rechte Argument in umgekehrter Reihenfolge 1 Schritt nach links (dh drehen Sie einen Schritt nach rechts).

⌽≠ XOR mit dem Argument 1 Schritt nach links gedreht

Adam
quelle
1

Pyth , 24 Bytes

AQVH=Gmxhded.:+eG+GhG3;G

Probieren Sie es online aus!

AQ                        # G, H = Q[0], Q[1] # Q = input in the form [[states],steps]
  VH                      # for i in range(H):
    =G                    # G = 
      m                   #     map(lambda d:                              )
       xhded              #                   d[0] ^ d[-1],
            .:       3    #         substrings(                 , length=3)
              +eG+GhG     #                     G[-1] + G + G[0]
                      ;   # (end for loop)
                       G  # print G
ar4093
quelle