Qui n'aime pas les films d'action avec des voitures rapides et bruyantes, en particulier celles avec beaucoup d'accidents? Qui n'aime pas les plans d'action dans l'art ascii?

La scène est:

Deux voitures partent sur les côtés opposés d'une route droite (avec 60 espaces entre les deux). Ils commencent à se rapprocher à vitesse constante. La voiture de gauche roule à 1 espace par seconde et celle de droite roule à 2 espaces par seconde.

Évidemment, les voitures ne peuvent pas se traverser, donc pour n ≥ 20la scène, il y aura deux voitures écrasées avec des capots à l'endroit où l'accident s'est produit.

En tant que cinéphile, je veux faire une pause de temps en temps, juste pour en apprécier la beauté.

Étant donné un entier n(argument de fonction ou STDIN), représentant le nombre de secondes depuis le début de la scène, affichez la scène à ce moment.

Voici la scène de départ, avec 60 espaces entre les roues avant:

  __                                                                __
_/  \_                                                            _/  \_
o    o                                                            o    o

voici la scène après 11 secondes:

             __                               __
           _/  \_                           _/  \_
           o    o                           o    o

et voici à quoi ça ressemble après le crash (notez que les bonnets sont en place après le crash):

                      __    __
                    _/  \/\/  \_
                    o    oo    o

Je suis seulement intéressé à regarder deux voitures s'écraser, donc les espaces, les nouvelles lignes, ++ n'ont pas d'importance.

Il s'agit du code golf, donc le code le plus court en octets l'emporte. Les réponses ajoutées plus tard peuvent toujours gagner si elles sont plus courtes que la réponse actuellement acceptée.

CJam, 68 66 octets

liKe<:M"  __  _/  \_o    o"6/f{\S*1$+60M3*-S*@N}:+MK={58'/t59'\t}&

Essayez-le en ligne

Quiconque voit le début du code en sera sûr liKe!

Explication:

li      Get input n and convert to integer.
Ke<     Cap n at 20.
:M      Save in variable M for multiple use later.
"  __  _/  \_o    o"
        Car (18 characters).
6/      Split into 3 lines of 6 characters.
f{      Map lines with parameter.
  \       Swap n to top.
  S*      Create string with n spaces for left margin.
  1$      Copy one car line to top. Keep original for second car
  +       Concatenate the spaces and car.
  60M3*-  Calculate 60-3*n, which is the amount of space between cars.
  S*      Create string with 60-3*n spaces.
  N       Add a newline.
}       End of line mapping.
:+      Concatenate all output pieces into single string.
MK=     Check if capped n is equal to 20.
{       If equal, replace hoods with crashed versions.
  58'/t   '/ at position 58.
  59'\t   '\ at position 59.
}&      End of conditional block for crashed hoods.

Labyrinthe , 394 386 octets

Je vous présente fièrement ...

<}74}}:23}29}59}}}}}}}:111_}}}}:::::::23_}:111
?                        @
:" }}_47}_95    3""""""""(
 _ :       }    _   }    {=}
 2 23_}29_ _    ;   :      \
 0       ; 3  +_( 3_"  60{ .{.{.
"-_95:}}"" 2  0 ) 2 "  _ _ {
""       _ :  2 _ ."(; } 3 .{
 ;_92}_47} :  _ 0    = : *  ;
           : "" 2 {.{{ . -""(
}}:59_}}:::: "";_ .    {  _ "
}             "   {.{.{.  32.
}}}_95:}}}}_20-

... mon nouveau Labyrinthe Esolang en deux dimensions! Le code ci-dessus n'est pas incroyablement bien joué (il y a 161 espaces et 25 NOP, donc une meilleure disposition pourrait raccourcir cela beaucoup), mais au moins j'ai réussi à montrer que le langage est utilisable pour des tâches non triviales. :)

Comment ça marche

Tout d'abord, un bref aperçu de la langue:

