Luftpolsterfolien sind Unterhaltung auf höchstem Niveau. Dem kann jeder zustimmen.

Jetzt lassen Sie sogar Computer Luftpolsterfolien genießen.

Technische Daten

Sie erhalten zwei Ganzzahlen, w und h (jeweils Breite und Höhe).

Ihr Programm sollte alle w * h Phasen ausgeben, die jeweils 1 Sekunde warten und enden.

Jede Luftpolsterfolie beginnt, wenn alle Zellen voll sind.

Zum Beispiel beginnt eine 4 * 6-Luftpolsterfolie wie folgt:

O_O_
_O_O
O_O_
_O_O
O_O_
_O_O

Und in jeder Phase wird eine zufällige nicht-gepoppte Zelle gepoppt.

O_O_
_O_O
O_X_
_O_O
O_O_
_O_O

Das Programm sollte beendet werden, wenn alle Zellen aufgetaucht sind. aka.

X_X_
_X_X
X_X_
_X_X
X_X_
_X_X

Beispiele

(4,6)
(5,5)
(6,2)
(10,10)
(7,9)

C (Windows) 260 248 Bytes

#import<windows.h>
i,j,l,r;b(w,h){char*s=malloc(l=w*h+h);for(i=h;i--;*s++=10)for(j=w;j--;*s++=i%2^j%2?79:45);*(s-1)=0;s-=l;for(srand(time(0));j>system("cls")+puts(s)-2;j>-1?s[j]=88:0)for(Sleep(1000),r=rand(),j=-2,i=r+l*2;--i-r;j=s[i%l]==79?i%l:j);}

Python 3 , 222-220 Bytes

Dies ist meine erste Antwort. Seien Sie also bitte vorsichtig (und weisen Sie auf Fehler hin, die ich gemacht habe).

