Moi teściowie mają na swoim podwórku staw rybny wypełniony koi. Tak naprawdę nie przyszło mi to do głowy, dopóki nie zauważyłem następującego fragmentu mojego kodu.

',') & '_'

... Miałem twarze ryb, które patrzyły na mnie z ekranu ...

Co dało mi świetny pomysł ...

Moją misją dla was, moi drodzy golfiści, jest stworzenie akwarium ASCII o jednej linii, zgodnie z następującymi zasadami:

• Rozmiar akwarium od strony zbiornika do drugiej strony zbiornika nie powinien być mniejszy niż 60 znaków i nie większy niż 80 znaków. Boki zbiornika należy wskazać za pomocą |znaku rury / baru ( ).
• Ryby muszą być w stanie „pływać” od lewej do prawej między bokami akwarium. Ponieważ będą się obracać, widok z przodu jest wymagany do przejścia z jednego kierunku do drugiego.

• Ryba musi wyglądać następująco:

  • }}< }} ',') Ryba pływa w prawo
  • (',' {{ >{{ Ryba pływa w lewo
  • }}('_'){{ Ryba skierowana do przodu

• Kiedy ryba skręca, aby zmienić kierunek (30% szansy), musi zacząć od jednego kierunku, przodem do przodu, a następnie skierować się w drugim kierunku ... Upewnij się, że jest wystarczająco dużo miejsca na obrót ryby, tj. Wymaga sześciu spacji przed minimalna krawędź zbiornika ...

• O ile ryba nie wydmuchuje bańki lub nie zmieni kierunku, będzie kontynuować w kierunku, w którym jest skierowana, jeśli znajdzie się w odległości sześciu pól od boku akwarium, zmieni kierunek.
• Ryba (skierowana w lewo lub w prawo) może czasami (10% szansy) przestać wysadzać pęcherzyki kolejno ( .oO*), więc ryba musi mieć wolne miejsce obok nich, aby bąbel mógł istnieć, więc ryba może pływaj tak blisko boków, oszczędzaj jedno miejsce. Bańka musi zniknąć, zanim ryba będzie mogła przejść dalej ...

Seria przykładowych wierszy zachowania ryby, ze -znakami wskazującymi spacje, ponieważ funkcja wyświetlania kodu tutaj jest trochę ścisła ... Spodziewam się, że te myślniki zostaną zastąpione spacjami, gdy kodujesz to ...

Każda linia tutaj może być uważana za ramkę poklatkową.

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

itd. Powyższy przykład jest, jak powiedziałem, niewielki, ale masz ogólny pomysł ...

Najkrótszy kod wygrywa ...

Oczekuję, że dane wyjściowe w tej samej linii (jeśli to możliwe), jeśli nie, wyświetlanie klatka po klatce po kolei jest w porządku ... To, czy przejdziesz jedną linię, czy wiele linii, zależy od Ciebie. Jeśli wykonujesz wiele linii, muszą one być oddzielone nową linią.

Także zegar jest narzucany między ramkami, 2000ms. To jest obowiązkowe .

Zobaczmy, co masz!

Python 3 (278)

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

Gra w Pythona jest zawsze trudna ze względu na wymagania dotyczące wcięć instrukcji, ale mimo to poszło niesamowicie dobrze!

Ogromne podziękowania dla Volatility i DSM za to, że pomogłem mi w grze w golfa o wiele dalej.

Czysta wersja

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)

Rubin, 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]}

Ryba ma jedenaście znaków, co sprawia, że ​​akwarium ma szerokość 6 * 9 + 11 + 2 = 67 znaków, co idealnie pasuje do wymaganej tolerancji.

Funkcja flambda wykonuje wszystkie ciężkie podnoszenie: przyjmuje zmianę jako parę argumentów, a następnie próbuje zastosować podstawienie w akwarium. Jeśli się powiedzie, maluje jedną klatkę animacji. Następnie zgłasza wartość sukcesu jako 2(podjęte opóźnienie) lub nil(opóźnienie niewykonane).

Ryba nie wydmuchuje bąbelków dwa razy z rzędu. (Poprawka: ...while rand>0.1- 4 znaki)

Ryby mogą dmuchać bąbelki nawet przed wymuszonym nawrotem. (Poprawka: zmiana układu gałęzi)

Istnieje rama, w której bąbelek całkowicie zniknął (w tym *), ale ryba nie przesunęła się do powstałej pustki. To wynika z litery, ale nie z przykładu. (Stały zamienić f[?*,w]z q[?*]=w- wolna)

Nie czyści konsoli. Poprawka: dodaj `clear`(uniks) lub system 'cls'(konsolę Windows) przed, puts qaby naprawić ^{( Ref. )} Lub użyj printzamiast putsi wstaw \rdo akwarium ( sugerowane przez @manatwork ).

Wersja do odczytu:

# 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

R, 451 znaków

Pierwsza próba:

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

Zębaty:

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
}

Drukuje akwarium jako standardowe na jednej linii (następnie 2 s przerwy i powrót karetki przed wydrukowaniem akwarium w t + 1).

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}

lub bardziej wyraźnie

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

Ryba obraca się poprawnie. Dmuchanie baniek.

285 - jeśli podoba Ci się prawdziwe akwarium, a nie przewijana wersja:

$|=@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}

C, 400 394 373 znaków

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

Z białymi znakami:

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