• Labyrinth fonctionne sur deux piles, principale et auxiliaire , qui peuvent contenir des entiers signés arbitraires. Au bas des deux piles, il y a une quantité infinie de zéros.
• Les commandes sont des caractères individuels sur une grille 2D et elles forment un labyrinthe (c'est-à-dire que les personnages inconnus, en particulier les espaces, sont des murs). "est un NOP qui n'est pas un mur et peut être utile pour remplir certains chemins dans le code. Contrairement à de nombreux autres langages 2D, les bords ne s'enroulent pas .
• Le pointeur d'instruction (IP) commence au premier caractère non mural (dans l'ordre de lecture) se déplaçant vers la droite. @termine le programme.
• Si possible, l'IP suit les couloirs (également autour des virages). Si l'IP a plusieurs cellules vers lesquelles se déplacer, elle tournera généralement à gauche si le haut de la pile principale est négative, se déplacera tout droit si elle est nulle ou tourner à droite si elle est positive. Lorsque l'IP frappe un mur, il change de direction. (Il existe quelques subtilités supplémentaires, mais elles ne devraient pas avoir d'importance pour ce code.) C'est le seul moyen d'implémenter le flux de contrôle.
• Outre les commandes arithmétiques et de manipulation de pile, le code source peut être modifié au moment de l'exécution avec les quatre commandes >v<^qui décaleront une ligne ou une colonne du code source de façon cyclique d'une cellule. La ligne ou la colonne affectée dépend du haut de la pile. Si la propre ligne ou colonne de l'IP est décalée, elle se déplacera avec le décalage. Cela permet de sauter d'un bord du code source à l'autre.

Maintenant, pour ce défi particulier, voici l'idée générale de l'algorithme:

• Poussez les extrémités des voitures jusqu'aux capots (c.-à-d. / \_o oo o) Sur la pile auxiliaire.
• Lisez l'entrée et déterminez s'il faut pousser __ou /\continuer.
• Poussez le reste des voitures (c'est __ __ _/ \-à- dire et deux espaces de tête) sur la pile auxiliaire.
• CLAMP l'entrée à une valeur maximale de 20, Appelons cette N .
• Effectuez maintenant les 3 opérations suivantes:
  • Imprimez N espaces.
  • Imprimez 6 caractères enregistrés.
  • Imprimez 60 à 3 * N espaces.
  • Imprimez 6 caractères enregistrés.
  • Imprimez une nouvelle ligne.

Enfin, regardons quelques parties du code. L'IP commence dans le coin supérieur gauche, sur une commande de décalage de grille. Le haut de la pile principale est 0(qui est utilisé comme index relatif), de sorte que la première ligne est décalée vers la gauche, ce qui déplace également l'IP à l'extrémité droite de la grille. Maintenant, la première ligne est simplement exécutée de droite à gauche, ce qui pousse le premier jeu de caractères fixes sur la pile auxiliaire:

}74}}:23}29}59}}}}}}}:111_}}}}:::::::23_}:111<

Ce décalage de ligne est utile pour le golf lorsque vous souhaitez commencer avec une grande quantité de code linéaire.

Ensuite, nous lisons l'entrée et poussons les bons bonnets:

?  
:" 
 _ 
 2 
 0       ;
"-_95:}}""
""       _
 ;_92}_47}

Le bit à gauche avec les trois NOP envoie des résultats négatifs le long de la branche supérieure et des résultats non négatifs le long de la branche inférieure. À droite, ils sont réunis.

Suit maintenant une autre grande section linéaire (qui pourrait probablement être beaucoup jouée avec une autre astuce de changement de ligne):

   }}_47}_95 
   :       } 
   23_}29_ _ 
           3 
           2 
           : 
           : 
           : 
}}:59_}}:::: 
}
}}}_95:}}}}

Cela pousse le reste des voitures sur la pile auxiliaire.

Ensuite, nous calculons min(20, input), qui est similaire à la première branche:

                ;
              +_(
              0 )
              2 _
              _ 0
             "" 2
             "";_
              "  
           _20-

