Jestem zmęczona, ale nie mogę zasnąć. Pomóż mi policzyć owce.

Biorąc pod uwagę wejściową N (dodatnią liczbę całkowitą), spraw, aby N owiec przeskoczyło przez ogrodzenie ascii, jak na poniższej próbce. Tylko jedna klatka powinna być wyświetlana jednocześnie:

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

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

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

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

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

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

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

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

Licznik należy przechowywać w prawym dolnym rogu „podłoża”. Dozwolone są końcowe i wiodące białe znaki i znaki nowej linii. Jeśli Twój wybrany język ma trudności z czyszczeniem ekranu dla każdej klatki, możesz dodać wystarczającą liczbę nowych wierszy, aby wyczyścić ekran - w odpowiedzi podaj, ile linii dodajesz w tym celu. Program powinien zakończyć się, gdy niąta owca znajduje się na piątej płodności.

Muszę wstać jutro wcześnie, więc wygrywa najkrótszy kod w bajtach. Prześlij funkcję lub pełny program. Obowiązują standardowe luki.

MATL , 60 56 53 bajtów

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

Animacja z powyższym kodem działa bardzo szybko. Następująca wersja zawiera pauzę, aby spowolnić animację, a tym samym łatwiej ją zobaczyć (niewymagane przez wyzwanie), kosztem 4 dodatkowych bajtów:

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

Wypróbuj w MATL Online! Tłumacz jest wersją beta; odśwież stronę, jeśli nie działa.

Lub zobacz nagranie z kompilatora offline:

Wyjaśnienie

:"              % 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 bajtów

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

Ostatnia obliczona klatka jest wyświetlana jako pierwsza. Dzięki temu numer skoku wynosi n-1
In alert, charaktery mają różną szerokość, więc wygląda na zepsute.

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

Poprzednia odpowiedź:

120 bajtów, numer skoku jest niepoprawny, ponieważ zaczyna się od 1 zamiast 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 bajty

Czyści dane wyjściowe i czeka 300 ms między każdą ramką:

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)

Możesz to przetestować tutaj (pamiętaj, aby otworzyć konsolę).

Rubinowy, 83 bajty

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

Drukuje na standardowe wyjście. Wyjście oddzielone znakami nowej linii. Zmniejszenie wysokości ekranu do 3 powoduje, że jednocześnie widoczny jest tylko jeden obraz.

C #, 234 bajtów

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 bajtów

<?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>":"";

Zapisz do pliku s.php, zadzwoń w przeglądarce za pomocą s.php?n=<n>.

Wywołuje się z nowymi parametrami dla każdej ramki, bez opóźnienia.

Mógłbym zaoszczędzić 5 więcej index.php; ale nie chcę iść tak daleko.

Tcl, 168 bajtów

Wersja z ekranem o wysokości 10 wierszy. (Zamień 7poniżej na wysokość ekranu w kolumnach minus cztery).

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

Działa to bardzo szybko, więc możesz dodać pauzę w drugim wierszu:

Tcl, 177 bajtów

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

Działa poprzez ponowne użycie łańcucha u góry do dwóch różnych rzeczy:

• jako lista dla wewnętrznej pętli (do wyświetlenia każdej wersji owiec + ogrodzenie)
• jako odwzorowanie cyfry → spacja do usunięcia cyfr z szablonu obrazu owcy + ogrodzenia

Sam szablon jest obrazem ciągu do wyświetlenia. Najpierw mapujemy (zamieniamy ciąg) cyfrę aktualnej pozycji owcy (pętla wewnętrzna) na „o”. Następnie odwzorowujemy pozostałe cyfry na spacje. Następnie wypisujemy powstały ciąg.

(Sam łańcuch zaczyna się po ostatnim {w trzecim wierszu i kończy od skrajnego lewego} w ostatnim wierszu.)

QBasic, 110 bajtów

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

Pętle nad 5*nkleszczami. Przy każdym kleszczu czyści ekran, drukuje licznik i liczbę owiec, a następnie używa LOCATEdo wydrukowania ow odpowiednim miejscu. Przy xczym kod pozycji między 0 i 4:

• Rząd: (x=2)+2
  • Jeśli x=2to prawda, -1+2=1
  • Jeśli x=2jest fałszem, 0+2=2
• Kolumna: 1+x-(x>1)+x\3
  • Jeśli xjest 0lub 1, x>1jest fałszywe i x\3jest 0: 1+x-0+0= 1lub2
  • Jeśli xjest 2, x>1jest prawdziwe i x\3wynosi 0: 1+x-(-1)+0=4
  • Jeśli xjest 3lub 4, x>1jest prawdą i x\3jest 1: 1+x-(-1)+1= 6lub7

Na koniec SLEEPprzez 1 sekundę i pętlę. Jeśli nie masz nic przeciwko wciśnięciu Enter przy każdej klatce, mogę ogolić dwa bajty, usuwając argument do SLEEP.

PHP, 132 131 bajtów

Edycja po komentarzach (dzięki!):

<?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;

Który nie jest golfem:

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

Oryginalny post

<?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);}

Testowane na ubuntu (nie wiem, czy system("clear")działa na systemie Windows)

Nie golfowany:

<?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 bajtów

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

Oryginalne rozwiązanie

node.js, 146 142 185 bajtów

Testowane tylko z terminalem ubuntu (a teraz z n owcami):

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)

To jest ramka co 9 ms. Bardziej kojąca wersja (ramka co 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)

I bez golfa:

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 bajtów

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

Wykorzystuje kodowanie CP-1252 .

Wyjaśnienie

Iteracja odnosi się do wewnętrznej iteracji (0 -> 4) podróży owiec.

Główne pętle

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

Wygeneruj górny wiersz

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

Wygeneruj środkowy rząd

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

Wygeneruj dolny wiersz

…──|  # 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

Galaretka , 55 54 53 bajtów

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

TryItOnline

Drukuje ramki oddzielone liniami.

W jaki sposób?

ị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 bajtów, 163 151 136 znaków

Rozwiązanie za pomocą funkcji rekurencyjnej. Zadzwoń jako f (int)

EDYTOWAĆ

-12 po ponownym przeczytaniu komentarzy i stwierdzeniu, że liczba nie musi się zwiększać, gdy owce dotrą do końca pola

-15 poprzez bezpośrednie iterowanie listy indeksów i utratę zmiennej

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)

Notatki

Zakłada kodowanie UTF-8

Użycie - zamiast ─ (jak w odpowiedzi @Luis MATL) obniżyłoby bajt o 8, aby dopasować liczbę znaków i utraciłoby zależność UTF-8

Dodano 50 nowych linii - dane wyjściowe znajdują się na dole konsoli (tańsze niż importowanie i używanie systemu os.system („wyczyść”) i działa w systemach Windows i Linux)

Wersja z 1 sekundowym opóźnieniem między wyjściami (170 bajtów, 162 znaków)

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 + standardowe narzędzia Linux (339 bajtów)

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