Estoy cansado, pero parece que no puedo conciliar el sueño. Ayúdame a contar ovejas.

Dada una entrada N (entero positivo), haga que N ovejas salten sobre una cerca ascii, como en el ejemplo a continuación. Solo se debe mostrar un cuadro a la vez:

o |-|
──|-|──  0

 o|-|
──|-|──  0

   o
  |-|
──|-|──  0

  |-|o
──|-|──  0

  |-| o
──|-|──  0

o |-|
──|-|──  1

 o|-|
──|-|──  1

   o
  |-|
──|-|──  1

El recuento debe mantenerse en el lado inferior derecho del 'suelo'. Se permiten espacios en blanco al inicio y al final y nuevas líneas. Si su idioma de elección tiene dificultades para borrar la pantalla para cada cuadro, puede agregar suficientes líneas nuevas para borrar la pantalla; indique cuántas líneas agrega para esto en su respuesta. El programa debe finalizar cuando la enésima oveja está en el quinto floortil.

Necesito levantarme temprano mañana, por lo que gana el código más corto en bytes. Por favor envíe una función o un programa completo. Se aplican lagunas estándar.

MATL , 60 56 53 bytes

:"@qXJx[HKCbO]"7Z"'  |-|  'v'o'@('--|-|--  '  JVhXxXD

La animación con el código anterior se ejecuta muy rápido. La siguiente versión incluye una pausa para hacer que la animación sea más lenta y, por lo tanto, más fácil de ver (no requerida por el desafío), a costa de 4 bytes más:

:"@qXJx[HKCbO]"7Z"'  |-|  'v'o'@('--|-|--  '  JVhXxXD.2Y.

¡Pruébalo en MATL Online! El intérprete es un beta; Actualiza la página si no funciona.

O vea una grabación del compilador fuera de línea:

Explicación

