Mes beaux-parents ont un étang à poissons dans leur cour, rempli de koi. Cela ne m'a pas vraiment traversé l'esprit jusqu'à ce que je remarque l'extrait suivant de mon code.

',') & '_'

... J'avais des visages de poisson me regardant depuis mon écran ...

Ce qui m'a donné une bonne idée ...

Ma quête pour vous, mes chers golfeurs, est de créer un aquarium ASCII en ligne, avec les règles suivantes:

• La taille de l'aquarium d'un côté du réservoir à l'autre côté du réservoir ne doit pas être inférieure à 60 caractères et pas plus de 80 caractères. Les côtés du réservoir doivent être indiqués en utilisant le caractère pipe / bar ( |).
• Les poissons doivent pouvoir «nager» de gauche à droite entre les côtés du réservoir. Comme ils vont tourner, une vue de face est nécessaire pour la transition d'une direction à l'autre.

• Le poisson doit ressembler à ceci:

  • }}< }} ',') Poissons nageant à droite
  • (',' {{ >{{ Poissons nageant à gauche
  • }}('_'){{ Poissons face à l'avant

• Lorsqu'un poisson se tourne pour changer de direction (30% de chances), il doit partir d'une direction, faire face à l'avant, puis faire face à l'autre direction ... Assurez-vous qu'il y a suffisamment d'espace pour que le poisson puisse tourner, c'est-à-dire qu'il nécessite six espaces avant la bord du réservoir minimum ...

• À moins qu'un poisson ne souffle une bulle ou ne change de direction, il continuera dans la direction à laquelle il fait face, s'il se trouve à moins de six cases du côté du réservoir, il changera de direction.
• Le poisson (face à gauche ou à droite) peut parfois (10% de chances) s'arrêter pour faire des bulles successivement ( .oO*), de sorte que le poisson doit avoir un espace disponible à côté d'eux pour que la bulle existe, donc un poisson peut nagez seulement aussi près des côtés, économisez un espace. La bulle doit disparaître avant que le poisson ne puisse avancer ...

Une série d'exemples de lignes du comportement du poisson, avec des -caractères indiquant les espaces, car la fonction d'affichage du code ici est un peu stricte ... Je m'attendrai à ce que ces tirets soient remplacés par des espaces lorsque vous coderez ceci ...

Chaque ligne ici pourrait être considérée comme une trame en time-lapse.

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

etc. L'exemple ci-dessus est, comme je l'ai dit, petit, mais vous avez l'idée générale ...

Le code le plus court gagne ...

Je m'attends à ce que la sortie sur la même ligne (si possible), sinon, afficher image par image successivement est très bien ... Que vous alliez une ligne ou plusieurs lignes, c'est à vous. Si vous effectuez plusieurs lignes, elles doivent être séparées par une nouvelle ligne.

Un temporisateur est également imposé entre les images, 2000 ms. C'est obligatoire .

Voyons voir ce que tu as!

Python 3 (278)

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

Jouer au golf en Python est toujours difficile en raison des exigences d'indentation des déclarations, mais malgré cela, cela s'est incroyablement bien passé!

Un grand merci à Volatility et DSM pour m'avoir aidé à jouer au golf encore plus loin.

Version propre

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)

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

Le poisson fait onze caractères de long, ce qui fait que l'aquarium 6 * 9 + 11 + 2 = 67 caractères de large, ce qui correspond parfaitement à la tolérance requise.

La ffonction lambda fait le gros du travail: elle accepte une substitution comme paire d'arguments, puis tente d'appliquer la substitution sur l'aquarium. S'il réussit, il peint une image de l'animation. Il signale ensuite la valeur de réussite comme 2(le délai pris) ou nil(délai non exécuté).

Les poissons ne souffleront pas de bulles deux fois de suite. (Correction: ...while rand>0.1- 4 caractères)

Les poissons peuvent faire des bulles avant même un virage forcé. (Correction: réorganiser la structure de ramification)

Il y a un cadre où la bulle a complètement disparu (y compris le *) mais le poisson ne s'est pas déplacé dans le vide résultant. Cela suit la lettre, mais pas l'exemple. (Correctif: remplacer f[?*,w]par q[?*]=w- gratuit)

N'efface pas la console. Correction: ajoutez `clear`(Unix) ou system 'cls'(console Windows) avant puts qde corriger ^{( Réf. )} Ou utilisez à la printplace de putset ajoutez \rà l'aquarium ( suggéré par @manatwork ).

Version lisible:

# 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 caractères

Une première tentative:

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

Dentelé:

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
}

Il imprime l'aquarium en stdout sur une seule ligne (puis pause de 2 s et retour en chariot avant l'impression de l'aquarium à 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}

ou plus clairement

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

Le poisson tourne correctement. Des bulles soufflent.

285 - si vous aimez la véritable sensation d'aquarium et non la version à défilement:

$|=@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 caractères

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

Avec espace:

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