import time,random as t
def f(c,r):
 p=print;a='0_'*c;d=((a[:c]+'\n'+a[1:c+1]+'\n')*r)[:-~c*r]
 for i in[1]*((r*c+r%2*c%2)//2):
  p(d);k=1
  while d[k]!='0':k=t.randrange(len(d))
  d=d[:k]+'X'+d[k+1:];time.sleep(1)
 p(d)

Probieren Sie es online!

Wie es funktioniert:

1. Verkette viele '0 _' zusammen
2. In '0_0 _... \ n' und '_0_0 ... \ n' Teile zerlegen und verketten
3. Generiere zufällige Indizes, bis das Zeichen am Index eine '0' ist
4. Erstellen Sie eine neue Zeichenfolge, wobei das Zeichen am generierten Index durch ein 'X' ersetzt wird (Verdammt, Python für nicht veränderbare Zeichenfolgen!)
5. Wiederholungszeiten r*c+r%2*c%2: r*cDas Muster enthält Blasen, es sei denn, r und c sind beide ungerade, in diesem Fall r*c+1.

MATL , 37 Bytes

:!i:+o`T&Xxt3:q'_OX'XEcD2y1=ft&v1Zr(T

Die obere linke Ecke ist immer ein Unterstrich (erlaubt durch die Herausforderung).

Der Bildschirm wird zwischen den Phasen gelöscht. Ich könnte ein Byte sparen, indem ich den Bildschirm nicht lösche, aber so sieht es besser aus.

Das Programm wird mit einem Fehler ( standardmäßig zulässig ) beendet, nachdem alle Phasen angezeigt wurden .

Probieren Sie es bei MATL Online! (Wenn es nach ein paar Sekunden nicht funktioniert, aktualisieren Sie die Seite und versuchen Sie es erneut.)

Mathematica (145 Bytes)

Anonyme Funktion, verwendet Höhe und Breite als Eingabe (in dieser Reihenfolge - wenn dies ein Problem ist, ersetzen Sie {##}durch {#2,#}in der Mitte des Codes für zusätzliche 2 Bytes).

Code:

Monitor[Do[Pause@1,{i,NestList[RandomChoice@StringReplaceList[#,"O"->"X"]&,""<>Riffle["_"["O"][[Mod[#+#2,2]]]&~Array~{##},"
"],Floor[##/2]]}],i]&

Erläuterung:

• ""<>Riffle[Array["_"["O"][[Mod[#+#2,2]]]&,{##}],"\n"] Erstellt die erste, nicht platzierte Luftpolsterfolie, indem ein Array aus "_" und "O" erstellt und zwischen den Zeilenumbrüchen ein String eingefügt wird.
• NestList[RandomChoice@StringReplaceList[#,"O"->"X"]&,..., Floor[##/2]]wählt wiederholt eines der "O" aus, um es durch ein "X" zu ersetzen, so oft es "O" gibt (das ist Floor [width * height / 2] - danke an @JonathanAllan für die Idee, "_" zu setzen "anstelle von" O "in der oberen linken Ecke, sonst wäre dies Ceilingstattdessen und damit 2 Bytes mehr).
• Monitor[Do[Pause@1,{i,...}],i]Lässt idie Werte in der soeben berechneten Liste für jeweils 1 Sekunde übernehmen und dynamisch drucken i.

Beispielausgabe:

Gelee , 30 29 Bytes

=”OTX
+þ⁹++µị⁾_OYµṄœS1”XǦµÐL

Ruft den Link als Dyade mit den Programmargumenten auf und beendet ihn dann mit einer Meldung (der Code, für den gilt çṛ“\'=ṙMḋḌẓ(ėo»).

Nuance: die untere rechte „Zelle“ wird immer eine Blase sein (statt oben links wie das Beispiel in der Frage), dies, um sicherzustellen ist , wenn alle Blasen , die zufällige Wahl kehrt geknallt werden 0 die das sein wird , "X"bei der Ende der Liste - Ersetzen, ändert den Wert nicht und unterbricht die Schleife.

Hinweis: Der Bildschirm wird nicht gelöscht (wurde nicht angegeben, und ich bin nicht sicher, wie ich das tun soll).

Wie?

=”OTX - Link 1, choose a random O index or 0: string   e.g. "_O_\nX_O"
 ”O   - "O"
=     - equals (vectorises over the string)            e.g. [0,1,0,0,0,0,1]
   T  - truthy indexes                                 e.g. [2,7]
    X - random choice (if empty this returns 0)

+þ⁹++µị⁾_OYµṄœS1”XǦµÐL - Main link: w, h              e.g. 3, 2
                        - left argument (implicit), w  e.g. 3
  ⁹                     - right argument, h            e.g. 2
 þ                      - outer product with
+                       -     addition                 e.g. [[2,3,4],[3,4,5]]
                        - left argument (implicit), w  e.g. 3
   +                    - add                          e.g. [[5,6,7],[6,7,8]]
                        - right argument (implicit), h e.g. 2
    +                   - add                          e.g. [[7,8,9],[8,9,10]]
     µ                  - monadic chain separation
       ⁾_O              - "_O"
      ị                 - index into (1-based & mod)   e.g. [['_','O','_'],['O','_','O']]
                        -     note: the additions above assure the last entry is an 'O'.
          Y             - join with line feeds         e.g. ['_','O','_','\n','O','_','O']
           µ        µ   - monadic chain separations
                     ÐL - loop until the results are no longer unique:
            Ṅ           -     print with a trailing line feed and yield
             œS1        -     sleep for 1 second and yield
                   ¦    -     apply to index
                  Ç     -         given by calling the last link (1) as a monad 
                        -                 (a random O index or 0 if none exists)
                ”X      -         an "X"  (      ... which will be an X already)

Scala , 764 Bytes

object B{
  def main(a: Array[String]):Unit={
    val v=false
    val (m,l,k,r,n)=(()=>print("\033[H\033[2J\n"),a(0)toInt,a(1)toInt,scala.util.Random,print _)
    val e=Seq.fill(k, l)(v)
    m()
    (0 to (l*k)/2-(l*k+1)%2).foldLeft(e){(q,_)=>
      val a=q.zipWithIndex.map(r => r._1.zipWithIndex.filter(c=>
        if(((r._2 % 2) + c._2)%2==0)!c._1 else v)).zipWithIndex.filter(_._1.length > 0)
      val f=r.nextInt(a.length)
      val s=r.nextInt(a(f)._1.length)
      val i=(a(f)._2,a(f)._1(s)._2)
      Thread.sleep(1000)
      m()
      val b=q.updated(i._1, q(i._1).updated(i._2, !v))
      b.zipWithIndex.map{r=>
        r._1.zipWithIndex.map(c=>if(c._1)n("X")else if(((r._2 % 2)+c._2)%2==0)n("O")else n("_"))
        n("\n")
      }
      b
    }
  }
}

Wie es funktioniert

Der Algorithmus füllt zuerst eine 2D-Sequenz mit falschen Werten. Anhand der eingegebenen Befehlszeilenargumente wird festgelegt, wie viele Iterationen (offene Kästchen) vorhanden sind. Es wird eine Falte mit diesem Wert als Obergrenze erstellt. Der ganzzahlige Wert der Falte wird nur implizit verwendet, um zu zählen, für wie viele Iterationen der Algorithmus ausgeführt werden soll. Die zuvor erstellte gefüllte Sequenz ist die Startsequenz für die Falte. Dies wird verwendet, um eine neue 2D-Sequenz falscher Werte mit ihren entsprechenden Abhängigkeiten zu generieren.

Beispielsweise,

[[false, true],
 [true, false],
 [true, true]]

Wird verwandelt in

[[(false, 0)], [(false, 1)]]

Beachten Sie, dass alle Listen, die vollständig wahr sind (eine Länge von 0 haben), in der Ergebnisliste weggelassen werden. Der Algorithmus nimmt dann diese Liste und wählt eine zufällige Liste in der äußersten Liste aus. Die Zufallsliste wird als die zufällige Zeile ausgewählt, die wir auswählen. Aus dieser Zufallszeile finden wir wiederum eine Zufallszahl, einen Spaltenindex. Sobald wir diese beiden Zufallsindizes gefunden haben, schlafen wir den Thread, auf dem wir uns befinden, für 1000 Millisekunden.

Nachdem wir schlafen gegangen sind, löschen wir den Bildschirm und erstellen ein neues Board mit einem trueWert, der in den von uns erstellten Zufallsindizes aktualisiert wurde.

Um dies richtig auszudrucken, verwenden wir es mapund komprimieren es mit dem Index der Karte, damit wir das in unserem Kontext haben. Wir verwenden den Wahrheitswert der Sequenz, um festzustellen, ob wir ein Xoder eines Ooder drucken sollen _. Für letztere verwenden wir den Indexwert als Richtwert.

Interessante Dinge zu beachten

Um herauszufinden, ob ein Ooder ein ausgegeben werden soll _, wird die Bedingung ((r._2 % 2) + c._2) % 2 == 0verwendet. r._2verweist auf den aktuellen Zeilenindex, während c._2auf die aktuelle Spalte verwiesen wird. Befindet man sich in einer ungeraden Zeile, r._2 % 2so ist dies 1 und wird daher c._2in der Bedingung um eins versetzt. Dies stellt sicher, dass in ungeraden Zeilen die Spalten wie vorgesehen um 1 verschoben werden.

Das "\033[H\033[2J\n"Ausdrucken der Zeichenfolge löscht den Bildschirm gemäß einer von mir gelesenen Stackoverflow-Antwort. Es schreibt Bytes an das Terminal und erledigt ein paar unkonventionelle Dinge, die ich nicht wirklich verstehe. Aber ich habe festgestellt, dass es der einfachste Weg ist, dies zu tun. Auf dem Konsolenemulator von Intellij IDEA funktioniert dies jedoch nicht. Sie müssen es mit einem normalen Terminal ausführen.

Eine andere Gleichung, die man beim ersten Blick auf diesen Code als seltsam empfinden könnte, ist (l * k) / 2 - (l * k + 1) % 2. Lassen Sie uns zuerst die Variablennamen entmystifizieren. lverweist auf die ersten Argumente, die an das Programm übergeben werden, während kauf das zweite Argument verwiesen wird . Übersetzen sie, (first * second) / 2 - (first * second + 1) % 2. Das Ziel dieser Gleichung ist es, die genaue Anzahl der Iterationen zu ermitteln, die erforderlich sind, um eine Folge aller X zu erhalten. Das erste Mal, als ich das tat, tat ich einfach so, (first * second) / 2wie es Sinn machte. Für jedes nElement in jeder Unterliste gibt es n / 2Blasen, die wir platzen lassen können. Dies bricht jedoch beim Umgang mit Eingaben wie(11 13). Wir müssen das Produkt der beiden Zahlen berechnen, es ungerade machen, wenn es gerade ist und gerade, wenn es ungerade ist, und dann die Modifikation um 2 nehmen. Dies funktioniert, weil Zeilen und Spalten, die ungerade sind, eine Iteration weniger erfordern um zum Endergebnis zu gelangen.

mapwird anstelle von a verwendet, forEachda es weniger Zeichen enthält.

Dinge, die wahrscheinlich verbessert werden können

Eine Sache, die mich an dieser Lösung wirklich stört, ist die häufige Verwendung von zipWithIndex. Es nimmt so viele Charaktere auf. Ich habe versucht, es so zu gestalten, dass ich meine eigene Ein-Zeichen-Funktion definieren kann, die nur zipWithIndexmit dem übergebenen Wert ausgeführt wird. Es stellt sich jedoch heraus, dass Scala einer anonymen Funktion keine Typparameter erlaubt. Es gibt wahrscheinlich einen anderen Weg, um das zu tun, was ich mache, ohne es zu benutzen, zipWithIndexaber ich habe nicht zu viel über einen klugen Weg nachgedacht, es zu tun.

Derzeit wird der Code in zwei Durchgängen ausgeführt. Der erste generiert eine neue Karte, während der zweite Durchgang sie druckt. Ich denke, dass, wenn man diese zwei Durchläufe in einem Durchlauf kombinieren würde, das ein paar Bytes sparen würde.

Dies ist das erste Codegolf, das ich gemacht habe, daher bin ich mir sicher, dass es viel Raum für Verbesserungen gibt. Wenn Sie den Code sehen möchten, bevor ich ihn so weit wie möglich auf Bytes optimiert habe, finden Sie ihn hier.

JavaScript (ES6), 246 229 Byte

document.write(`<pre id=o></pre>`)
setInterval(_=>{(a=o.innerHTML.split(/(O)/))[1]?a[Math.random()*~-a.length|1]=`X`:0;o.innerHTML=a.join``},1e3)
f=(w,h)=>o.innerHTML=[...Array(h)].map((_,i)=>`O_`.repeat(w+h).substr(i,w)).join`
`

<div oninput=f(+w.value,+h.value)><input id=w type=number min=1><input id=h type=number min=1>

Python - 290 Bytes

Ich habe noch nie zuvor eine davon gemacht - für konstruktive Kritik wäre ich also dankbar :)

Haupttrick dabei ist nur das nervig verschachtelte Listenverständnis. Ich könnte ein paar Zeichen einsparen, indem ich zwischen den Pops kein Zeilenumbruch mache, aber das sieht einfach hässlich aus.

r=range
q=print
import random as n,time
def f(H,W):
    def p(b):
        q("\n".join(["".join(["O"if(i,j)in b else"X"if(i,j)in X else"_"for j in r(H)])for i in r(W)]));time.sleep(1);q()
    b=[(i,h)for h in r(H)for i in r(h%2,W,2)];n.shuffle(b);X=[]
    while len(b)>0:
        p(b);X+=[b.pop()]
    p(b)

Kohle , 49 46 39 Bytes (nicht konkurrierend)

ＵＯＮＮO_¶_OＡＫＡαＡ№αOβＨＷψβ«Ａ§α§⌕ＡαO‽βXＡ№αOβ

Ausführlich

Oblong(InputNumber(), InputNumber(), "O_\n_O")
Assign(PeekAll(), a)
Assign(Count(a, "O"), b)
RefreshWhile (k, b) {
    AssignAtIndex(a, AtIndex(FindAll(a, "O"), Random(b)), "X")
    Assign(Count(a, "O"), b)
}

APL (Dyalog) , 61 59 Bytes

⎕←m←'O_'[2|-/¨⍳⎕]
(b/,m)[?+/b←'O'=,m]←'X'
⎕DL 1
→2/⍨'O'∊⎕←m

⎕← Ausgabe
m← m , wo m ist
'O_'[... ] Diese Zeichen indiziert durch ...
 2| die Teilung-Rest-when-geteilt-durch-zwei von
 -/¨ der Differenz zwischen jedem von
 ⍳ allen der Koordinaten (Indizes) in einer Anordnung von Form
 ⎕ numerischen Eingang (die Anzahl der Zeilen und Spalten , )

(... )[... mit ]←'X' dem Zeichen X zu einer der ... zuweisen
 b/ filterten by- b (zu definieren)
 ,m Elemente von M raveled, insbesondere ...
 ? ein Zufallselement (Lit. Zahl) im Bereich einer zu
 +/ der Summe aus
 b← b , wobei b ist
 'O'= Boolesche denn wo der Buchstabe gleich
 ,m m ist, hat sich gerastert

⎕DL 1 D e l ay eine Sekunde

→2 Gehen Sie zu Zeile 2,
/⍨ wenn (lit. gefiltert nach),
'O'∊ ob der Buchstabe ein Mitglied des
⎕←m ausgegebenen Werts ist, wobei der ausgegebene Wert m ist

Probieren Sie es online!

Ab Version 16.0 wird es kürzer sein:

{0::→⋄'X'@(⊂(?∘≢⊃⊢)⍸'O'=⍵⊣⎕DL 1)⊢⎕←⍵}⍣≡'O_'[2|-/¨⍳⎕]

Python 3, 195 188 Bytes

import time,random
def f(w,h):
 a=bytearray(b'0-'*w*h);b=[*range(0,w*h,2)];random.shuffle(b);
 while 1:print(*(a.decode()[w*i:w*i+w]for i in range(h)),sep='\n');a[b.pop()]=88;time.sleep(1)

Die Verwendung von bytearrayund decodescheint kürzer zu sein als das Schneiden und Zusammensetzen einer Saite a la a[:i]+'X'+a[i+1:].

import time,random
def f(w,h):
 x=[*range(1,h*w,2)];random.shuffle(x)
 while 1:
  for i in range(w*h):
   print('-X0'[(i%w%2!=i//w%2)+(i in x)],end='\n'[i%w<w-1:])
  print();time.sleep(1);x.pop()

Java 7, 317 Bytes

void c(int w,int h)throws Exception{String r="";int x=0,j=0,i;for(;j++<h;x^=1,r+="\n")for(i=0;i<w;r+=(i+++x)%2<1?"_":"O");for(System.out.println(r);r.contains("O");System.out.println(r=r.substring(0,x)+'X'+r.substring(x+1))){Thread.sleep(1000);for(x=0;r.charAt(x)!='O';x=new java.util.Random().nextInt(r.length()));}}

Erläuterung:

void c(int w, int h) throws Exception{                     // Method with two integer parameters (throws Exception is required for the Thread.sleep)
  String r = "";                                           //  String we build to print
  int x=0, j=0, i;                                         //  Some temp values and indexes we use
  for(; j++<h;                                             //  Loop over the height 
      x^=1,                                                //    After every iteration change the flag `x` every iteration from 0 to 1, or vice-versa
      r += "\n")                                           //    And append the String with a new-line
    for(i=0; i<w;                                          //   Inner loop over the width
        r += (i++ + x)%2 < 1 ? "_" : "O")                  //    Append the String with either '_' or 'O' based on the row and flag-integer
    ;                                                      //   End inner width-loop (implicit / no body)
                                                           //  End height-loop (implicit / single-line body)
  for(                                                     //  Loop
    System.out.println(r);                                 //   Start by printing the starting wrap
    r.contains("O");                                       //   Continue loop as long as the String contains an 'O'
    System.out.println(r=                                  //   Print the changed String after every iteration
        r.substring(0,x)+'X'+r.substring(x+1))){           //    After we've replaced a random 'O' with 'X'
      Thread.sleep(1000);                                  //   Wait 1 second
      for(x=0; r.charAt(x) != 'O';                         //   Loop until we've found a random index containing still containing an 'O'
          x = new java.util.Random().nextInt(r.length()))  //    Select a random index in the String
      ;                                                    //   End loop that determines random index containing 'O' (implicit / no body)
  }                                                        //  End loop
}                                                          // End method

Testgif (4,6)

Perl, 148 Bytes

146 Byte Code + -plFlags.

$_=O x($x=$_+1);s/O\K./_/g;for$i(1..($y=<>)){$b.=($i%2?$_:_.s/.$//r).$/}}print$_="\e[H$b";while(/O/){$r=0|rand$y*$x+3;s/.{$r}\KO/X/s||redo;sleep 1

Um es auszuführen:

perl -ple '$_=O x($x=$_+1);s/O\K./_/g;for$i(1..($y=<>)){$b.=($i%2?$_:_.s/.$//r).$/}}print$_="\e[H$b";while(/O/){$r=0|rand$y*$x+3;s/.{$r}\KO/X/s||redo;sleep 1' <<< "6
4"

MATLAB (R2016b), 172 Bytes

Code:

x=input('');m=[eye(x(2),x(1)) ''];m(:)='O';m(1:2:end,2:2:end)='_';m(2:2:end,1:2:end)='_';o=find(m=='O');r=o(randperm(nnz(o)));disp(m);for i=r';pause(1);m(i)='X';disp(m);end

Empfehlungen sind immer willkommen! Probieren Sie es online!

Programmausgabe:

Erläuterung:

x = input( '' );                    % Input
m = [ eye( x( 2 ), x( 1 ) ) '' ];   % Character Matrix
m( : ) = 'O';                       % Fill Matrix with "Bubbles"

m( 1:2:end, 2:2:end ) = '_';        % Alternate Spaces Between Bubbles (Part 1)
m( 2:2:end, 1:2:end ) = '_';        % Alternate Spaces Between Bubbles (Part 2)

o = find( m == 'O' );               % Index Bubble Locations
r = o( randperm( nnz( o ) ) );      % Randomize Bubble Locations

disp( m );                          % Display Initial Bubble Wrap Phase

for i = r'
    pause( 1 );                     % Pause for 1 Second
    m( i ) = 'X';                   % Pop Bubble
    disp( m );                      % Display Subsequent Bubble Wrap Phase
end