:"              % Input N implicitly. Repeat N times
  @q            %   Push iteration index minus 1, that is, from 0 to N-1. This
                %   are the numbers of sheep
  XJx           %   Copy into clipboard J and delete
  [HKCbO]       %   Push array [2 4 7 -2 0]
  "             %   For each value in that array. This loops generates the 5
                %   frames for each number of sheep
    7Z"         %     Push string of 7 spaces
    '  |-|  '   %     Push this string
    v           %     Concatenate vertically. This gives a 2x7 char array
                %     with the upper part of the frame, except the 'o',
                %     which will be now placed in a varying position 
    'o'         %     Push string 'o'
    @           %     Push loop variable, that is, 2, 4, 7, -2 or 0
    (           %     Write 'o' into that position of the 2x7 char array.
                %     The position is interpreated linearly, that is, a single
                %     number is used as index into the 2D array in column-major
                %     order (down, then across). So index 2 is lower-left corner,
                %     index 4 is to the right of that etc. Indexing is
                %     semi-modular (modular for non-positive values). So 0 is
                %     the lower-right corner, and -2 is to the left of that
    '--|-|--  ' %     Push this string
    JV          %     Push current number of sheep converted to string
    h           %     Concatenate horizontally
    Xx          %     Clear screen
    XD          %     Display all stack contents
    .2Y.        %     Pause for 0.2 seconds (optional)
                %   End implicitly
                % End implicitly

Javascript (ES6), 120 124 bytes

f=(n,m=`   2
43|-|10
──|-|── `,s=0)=>n?alert(m.replace(s%5,'o').replace(/\d/g,' ')+' '+(n-1),(++s%5?f(n,m,s):f(n-1,m,0))):''

El último cuadro calculado se muestra primero. Gracias a esto, el número de salto es n-1
In alert, los personajes tienen un ancho diferente, por lo que parece que está roto.

f=(n,m=`   2
43|-|10
──|-|── `,s=0)=>n?alert(m.replace(s%5,'o').replace(/\d/g,' ')+' '+(n-1),(++s%5?f(n,m,s):f(n-1,m,0))):''
;

f(2);//You'll get 10 alert popup

Respuesta anterior:

120 bytes, el número de salto es incorrecto porque comienza en 1 en lugar de 0

f=(n,m=`   2
43|-|10
──|-|── `,s=0)=>n?alert(m.replace(s%5,'o').replace(/\d/g,' ')+' '+n,(++s%5?f(n,m,s):f(n-1,m,0))):''

JavaScript (ES6), 144 142 bytes

Borra la salida y espera 300 ms entre cada cuadro:

n=>(F=j=>((c=console).clear(),c.log(`   2
01|-|34
──|-|── `.replace(/\d/g,i=>(j-i)%5?' ':'o')+(j/5|0)),++j<n*5&&setTimeout(`F(${j})`,300)))(0)

Puede probarlo aquí (asegúrese de abrir la consola).

Ruby, 83 bytes

->n{(n*5).times{|i|$><<"   c
  |-|  
ab|-|de  #{i/5}
".tr('abcde',' '*(i%5)+'o ')}}

Imprime en stdout. Salida separada por nuevas líneas. Al reducir la altura de la pantalla a 3, solo se puede ver una imagen a la vez.

C #, 234 bytes

using C=System.Console;class P{static void Main(string[]a){for(int n=0;n-1+""!=a[0];++n){foreach(int p in new[]{5,6,3,10,11}){C.Clear();C.Write("    \n  |-|  \n──|-|── ".Remove(p,1).Insert(p,"o")+n);for(var w=3e7;w>0;--w);}}}}

PHP + JavaScript, 168 bytes

<?extract($_GET);$s="     ";$s[$f=++$f%5]=o;echo strtr("<pre>   C
AB|─|DE
──|─|── $c",EABCD,$s),($c+=!$f)<$n?"<script>location.href='s.php?n=$n&c=$c&f=$f'</script>":"";

Guardar en archivo s.php, llamar al navegador con s.php?n=<n>.

Se llama a sí mismo con nuevos parámetros para cada cuadro, sin demora.

Podría ahorrar 5 más con index.php; pero no quiero ir tan lejos

Tcl, 168 bytes

Versión con pantalla de 10 filas de altura. (Reemplace el 7siguiente con la altura de su pantalla en columnas menos cuatro).

set s {0 1 2 3 4 }
for {set n 0} {$n<$argv} {incr n} {foreach x $s {
puts [string repe \n 6][string map [split $s {}] [string map "$x o" {   2
01|-|34
--|-|--  }]]$n}}

Eso funciona muy rápido, por lo que puede agregar una pausa en la línea dos:

Tcl, 177 bytes

set s {0 1 2 3 4 }
for {set n 0} {$n<$argv} {incr n} {foreach x $s {after 250
puts [string repe \n 6][string map [split $s {}] [string map "$x o" {   2
01|-|34
--|-|--  }]]$n}}

Funciona reutilizando la cadena en la parte superior para dos cosas diferentes:

• como una lista para el bucle interno (para mostrar cada versión de la oveja + valla)
• como un mapeo de dígito → espacio para eliminar dígitos de la plantilla de imagen oveja + valla

La plantilla en sí es la imagen de cadena para mostrar. Primero asignamos (reemplazo de cadena) el dígito de posición actual de la oveja (bucle interno) a una 'o'. Luego mapeamos los dígitos restantes a espacios. Luego imprimimos la cadena resultante.

(La cadena en sí comienza después del último {en la tercera línea y termina con el extremo izquierdo} en la última línea).

QBasic, 110 bytes

INPUT n
FOR i=0TO 5*n-1
CLS
?
?"  |-|"
?"--|-|-- ";i\5
x=i MOD 5
LOCATE(x=2)+2,1+x-(x>1)+x\3
?"o"
SLEEP 1
NEXT

Recorre las 5*ngarrapatas. En cada marca, borra la pantalla, imprime el estilo y el conteo de ovejas, y luego usa LOCATEpara imprimir oen el lugar apropiado. Conx ser el código de posición entre 0 y 4:

• Fila: (x=2)+2
  • Si x=2es verdad-1+2 =1
  • Si x=2 es falso, 0+2=2
• Columna: 1+x-(x>1)+x\3
  • Si xes 0o 1, x>1es falso y x\3es0 : 1+x-0+0=1 o2
  • Si xes 2, x>1es cierto yx\3 es 0:1+x-(-1)+0 =4
  • Si xes 3o 4, x>1es verdadero y x\3es 1: 1+x-(-1)+1=6 o7

Finalmente, SLEEPdurante 1 segundo y bucle. Si no le importa presionar enter en cada cuadro, puedo eliminar dos bytes eliminando el argumento SLEEP.

PHP 132 131 bytes

Ediciones después de los comentarios (¡gracias!):

<?php for(;$i<$argv[1]*5;sleep(1),system(clear),$c="    
  |-|  
──|-|──  ".floor($i/5),$c[[5,6,3,10,11][$i++%5]]=o)echo$c;

Lo cual no tiene golf:

<?php

ini_set('error_reporting', '0');        # golfing precondition

for(; $i<$argv[1]*5;                    # repeat N times
  sleep(1),                             # sleep after iteration
  system(clear),                        # clear screen (linux only)
  $c = "    
  |-|  
──|-|──  " . floor($i / 5),             # define template
  $c[[5, 6, 3, 10, 11][$i++ % 5]] = o)  # replace with sheep (and finish "for" statement)
  echo $c;                              # output result

Publicación original

<?php $i=0;for(;;){system("clear");$c="  \n  |-|  \n──|-|──  ";$c[[3,4,1,8,9][$i%5]]='o';echo"  $c".floor($i++/5);sleep(1);}

Probado en ubuntu (no sé, si system("clear") funciona en Windows)

Sin golf:

<?php
$i = 0;
for(;;) {
  system("clear");
  $content = "  \n  |-|  \n──|-|──  ";
  $content[[3,4,1,8,9][$i%5]] = 'o';
  echo "  $content " . floor($i++/5);
  sleep(1);
}

node.js + sleep , 169 bytes

c='   2\n01|-|34\n──|-|──  '
for(i=0;i<process.argv[2]*5;require('sleep').sleep(1))console.log('\033[2J'+c.replace(i%5,'o').replace(/\d/g,' ')+Math.floor(i++/5))

Solución original

node.js, 146 142 185 bytes

Probado solo con el terminal ubuntu (y ahora con n sheeps):

i=0
c='   2\n01|-|34\n──|-|──  '
setInterval(function(){console.log('\033[2J'+c.replace(i%5,'o').replace(/\d/g,' ')+Math.floor(i++/5))
if(process.argv[2]*5==i)process.exit()},9)

Bueno, eso es un marco cada 9 ms. Una versión más relajante para el sueño (marco cada 1s):

i=0;setInterval(function(){console.log('\033[2J'+'   2\n01|-|34\n──|-|──  '.replace(i%5,'o').replace(/\d/g,' ')+Math.floor(i++/5))},1000)

Y sin golfos:

var i = 0;
setInterval(function(){
  console.log('\033[2J' + '   2\n01|-|34\n──|-|──  '.replace(i%5, 'o').replace(/\d/g, ' ') + Math.floor(i++/5));
}, 1000)

05AB1E , 66 60 59 bytes

FNU5Fð4×N<i¨'oJ},N<iðë'o}ðNÉis}"|-|  "JN1›iR},…──|Â'-sððXJ,

Utiliza CP-1252 codificación .

Explanantion

La iteración se refiere a la iteración interna (0 -> 4) del viaje de ovejas.

Bucles principales

F      # For N in range [0 .. input)
 NU    # Save N in variable X
 5F    # For N in range [0 .. 5)

Generar fila superior

ð4×         # push 4 spaces
N<i    }    # if we're on the 2nd iteration
   ¨'oJ     # replace the last space with an "o"
,           # print row

Generar fila central

N<iðë'o}     # push a space if we're on the 2nd iteration, else push "o"
ð            # push a space
NÉis}        # if we're on an odd numbered iteration, swap the stacks top 2 chars
"|-|  "      # push this string
J            # join the stack to one string
N1›iR}       # if we're on the any of the last 3 iterations, reverse the string
,            # print row

