One Line Aquarium


31

I miei suoceri hanno un laghetto nel loro cortile, pieno di koi. Non mi è passato per la testa finché non ho notato il seguente estratto dal mio codice.

',') & '_'

... Avevo le facce di pesce che mi guardavano dallo schermo ...

Il che mi ha dato un'ottima idea ...

La mia ricerca per voi, miei cari golfisti, è quella di creare un acquario ASCII a una linea, con le seguenti regole:

  • La dimensione dell'acquario dal lato del serbatoio all'altro lato del serbatoio non deve essere inferiore a 60 caratteri e non superiore a 80 caratteri. I lati del serbatoio devono essere indicati usando il carattere pipe / bar ( |).
  • I pesci devono essere in grado di "nuotare" da sinistra a destra tra i lati della vasca. Mentre gireranno, è necessaria una vista frontale per il passaggio da una direzione all'altra.
  • Il pesce deve essere simile al seguente:

    • }}< }} ',') Pesce che nuota bene
    • (',' {{ >{{ Pesce che nuota a sinistra
    • }}('_'){{ Pesce di fronte
  • Quando un pesce gira per cambiare direzione (probabilità del 30%), deve iniziare da una direzione, rivolto verso la parte anteriore, quindi rivolto nell'altra direzione ... Assicurati che ci sia ampio spazio per la rotazione del pesce, cioè richiede sei spazi prima del bordo del serbatoio minimo ...

  • A meno che un pesce non stia soffiando una bolla o cambiando direzione, continuerà nella direzione in cui è rivolto, se arriva entro sei spazi dal lato della vasca, cambierà direzione.
  • Il pesce (rivolto a sinistra o a destra) può occasionalmente (10% di probabilità) smettere di soffiare bolle in successione ( .oO*), quindi è necessario che il pesce abbia uno spazio disponibile accanto a loro affinché esista la bolla, quindi un pesce può nuota solo vicino ai lati, salva uno spazio. La bolla deve scomparire prima che il pesce possa andare avanti ...

Una serie di linee di esempio del comportamento del pesce, con -caratteri che indicano gli spazi, poiché la funzione di visualizzazione del codice qui è un po 'severa ... Mi aspetto che questi trattini vengano sostituiti con spazi quando codifichi questo ...

Ogni riga qui può essere considerata un frame in time-lapse.

|-}}< }} ',')----------|
|--}}< }} ',')---------|
|---}}< }} ',')--------|
|----}}< }} ',')-------|
|-----}}< }} ',')------|
|-----}}< }} ',').-----|
|-----}}< }} ',')o-----|
|-----}}< }} ',')O-----|
|-----}}< }} ',')*-----|
|---------}}('_'){{----|
|-----------(',' {{ >{{|
|----------(',' {{ >{{-|
|---------(',' {{ >{{--|
|--------.(',' {{ >{{--|
|--------o(',' {{ >{{--|
|--------O(',' {{ >{{--|
|--------*(',' {{ >{{--|
|--------(',' {{ >{{---|
|-------(',' {{ >{{----|
|------(',' {{ >{{-----|

ecc. L'esempio sopra è, come ho detto, piccolo, ma hai l'idea generale ...

Il codice più corto vince ...

Mi aspetto l'output sulla stessa riga (se possibile), in caso contrario, visualizzare un frame dopo l'altro in successione va bene ... Che tu vada su una riga o su più righe dipende da te. Se stai facendo più righe, devono essere separate da una nuova riga.

Inoltre viene imposto un timer tra i frame, 2000ms. Questo è obbligatoria .

Vediamo cosa hai!


Se il pesce si avvicina troppo al bordo dell'acquario, deve girare o potrebbe fuoriuscire dallo schermo? Deve essere possibile che il pesce soffi bolle in questa situazione? Inoltre, deve essere possibile (o è vietato, o è consentito ma non richiesto) che i pesci soffino bolle due volte in successione?
John Dvorak,

1
Aspetta, no, non fare cambiamenti come questo! Ho già iniziato a scrivere codice! Ti dispiacerebbe tornare indietro?
John Dvorak,

5
Si prega di utilizzare la sandbox la prossima volta.
John Dvorak,

1
Non è esplicitamente dichiarato, ma immagino che ci debba essere esattamente un pesce nell'acquario?
John Dvorak,

1
È necessario che il pesce possa bolle due volte in successione o è consentito farlo accadere? Fa una differenza di tre caratteri per me.
John Dvorak,

Risposte:


11

Python 3 (278)

Precedentemente: 334, 332, 325, 302, 300, 299, 291, 286, 284, 281

import random,time
r=random.random
F="}}('_'){{%s","}}< }} ',')%s","%s(',' {{ >{{"
p,d=9,1
c=b=0
while 1:
 if c:p-=c+c*3*(2*d+c==1);d=c-c*d*d;c-=d
 elif b%5:b+=1
 elif.3>r()or{p*d}<{-5,53}:c=-d
 elif.1>r():b=1
 else:p+=d
 print('|%-70s|'%(' '*p+F[d])%' .oO*'[b%5]);time.sleep(2)

Giocare a golf in Python è sempre difficile a causa dei requisiti di rientro delle dichiarazioni, ma nonostante ciò, è andato incredibilmente bene!

Un grande ringraziamento a Volatility e DSM per avermi aiutato a giocare a golf ancora di più.

Versione pulita

from random import random as r
from time import sleep as s
F = { 1: "}}< }} ',')%s", 0: "}}('_'){{%s", -1: "%s(',' {{ >{{" }

# p: position (from left)
# d: direction (-1: left, +1: right)
# c: changing direction (0: not changing, +1: to right, -1: to left)
# b: bubble (0)
p, d, c, b = 9, 1, 0, 0

while 1:
    if c:
        p -= c*[1,4][2*d+c==1]
        if d:
            d = 0
        else:
            d, c = c, 0
    elif b % 5:
        b += 1
    else:
        # change direction
        if r() < .3 or p * d in (-5,53):
            c = -d
        # start bubbling
        elif r() < .1:
            b = 1
        # move forward
        else:
            p += d

    # print fish and sleep
    print('|{:<70}|'.format(' '*p+(F[d]%' .oO*'[b%5])))
    s(2)

7

Rubino, 291 289

l="(',' {{ >{{";m="    }}('_'){{    ";r="}}< }} ',')";w=?\s;s=w*6;q="|#{r+s*9}|"
f=->*s{(puts q;sleep 2)if q.sub! *s}
loop{rand>0.1||(f[") ",")."]||f[" (",".("];f[?.,?o];f[?o,?O];f[?O,?*];f[?*,w])
q[7]==?(||q[-8]==?)||rand<0.3?f[s+l,m]&&f[m,r+s]||f[r+s,m]&&f[m,s+l]:f[w+l,l+w]||f[r+w,w+r]}

Il pesce è lungo undici caratteri, rendendo l'acquario 6 * 9 + 11 + 2 = 67 caratteri di larghezza, che si adatta perfettamente alla tolleranza richiesta.

La ffunzione lambda svolge tutto il lavoro pesante: accetta una sostituzione come coppia di argomenti, quindi tenta di applicare la sostituzione sull'acquario. Se riesce, dipinge un fotogramma dell'animazione. Quindi riporta il valore di successo come 2(ritardo impiegato) o nil(ritardo non eseguito).

I pesci non soffieranno bolle due volte in successione. (Correzione: ...while rand>0.1- 4 caratteri)

I pesci possono soffiare bolle anche prima di una svolta forzata. (Correzione: riorganizzare la struttura ramificata)

C'è una cornice in cui la bolla è completamente sparita (incluso il *) ma il pesce non si è spostato nel vuoto risultante. Questo segue la lettera, ma non l'esempio. (Correzione: sostituire f[?*,w]con q[?*]=w- gratuito)

Non cancella la console. Correzione: aggiungere `clear`(Unix) o system 'cls'(console di Windows) prima puts qdi correggere ( Rif. ) O utilizzare printanziché putse anteporre \rall'acquario ( suggerito da @manatwork ).

Versione leggibile:

# l - left fish; m - middle fish + space; r - right fish
# w - single space character; s - six spaces; q - the aquarium
l="(',' {{ >{{"; m="    }}('_'){{    "; r="}}< }} ',')";
w=" "; s=w*6; q="|#{r+s*9}|"
f = ->k,v do
  if q.sub! k,v
    puts q
    sleep 2
    return 2
  else
    return nil
  end
end

loop do
  if rand < 0.1
    f[") ",")."] || f[" (",".("]
    f[?.,?o]; f[?o,?O]; f[?O,?*]; f[?*,' ']
  end
  if q[7] == "(" || q[-8] == ")" || rand < 0.3
    (f[s+l,m] && f[m,r+s]) || (f[r+s,m] && f[m,s+l])
  else
    f[w+l,l+w] || f[r+w,w+r]
  end
end

Vorrei aggiungere \rall'inizio del q: q="\r|#{r+s*9}|". Quindi utilizzare $><<qinvece di puts q. È più lungo di 1 carattere, ma sembra migliore senza usare comandi esterni.
arte

\rcancella lo schermo? Non nel mio caso. Oppure, perché non ti piace puts?
John Dvorak,

1
No, \rè il ritorno a capo. Usando $><<qper l'output il cursore rimarrà sulla stessa riga ( putsforza un \ndopo l'uscita), quindi l'avvio dell'uscita successiva con un \rsalto tornerà all'inizio della riga corrente e inizierà a produrre da lì. Quindi sovrascrive la precedente "immagine" della linea dell'acquario.
arte

@manatwork sfortunatamente, questo rovina completamente la finestra interattiva di jRuby, che ignora il \r.
John Dvorak,

Oh. Mi dispiace sentirlo. E grazie per l'informazione. Purtroppo questo è il primo fatto che ho imparato su jRuby. :(
arte

3

R, 451 caratteri

Un primo tentativo:

f=function(j,p){cat("\r|",rep("-",j),p,rep("-",50-j),"|",sep="");Sys.sleep(2)};d=F;j=5;P=c("--}}(\'_\'){{--","-}}< }} \',\')-","-(\',\' {{ >{{-");B=c("-",".","o","O","*","-");g=Vectorize(gsub,v="replacement");b=list(g("-$",B,P[2]),g("^-",B,P[3]));repeat{if(j<5 & d){d=!d;j=j+1;f(j,P[1])};if(j>44 & !d){d=!d;f(j,P[1]);j=j-1};if(runif(1)<.1){for(i in b[[d+1]])f(j,i)}else{f(j,P[d+2])};if(runif(1)<.3){d=!d;f(j,P[1]);f(j,P[d+2])};if(d){j=j-1}else{j=j+1}}

rientrato:

f=function(j,p){ #Printing function (depends of buffer and kind of fish)
    cat("\r|",rep("-",j),p,rep("-",50-j),"|",sep="")
    Sys.sleep(2)
}
d=F   #Direction: if FALSE left to right, if TRUE right to left.
j=5   #Buffer from left side of tank
P=c("--}}(\'_\'){{--","-}}< }} \',\')-","-(\',\' {{ >{{-") #The fish
B=c("-",".","o","O","*","-") #The bubble sequence
g=Vectorize(gsub,v="replacement")
b=list(g("-$",B,P[2]),g("^-",B,P[3])) #Fish+bubble
repeat{
    if(j<5 & d){ #What happens if too close from left side
        d=!d
        j=j+1
        f(j,P[1])
        }
    if(j>44 & !d){ #What happens if too close from right side
        d=!d
        f(j,P[1])
        j=j-1}
    if(runif(1)<.1){ #If bubble sequence initiated
        for(i in b[[d+1]])f(j,i)
        }else{f(j,P[d+2])} #Otherwise
    if(runif(1)<.3){ #If fish decide to turn
        d=!d
        f(j,P[1])
        f(j,P[d+2])
    }
    if(d){j=j-1}else{j=j+1} #Increment or decrement j depending on direction
}

Stampa l'acquario come stdout su una sola riga (quindi interruzione di 2 secondi e ritorno del carrello prima della stampa dell'acquario in t + 1).


3

Perl, 281

@f=("s O(',' {{ >{{","s}}('_'){{s","}}< }} ',')O s");$d=1;@o=split//," *Oo. ";{$_="|".$"x$x.$f[$d+1].$"x(44-$x).'|
';s/O/$o[$b]/;s/s/    /g;print;if($b||$t){$b--if$b;if($t){$d+=$t;$t=0if$d}}else{$x+=$d;$t=($x<1)-($x>43);if(!$t){$b=5if.9<rand;if(.7<rand){$t=-$d;$b=0}}}sleep 2;redo}

o più chiaramente

@f = ( "s O(',' {{ >{{", "s}}('_'){{s", "}}< }} ',')O s" );
$d = 1;
@o = split //, " *Oo. ";
{
    $_ = "|" . $" x $x . $f[ $d + 1 ] . $" x ( 44 - $x ) . '|
';
    s/O/$o[$b]/;
    s/s/    /g;
    print;
    if ( $b || $t ) {
        $b-- if $b;
        if ($t) { $d += $t; $t = 0 if $d }
    }
    else {
        $x += $d;
        $t = ( $x < 1 ) - ( $x > 43 );
        if ( !$t ) {
            $b = 5 if .9 < rand;
            if ( .7 < rand ) { $t = -$d; $b = 0 }
        }
    }
    sleep 2;
    redo
}

Pesce che gira correttamente. Bolle che soffiano.

285 - se ti piace il vero acquario e non la versione a scorrimento:

$|=@f=("s O(',' {{ >{{","s}}('_'){{s","}}< }} ',')O s");$d=1;@o=split//," *Oo. ";{$_="\r|".$"x$x.$f[$d+1].$"x(44-$x).'|';s/O/$o[$b]/;s/s/    /g;print;if($b||$t){$b--if$b;if($t){$d+=$t;$t=0if$d}}else{$x+=$d;$t=($x<1)-($x>43);if(!$t){$b=5if.9<rand;if(.7<rand){$t=-$d;$b=0}}}sleep 2;redo}

Dove ti giri? Non riesco a vederti settare $d=0nel caso "svolta obbligatoria".
John Dvorak,

1
sleep2(senza spazio) non funziona per me; anche quando ti giri, non mantieni allineata la faccia del pesce. E le bolle sembrano non apparire mai.
colpì il

"Anche un timer è imposto tra i frame, 2000ms. Questo è obbligatorio." - questo non succede affatto per me. Inoltre, non compaiono bolle, il pesce si trova semplicemente al suo posto. Inoltre, la testa dovrebbe rimanere in posizione mentre il pesce gira, non il centro del corpo (almeno è quello che mostra l'esempio)
John Dvorak,

Accidenti! Golf troppo duro. Hai bisogno di uno spazio extra con il sonno! Anche i pesci gorgogliavano bene!
aspetta

Oops - ho dimenticato la testa nel mezzo quando si gira ai bordi
ho

2

C, 400 394 373 caratteri

#define p printf
#define a(x) l[5]=r[11]=x;d();
char *l="      (',' {{ >{{",*f="    }}('_'){{    ",*r="}}< }} ',')      ",*c,s=7,i,*T;d(){p("|");for(i=0;i<s;i++)p(" ");p(c);for(i=0;i<70-s;i++)p(" ");puts("|");sleep(2);}b(){a(46)a(111)a(79)a(42)a(32)}t(){T=c;c=f;d();c=T==r?l:r;d();}m(){c==l?s--:s++;d();s>69||s<1?t():0;}main(){c=r;for(d();;)i=rand()%10,i?i>6?t():m():b();} 

Con spazi bianchi:

#define p printf
#define a(x) l[5]=r[11]=x;d();
char *l="      (',' {{ >{{",
     *f="    }}('_'){{    ",
     *r="}}< }} ',')      ",
     *c, 
     s=7,
     i,  
    *T; 
d(){
  p("|");
  for(i=0;i<s;i++)
    p(" ");
  p(c);
  for(i=0;i<70-s;i++)
    p(" ");
  puts("|");
  sleep(2);
}
b(){
  a(46)
  a(111)
  a(79)
  a(42)
  a(32)
}
t(){
  T=c;
  c=f;
  d();
  c=T==r?l:r;
  d();
}
m(){
  c==l?s--:s++;
  d();
  s>69||s<1?t():0;
}
main(){
  c=r;
  for(d();;)
    i=rand()%10,
    i?i>6?t():m():b();
}

1
Può i==l?(c=r):(c=l)essere abbreviato in c=i==l?r:l?
John Dvorak,

Sembra che possa essere. Grazie!
Josh,

Puoi salvare alcuni caratteri di#define p printf(
user12205,

@Ace gcc non mi piace quando lo faccio.
Josh,

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.