Enfin, nous avons la boucle qui s'exécute trois fois pour imprimer les lignes. Chaque itération de la boucle contient deux petites boucles (3x3) pour imprimer les espaces, ainsi que deux sections pour imprimer 6 caractères de la pile auxiliaire:

                         @
                3""""""""(
                _   }    {=}
                    :      \
                  3_"  60{ .{.{.
                  2 "  _ _ {
                  ."(; } 3 .{
                     = : *  ;
                  {.{{ . -""(
                  .    {  _ "
                  {.{.{.  32.

Une astuce astucieuse sur laquelle je voudrais attirer l'attention est .{.{.le côté droit. C'est une impasse, donc à part .à la fin, le code est exécuté deux fois, une fois en avant et une en arrière. Cela donne un moyen pratique de raccourcir le code palindromique (le problème est que vous devez vous assurer que l'IP prend le bon virage lorsque vous sortez à nouveau de l'impasse).

Python 2.7, 167 164 159 octets

n=input();s,x=60-3*n,min(n,20)
for e in['  _',"_/ ","o  "]:p=e+(e[::-1],(' \_',' \/')[s<1])['/'in e];print" "*x+p+" "*s+(p[-1]+p[1:-1]+p[0]).replace("//","\/")

Cela prend l'entrée de stdin.
Démo ici
Tester ceci -

$ ./cars.py
0
  __                                                                __  
_/  \_                                                            _/  \_
o    o                                                            o    o

$ ./cars.py
11
             __                               __  
           _/  \_                           _/  \_
           o    o                           o    o

$ ./cars.py
20
                      __    __  
                    _/  \/\/  \_
                    o    oo    o

R, 191 octets

A peu près aussi bien que je peux l'obtenir maintenant. Prend les secondes de STDIN et des chats à STDOUT.

n=scan();p=paste0;formals(p)$collapse='';cat(sprintf(c('%s  __  %s  __  ','%s_/  \\_%s_/  \\_','%s_/  \\/%s\\/  \\_','%so    o%so    o')[-3+(n<21)],p(rep(' ',n)),p(rep(' ',60-n*3))),sep='\n')

Explication

# Get the input from STDIN.  Requires a single number 0-20
n=scan();
# alias paste0 and set collapse default to ''
p=paste0;
formals(p)$collapse='';
# output
cat(
    # sprintf to format the strings
    sprintf(
        # vector of strings to format                                                      picks which bonnet to remove
        c('%s  __  %s  __  ','%s_/  \\_%s_/  \\_','%s_/  \\/%s\\/  \\_','%so    o%so    o')[-3+(n<21)]
        # move left car by 1
        ,p(rep(' ',n))
        # move right car by 2
        ,p(rep(' ',60-n*3))
    )
,sep='\n')

Les tests

> n=scan();p=paste0;formals(p)$collapse='';cat(sprintf(c('%s  __  %s  __  ','%s_/  \\_%s_/  \\_','%s_/  \\/%s\\/  \\_','%so    o%so    o')[-3+(n==20)],p(rep(' ',n)),p(rep(' ',60-n*3))),sep='\n')
1: 0
2: 
Read 1 item
  __                                                                __  
_/  \_                                                            _/  \_
o    o                                                            o    o
> n=scan();p=paste0;formals(p)$collapse='';cat(sprintf(c('%s  __  %s  __  ','%s_/  \\_%s_/  \\_','%s_/  \\/%s\\/  \\_','%so    o%so    o')[-3+(n==20)],p(rep(' ',n)),p(rep(' ',60-n*3))),sep='\n')
1: 5
2: 
Read 1 item
       __                                                 __  
     _/  \_                                             _/  \_
     o    o                                             o    o
> n=scan();p=paste0;formals(p)$collapse='';cat(sprintf(c('%s  __  %s  __  ','%s_/  \\_%s_/  \\_','%s_/  \\/%s\\/  \\_','%so    o%so    o')[-3+(n==20)],p(rep(' ',n)),p(rep(' ',60-n*3))),sep='\n')
1: 20
2: 
Read 1 item
                      __    __  
                    _/  \/\/  \_
                    o    oo    o
> 

CJam, 120 octets

q~20e<_["   "]*\[" _o"]\[" / " "_  " "_  " " \ " ]\[19>" /o"" _o"?]60 3 5$,*-["   "]*[0$," _o"" \o"?]3$[" _o"]+++++++zN*

Démo

Non golfé:

q~        e# Read the input
20e<      e# min(20, input) (let's call it N)
_         e# Duplicate the value on the stack
["   "]   e# Push 3 blank spaces
*         e# Create N arrays of 3 blank spaces
\         e# Swap the top two stack elements
[" _o"]   e# Push the " _o" string to stack
\         e# Swap the top two stack elements
[" / " "_  " "_  " " \ " ]
\         e#
[         e# If N is greater than 20 then push the array [" /o"],
  19      e# otherwise [" _o"]
  >
  " /o"
  " _o"
  ?
]
60        e# 60 is the maximum space between the two cars
3         e# 3 is the number of blocks covered per move
5$,       e# Take the 6th element from the stack (an array of size N)
*-        e# Compute the remaining blocks (60 - 3 * N)
["   "]   e# Add an array of 3 blank spaces
*         e# Multiply it to fit the remaining blocks
[0$," _o"" \o"?] e# Add the (broken?) front part of the second car
3$        e# Copy the middle part of the car
[" _o"]   e# Append the right side of the car
+++++++   e# Concatenate all arrays
z         e# Transpose the array
N*        e# Join the array using new lines

Démo

PHP, 160 155 bytes

$f=str_repeat;echo$l=$f(' ',$s=min(max($argv[1],0),20)),"  __  ",
$m=$f(' ',$r=60-3*$s),"  __\n{$l}_/  \\",$r?_.$m._:'/\\',
"/  \\_\n{$l}o    o{$m}o    o\n";

Le code est affiché ici sur 3 lignes pour s'adapter à la disposition de la boîte de code. Ces nouvelles lignes ne sont pas nécessaires.

Le code non golfé:

// The number of seconds, between (and including) 0 and 20
$sec  = min(max($argv[1], 0), 20);
$rest = 60 - 3 * $sec;

$left = str_repeat(' ', $sec);      // left padding
$mid  = str_repeat(' ', $rest);     // space in the middle
$c = $rest ? '_'.$mid.'_' : '/\\';

echo($left.'  __  '.$mid."  __\n");
echo($left.'_/  \\'. $c ."/  \\_\n");
echo($left.'o    o'.$mid."o    o\n");

Il obtient le nombre de secondes de la ligne de commande (premier argument):

$ php -d error_reporting=0 action.php 11
             __                               __
           _/  \_                           _/  \_
           o    o                           o    o

L'option PHP CLI -d error_reporting=0est nécessaire pour masquer certaines notifications que PHP affiche à propos des constantes non définies ( str_repeat, _) qu'il convertit en chaînes (2 octets enregistrés pour chaque notification).

Un octet supplémentaire peut être enregistré sur PHP 7 en pressant l'initialisation de $fdans sa première utilisation ( $m=($f=str_repeat)(...)); il ne compile pas sur PHP 5.

Le cas de test et certaines des techniques utilisées pour réduire le code peuvent être trouvés sur github .

Mise à jour:

@ ismail-miguel a pressé l'initialisation de $leftet a intégré $cles arguments de echosauvegarde de 4 octets (voir le commentaire ci-dessous).

En échangeant l'ordre des variables $met sles initialisant, je me suis débarrassé d'une paire de parenthèses et j'ai économisé 1 octet de plus.

JavaScript (ES6), 121 octets

En utilisant la chaîne de modèle, les 2 sauts de ligne à l'intérieur de la chaîne sont significatifs et comptés.

Pour enregistrer les octets, affichez avec alert, même si la police proportionnelle utilisée dans alertn'est pas bien adaptée à l'art ASCII et que le résultat est moche pour n> = 20 (crash).

Test de l'exécution de l'extrait dans FireFox

F=n=>alert(`  __  
_/  \\_
o    o`.replace(/.+/g,v=>(Z=x=>' '.repeat(x)+v)(n<20?n:n=20)+Z(60-3*n)).replace('__/','/\\/'))

<input id=I value=10><button onclick='F(I.value)'>go</button>

Python 2, 148 octets

Cela utilise des codes d'échappement ANSI pour positionner le curseur au bon endroit pour dessiner les voitures. Il vérifie ensuite si l'entrée était à 20, si elle l'était, elle remonte et puise dans les capots de la voiture.

Prend un int de stdin, sortie vers stdout.

p=lambda x:"u  __u_/  \_uo    o".replace("u","\n\033[%dC")%(x,x,x)+"\033[4A";i=min(20,input());print p(i)+"\n"+p(66-i*2)+"\n\n\n\033[25C/\\"*(i==20)

Non golfé:

def get_car(x):
    return "\n  __\n_/  \_\no    o".replace("\n","\n\033[%dC")%(x,x,x)+"\033[4A"

i=min(20,input())
print get_car(i)
print get_car(66-i*2)
if i==20:
    print"\n\n\033[25C/\\"

Pyth, 67 octets

Kjbm+++*\ JhS,Q20d*\ -60*3Jdc3"  __  _/  \_o    o"?nJ20KXXK58\/59\\

Essayez-le ici .

                                                                       Implicit: Q=eval(input())
          JhS,Q20                                                      Set J=min(Q,20)
                              "  __  _/  \_o    o"                     Concatenated car string
                            c3                                         Split into 3
   m                                                                   For d in the above
       *\ J                                                            J spaces before 1st car
                  *\ -60*3                                             60-3J spaces in between them
    +++          d         d                                           Concatenate spaces and car string
Kjb                                                                    Join on newlines, store in K
                                                  ?nJ20                If J != 20...
                                                       K               ... print K
                                                         XK58\/        ... else put / in position 58
                                                        X      59\\        and \ in position 59 (implicit print)

C, 180 191 168 octets

#define S(x,y)"  __  ",#x"/  \\"#y,"o    o",
char*s[][3]={S(_,_)S(_,/)S(\\,_)};i;l;f(n){l=n>19&&(n=20);for(i=0;i<3;i++)printf("%*s%*s\n",n+6,s[l][i],60-3*n,s[l*2][i]);}

non golfé:

// make a map of possible car parts
#define S(x, y) { "  __  ", #x "/  \\" #y, "o    o" }
char * s[4][3]= {
    S(_,_),
    S(_,/),
    S(\\,_)
};
i,l;
f(n){
    i = 0;
    l = n>19 && (n = 20); // l = 1, if crash happend
    for(; i < 3; i++) {
        // '*' means length (padding) is given as an int argument
        printf("%*s%*s\n", n + 6, s[l][i], 60 - 3 * n, s[l*2][i]);
    }
}

programme de test:

main() {
    f( 0);f( 5);f(10);
    f(15);f(20);f(21);
    return 0;
}

sortie:

  __                                                          __
_/  \_                                                      _/  \_
o    o                                                      o    o
       __                                           __
     _/  \_                                       _/  \_
     o    o                                       o    o
            __                            __
          _/  \_                        _/  \_
          o    o                        o    o
                 __             __
               _/  \_         _/  \_
               o    o         o    o
                      __    __
                    _/  \/\/  \_
                    o    oo    o
                      __    __
                    _/  \/\/  \_
                    o    oo    o

J'ai pu jouer au golf assez fort. Je pense que j'ai commencé avec près de 300 octets.

Mais je ne sais pas si cela répond toujours à toutes les exigences. Comme vous pouvez le voir après 21 secondes, la première voiture pousse la deuxième voiture vers la droite. J'aurais besoin d'ajouter quelques octets si cela n'est pas autorisé.

Edit: corrigé. Cela devrait être plus réaliste que Sharknado ;-)

Edit: je pourrais raccourcir considérablement ma solution en jetant un deuxième coup d'œil à la printfpage de manuel. Si vous utilisez '*', vous pouvez fournir la longueur du champ directement à printf, sans avoir besoin de créer une chaîne de formatage au sprintfpréalable.

> <> , 538 276 octets

 :3*a6*$-:0)?v~~a2*0c4*1-e2*1+6pa9*2+b7p04.
  v          >04.
 >>1[>:0)  ?v~].
  ^  ^-1o" "<
\$:&94&12." ":oo"_":oo" ":oo
\$:&95&12." ":oo"_":oo" ":ooao
\$:&96&12."_"o"/"o" ":oo"\"o"_"o
\$:&97&12."_"o"/"o" ":oo"\"o"_"oao
\$:&98&12."o"o" ":::oooo"o"o
\$:&99&12."o"o" ":::oooo"o"o;

J'ai beaucoup baissé la taille, je suis étonné d'avoir réussi à réduire la taille de moitié. L'ancien est en dessous. Celui-ci n'est pas aussi efficace en termes de performances en raison de la largeur de la grille, principalement depuis la toute première ligne.

Vous pouvez le tester ici . Mettez le temps passé dans la "pile initiale", pas "entrée"!

Voici l'ancienne version.

:3*a6*$-:0)  ?v~~a2*0c4*1-c3*1-4p^                        
v~v?)0:  <[1:$/$:1[ >:0)  ?v~]" ":oo"_":oo" ":ooaov       
] >" "o1-^    ^    <^-1o" "/"/"o"_"<]~v?)0:  <[1:$<       
>" ":oo"_":oo" ":oo^       \o" ":oo"\"\" "o1-^            
/o"\"oo:" "o"/"o"_"]~v?)0:  <[1:$o"_"o/                   
\"_"oaov   hi there  >" "o1-^                             
       >$:1[ >:0)  ?v~]"o"o" ":::oooo"o"o>$:1[ >:0)  ?v~]v
       ^    <^-1o" "<                    ^    <^-1o" "<   
              v      p4-1*29+2*9a<    ;o"o"oooo:::" "o"o"<