Generar fila inferior

…──|  # push the string "──|"
     # push a reversed copy
'-s   # push "-" between the 2 strings on the stack
ðð    # push 2 spaces
X     # push the N we saved in the main loop (current sheep number)
J,    # join and print row

Jalea , 55 54 53 bytes

ị30214D¤“o    ”ṙ“   “
““|-|““
__|-|__  ”ż
×5Ḷµ:5ż@Ç€Y

TryItOnline

Imprime cuadros separados por avances de línea.

¿Cómo?

ị30214D¤“o    ”ṙ“   “
““|-|““
__|-|__  ”ż           - Link 1, build a frame without counts: frameNumber
       ¤              - nilad and link(s) as a nilad:
 30214                -     literal 30214 (a nilad)
      D               -     to decimal: [3,0,2,1,4]
ị                     - index into (1-based and modular, so frames go 4,3,0,2,1,4,...)
        “o    ”       - string "o    "
               ṙ      - rotated to the left by that number
                “   “ - the rest, except the last character, is:
““|-|““               -     an array of strings ["   ","\n","","|-|","","\n__|-|__  "]
__|-|__  ”            -     i.e. split where a sheep might go

          ż           - zip the sheep (the rotated "o    ") into that

×5Ḷµ:5ż@Ç€Y - Main link: nSheep
×5          - multiply by 5 -> nFrames
  Ḷ         - lowered range: [0,1,2,...nFrames-1]
   µ        - monadic chain separation
    :5      - integer division by 5 (vectorises): [5 zeros, 5 ones, ..., 5 (nSheep-1)s]
      ż@    - zip with reversed arguments
        ǀ  - call last link (1) as a monad for each (zip sheep numbers with frames)
          Y - join with line feeds (TODO: replace with future animate frames atom :p)