Java, 258 caractères

class M{public static void main(String[]a){String l="",m=l,r="  __  ",w="o    o",x="_/  \\_";int p=Integer.parseInt(a[0]),i=20;p=p>i?i:p;for(i=-1;++i<p;)l+=" ";for(;++i<21;)m+="   ";System.out.print(l+r+m+r+"\n"+l+(x+m+x).replace("__","/\\")+"\n"+l+w+m+w);}}

Non-golfé

  class M {
     public static void main(String[] a) {
        String l = "", m = l, r = "  __  ", w = "o    o", x = "_/  \\_";
        int p = Integer.parseInt(a[0]), i = 20;
        p = p > i ? i : p;
        for (i = -1; ++i < p;)
           l += " ";
        for (; ++i < 21;)
           m += "   ";
        System.out.print(l + r + m + r + "\n"
              + l + (x + m + x).replace("__", "/\\") + "\n"
              + l + w + m + w);
     }
  }

Résultats

0
  __                                                                __  
_/  \_                                                            _/  \_
o    o                                                            o    o

1
   __                                                             __  
 _/  \_                                                         _/  \_
 o    o                                                         o    o

...

19
                     __       __  
                   _/  \_   _/  \_
                   o    o   o    o

20
                      __    __  
                    _/  \/\/  \_
                    o    oo    o