Python 2, 171 159 144 bytes, 163 151 136 caracteres

Solución utilizando una función recursiva. Llamar como f (int)

EDITAR

-12 después de releer los comentarios y ver que el conteo no tiene que incrementarse cuando la oveja llega al final del campo

-15 iterando a través de la lista de índice directamente y perdiendo una variable

def f(a,x=0):
 if a>0:
  for c in 5,6,3,10,11:
   b=list('    \n  |-|  \n──|-|──  ');b[c]='o';print"\n"*50+"".join(b)+(`x`)
  f(a-1,x+1)

Notas

Asume la codificación UTF-8

El uso de - en lugar de ─ (como en la respuesta @Luis MATL) reduciría la cuenta de bytes en 8 para que coincida con la cuenta de caracteres y perdería la dependencia de UTF-8

Se agregaron 50 nuevas líneas: la salida se encuentra en la parte inferior de la consola (más barata que importar y usar os.system ("clear") y funciona en Windows y Linux)

Versión con 1 segundo de retraso entre salidas (170 bytes, 162 caracteres)

import time
def f(a,x=0):
 if a>0:
  for c in 5,6,3,10,11:
   b=list('    \n  |-|  \n──|-|──  ');b[c]='o';print"\n"*50+"".join(b)+(`x`);time.sleep(1)
  f(a-1,x+1)

Bash + utilidades estándar de Linux (339 bytes)

e(){ echo "$@";}
n(){ e -n "$@";}
r(){ [ $? -eq 0 ]&&s=o||s=" ";[ $1 ]&&n " $s "||n "$s";}
f(){ k=$(($1%5));n "  ";[ $k -eq 2 ];r .;e "  ";for i in 0 1;do [ $k -eq $i ];r;done;n "|-|";for i in 3 4;do [ $k -eq $i ];r;done;e;n "──|-|──";}
for l in `seq 1 $1`;do for z in `seq 0 4`;do clear;f $z;e "  $((l-1))";sleep 1;done;done