21
                      __    __  
                    _/  \/\/  \_
                    o    oo    o      

Python 2, 102 octets

n=input()
for r in"  __  ","_/  \_","o    o":print((n*' ')[:20]+r+(60-3*n)*' '+r).replace('__/','/\/')

Assez simple. Pour chaque rangée de la voiture, nous imprimons à nouveau les nespaces, cette rangée, les 60-3*nespaces et la rangée. Pour arrêter les voitures, plutôt que de le faire min(n,20), c'était un caractère plus court pour limiter la première série d'espaces avec [:20], et le second est très bien car un temps négatif une chaîne est la chaîne vide.

Pour remonter les ailes, nous faisons juste un replace. Puisqu'apparaît __également sur le toit, nous avons besoin d'un peu de contexte pour identifier les ailes, donc nous vérifions les éléments /suivants.

Java, 270 267 octets

Je suis presque sûr qu'il y a une façon meilleure / plus courte de le faire, mais mon cerveau n'est pas correctement engagé.

class C{public static void main(String[]a){String l="",m="",r="  __  ",w="o    o";int p=Math.min(Integer.parseInt(a[0]),20),i;for(i=0;++i<p;)l+=" ";for(i=0;++i<60-3*p;)m+=" ";System.out.print(l+r+m+r+"\n"+l+"_/  \\"+(p==20?"/"+m+"\\":"_"+m+"_")+"/  \\_\n"+l+w+m+w);}}

Pour n = 19:

                    __      __  
                  _/  \_  _/  \_
                  o    o  o    o

Pour n = 20:

                     __    __  
                   _/  \/\/  \_
                   o    oo    o

Non golfé

public class Crash {
public static void main(String[] args) {
    String left="", mid="", r="  __  ", w="o    o";
    int pos = Math.min(Integer.parseInt(args[0]),20),i;
    for (i=0; ++i<pos;){
        left+=" ";
    }
    for (i=0; ++i<60-3*pos;){
        mid+=" ";
    }
    System.out.print(
            left + r + mid + r + "\n" +
            left + "_/  \\" + (pos==20 ? "/" + mid + "\\" : "_" + mid + "_") + "/  \\_\n" +
            left + w + mid + w);
}
}

PHP 7, 140 octets

<?$s=$argv[1];$r=($f=str_repeat)(~ß,60-3*$s);echo$l=$f(~ß,min(20,$s)),"  __  $r  __  
${l}_/  \\",$r?_.$r._:~У,"/  \_
$l",$o=~ßßßß,$r,$o;

Usage:

Enregistrez sous ANSI dans file.php(il doit y avoir des caractères de largeur nulle $o) et exécutez:

php -derror_reporting=~E_NOTICE -dshort_open_tag=1 file.php x

avec xcomme nombre de secondes.

Et une version qui fonctionne sans changer le rapport d'erreur ( 148 octets ):

<?$s=$argv[1];$r=($f=@str_repeat)(' ',60-3*$s);echo$l=$f(' ',min(20,$s)),"  __  $r  __  
${l}_/  \\",$r?"_${r}_":"/\\","/  \_
$l",$o="o    o",$r,$o;

Javascript, 193 octets

Ce n'est pas un gagnant, mais c'est quelque chose

http://jsfiddle.net/yb703y0p/2/

function f(n){
c = ["  __  A", "_/  \\_A", "o    oA"]
for(i=0;i<3;i++)c[i]=c[i].replace('A',' '.repeat(n))+c[i].replace('A','')
if(n==0)c[1]=c[1].replace('__','/\\')
console.log(c.join("\n"))
}