Większość ludzi zna pułapkę polegającą na liczeniu owiec na sen. Jest stado owiec, niektóre skaczą przez płot, a ty liczysz owce, które skaczą. Podobno pomaga to uspokoić umysł i wprawia cię w stan snu, dzięki czemu zasypiasz.

Oto owca ASCII zwrócona w prawo, czekająca na policzenie:

'00^>
 ||

Oto owca ASCII skacząca przez płot:

'00^>
 /\
 ++

Oto jeden skierowany w lewo, który został już policzony:

<^00'
  ||

Wyzwanie

Biorąc pod uwagę dwie liczby całkowite wejściowe, na m, z n > 2opisując Ile łącznie owiec, a m > 0mówiąc ile owce zostały już policzone, wyjście ASCII Art reprezentacja liczenia owiec zasnąć.

Teraz zwrot akcji:

• Ze względu na wielkość kojców, w których znajdują się owce, górny rząd może pomieścić maksymalnie 10owce, nie licząc aktualnie skaczących owiec, które również muszą zawsze znajdować się w górnym rzędzie.
• Kolejne rzędy nie mogą mieć owiec poza ich kojcami (nie możesz mieć więcej owiec po lewej stronie w drugim rzędzie niż w pierwszym rzędzie, i to samo dla prawej).
• Jeśli jest 11więcej lub więcej owiec, w górnym rzędzie musi 10znajdować się plus skacząca owca.
• Początkowe / końcowe białe znaki i białe znaki między owcami nie mają znaczenia, o ile:
  1. Między owcami jest co najmniej jedna biała postać
  2. Wszystkie postacie są odpowiednio ustawione.

Dopóki te zasady są spełnione, rzeczywiste rozmieszczenie owiec zależy od twojego wdrożenia.

Przykłady

Na przykład tutaj jest n=3i m=1, w najprostszym przypadku.

         '00^>
'00^>     /\      <^00'
 ||       ++        ||

Oto n=11i m=6najbardziej owiec, które mogą zmieścić się na jednej linii poziomej.

                        '00^>
'00^> '00^> '00^> '00^>  /\   <^00' <^00' <^00' <^00' <^00' <^00'
 ||    ||    ||    ||    ++     ||    ||    ||    ||    ||    ||

Oto inny przykład tego, z n=11im=1

                                                      '00^>
'00^> '00^> '00^> '00^> '00^> '00^> '00^> '00^> '00^>  /\   <^00'
 ||    ||    ||    ||    ||    ||    ||    ||    ||    ++     || 

Większy przykład z n=30im=12

                                                '00^>
'00^> '00^> '00^> '00^> '00^> '00^> '00^> '00^>  /\   <^00' <^00'
 ||    ||    ||    ||    ||    ||    ||    ||    ++     ||    || 

'00^> '00^> '00^> '00^> '00^> '00^> '00^> '00^>       <^00' <^00'
 ||    ||    ||    ||    ||    ||    ||    ||           ||    || 

'00^>                                                 <^00' <^00'
 ||                                                     ||    || 

                                                      <^00' <^00'
                                                        ||    || 

                                                      <^00' <^00'
                                                        ||    || 

                                                      <^00' <^00'
                                                        ||    || 

Oto przykład z n=17im=2

                                                '00^>
'00^> '00^> '00^> '00^> '00^> '00^> '00^> '00^>  /\   <^00' <^00'
 ||    ||    ||    ||    ||    ||    ||    ||    ++     ||    ||

'00^> '00^> '00^> '00^> '00^> '00^>
 ||    ||    ||    ||    ||    ||  

Oto przykład z n=19im=3

                                          '00^>
'00^> '00^> '00^> '00^> '00^> '00^> '00^>  /\   <^00' <^00' <^00'
 ||    ||    ||    ||    ||    ||    ||    ++     ||    ||    || 

'00^> '00^> '00^> '00^> '00^> '00^> '00^>
 ||    ||    ||    ||    ||    ||    ||  

'00^>
 ||  

Zauważ, że wszystkie są przykładami . W ostatnim przypadku możesz zakończyć tworzenie pionowego zestawu owiec po prawej stronie, co pozwoli dopasować lewą stronę do dwóch rzędów. A może kwadrat owcy 2x2 po prawej stronie, który pasowałby również owce po lewej stronie w dwóch rzędach. Itp.

I / O i reguły

• Dane wejściowe można przyjmować w dowolnym rozsądnym formacie i dowolną dogodną metodą .
• Wiodące / końcowe znaki nowej linii lub inne białe znaki są opcjonalne, pod warunkiem, że znaki są odpowiednio ustawione.
• Dopuszczalny jest pełny program lub funkcja. Jeśli funkcja, możesz zwrócić dane wyjściowe zamiast je drukować.
• Dane wyjściowe mogą być wysyłane do konsoli, zwracane jako lista ciągów, zwracane jako pojedynczy ciąg itp.
• Standardowe luki są zabronione.
• To jest golf golfowy, więc obowiązują wszystkie zwykłe zasady gry w golfa, a wygrywa najkrótszy kod (w bajtach).

APL (Dyalog Unicode) , 118 bajtów ^SBCS

Anonimowy przyrostek lambda. Przyjmuje njako lewy argument i mprawy argument. Zwraca wynik zagnieżdżonej tablicy, ale domyślny sposób wyświetlania tej zagnieżdżonej tablicy jest zgodny ze specyfikacjami. Wykorzystuje do dziewięciu kolumn dla liczonych owiec i pozostałe kolumny dla oczekujących owiec.

{(r⍴(×/r←d,⍨⌈w÷d←10-⍵⌊⊢/r)↑w⍴(w←⍺-⍵+1)⍴⊂s@2⌽S)(↑(s←'>',⍨¯1↓b)' /\' ' ++')(r⍴(×/r←9,⍨⌈⍵÷9)↑⍵⍴⊂S←⌽↑''(b←'''00^<')' ||')}

Wypróbuj online!

{… } Anonimowa lambda; ⍺jest lewy argument, ⍵jest prawy argument

Ta funkcja składa się z trzech odrębnych części: oczekiwania , skakania i liczenia . Każdy z nich jest nawiasowany, co powoduje, że wynikiem jest lista trzyelementowa.

Policzone (r⍴(×/r←9,⍨∘⌈⍵÷9)↑⍵⍴⊂S←⌽↑''(b←'''00^<')' ||')

''(… )' ||' Trzy wiersze zwierciadlanej liczonej owcy, środkowa to:

 b←'''00^<' ciało i jest przypisany do b

↑ wymieszaj listę ciągów znaków w matrycy znaków (wypełnienie spacjami)

⌽ odzwierciedl to

S← przypisać do S(dużego S heepa)

⊂ załącz go, abyśmy mogli poradzić sobie z tym jako całość

⍵⍴ użyj liczby zliczonych owiec, aby cyklicznie przekształcać to

(… )↑ Weź z tego następującą liczbę elementów (wypełnienie prototypowymi przedmiotami, tj. Ta sama tablica, ale wszystkie znaki zastąpione spacjami)

 ⍵÷9 dziewiąta liczba policzonych owiec

 ⌈ podsumowanie

 9,⍨ dołącz 9 do tego

 r← przypisać r(co zrobimy r eshape z; rzędy i kolumny)

 ×/ produkt z tej listy (tyle elementów potrzebujemy, w tym wypełnień)

r⍴ przekształć to w tablicę o długościach wymiarów r

Skoki (↑(s←'>',⍨¯1↓b)' /\' ' ++')

(… )' /\' ' ++' Trzy linie skaczących owiec, pierwsza to:

 ¯1↓b upuść ostatni znak z b

 '>',⍨ dołącz prawą głowę

 s← Przechowywać w s(małe y Heep)

↑ wymieszaj listę ciągów znaków w matrycy znaków (wypełnienie spacjami)

Czekanie (r⍴(×/r←d,⍨⌈w÷d←10-⍵⌊⊢/r)↑w⍴(w←⍺-⍵+1)⍴⊂s@2⌽S)

⌽S lustro S

s@2 wstaw s w drugim wierszu (zastępując tam obecne dane)

⊂ załącz go, abyśmy mogli poradzić sobie z tym jako całość

(… )⍴ Cyklicznie przekształcaj to w następujący rozmiar:

 ⍵+1 liczba policzonych owiec plus jeden

 ⍺- odejmij to od sumy

 w← przypisać do w( w aiting)

(… )↑ Weź z tego następującą liczbę elementów (wypełnienie prototypowymi przedmiotami)

 ⊢/r najbardziej prawy element r(tj. liczba użytych kolumn dla zliczonych owiec)

 ⍵⌊ minimum całości i to

 10- odejmij to od dziesięciu

 d← przypisać do d( d ifference; brakujące kolumny)

 w÷ podziel wprzez to

 ⌈ zaokrąglanie w górę (daje liczbę potrzebnych wierszy)

 d,⍨ dodać d

 r← przypisać r(co zrobimy r eshape z; rzędy i kolumny)

 ×/ produkt z tej listy (tyle elementów potrzebujemy, w tym wypełnień)

r⍴ przekształć to w tablicę o długościach wymiarów r

JavaScript, 281 , 293 , 288 bajtów

a="      ";c=((n,m)=>{b="";for(i=0;i<(q=m>(o=(l=(t=n-m-1)?t:0)/9)?m:o);++i){for(j=0;j<3;++j){b+=[a,"'00^> "," ||   "][j].repeat(r=l>i*9?(z=o-i)>1?9:Math.ceil(z*9):0)+a.repeat((l>9?9:l)-r)+(i?"     ":["'00^>"," /\\  "," ++  "][j])+[a," <^00'","   || "][j].repeat(m>i?1:0)+"\n"}}return b});

Zachowaj ostrożność podczas używania poniższego fragmentu, ponieważ istnieje duże ryzyko nagłej indukowanej narkolepsji.

  <form id="form">
    <input type="text" name="n" placeholder="n (sheep total)">
    <input type="text" name="m" placeholder="m (sheep in right hand field)">
    <button type="submit">Let's Go!</button>    
  </form>

  <pre id="output">
  </pre>

  <script>
    a="      ";c=((n,m)=>{b="";for(i=0;i<(q=m>(o=(l=(t=n-m-1)?t:0)/9)?m:o);++i){for(j=0;j<3;++j){b+=[a,"'00^> "," ||   "][j].repeat(r=l>i*9?(z=o-i)>1?9:Math.ceil(z*9):0)+a.repeat((l>9?9:l)-r)+(i?"     ":["'00^>"," /\\  "," ++  "][j])+[a," <^00'","   || "][j].repeat(m>i?1:0)+"\n"}}return b});
      form.addEventListener("submit", function(e){
        e.preventDefault();
  
        var n = parseInt(form.n.value);
        var m = parseInt(form.m.value);
  
        if(n != NaN && m != NaN){
          if(m > n){
            output.innerText = "C'mon man, how can you have more sheep in the right hand field than there are sheep in general?";
          }
          else{
            output.innerText = c(n, m);
          }
        }
        else{
          output.innerText = "Numbers only please.";
        }
      });
    </script>

C, 392 bajtów

Dzięki @Jonathan Frech za uratowanie bajtu!

#define F;for(
x,y,k;p(L,a,b,t)char L[][78];{F k=5;k--;)L[x=a*4+(t<2)][y=b*6+k]=t?"'00^>"[k]:"<^00'"[k];L[++x][y-=~!t]=47;L[x][++y]=92;L[x][--y]=L[x+=(t>1)][y]=t<2?'|':43;}i,l;f(n,m){char L[i=n*4][78]F;i--;){F L[i][l=77]=0;l--;)L[i][l]=32;}F l=n+~m;++i<l&&i<9+!m;)p(L,0,i,1);l-=i;p(L,0,i++,2)F;i<11&&m--;)p(L,0,i++,0)F i=0;l--;)p(L,++i,0,1)F i=1;m-->0;)p(L,i++,10,0)F l=0;l<i*4;)puts(L+l++);}

Wypróbuj online!

Rozwinięty:

#define F;for(

x, y, k;
p(L, a, b, t) char L[][78];
{
    F k=5; k--;)
        L[x=a*4+(t<2)][y=b*6+k] = t ? "'00^>"[k] : "<^00'"[k];

    L[++x][y-=~!t] = 47;
    L[x][++y] = 92;
    L[x][--y] = L[x+=(t>1)][y] = t<2 ? '|' : 43;
}

i, l;
f(n, m)
{
    char L[i=n*4][78]
    F; i--;)
    {
        F L[i][l=77]=0; l--;)
            L[i][l] = 32;
    }

    F l=n+~m; ++i<l&&i<9+!m;)
        p(L,0,i,1);

    l-=i;
    p(L,0,i++,2)

    F; i<11&&m--;)
        p(L,0,i++,0)

    F i=0; l--;)
        p(L,++i,0,1)

    F i=1; m-->0;)
        p(L,i++,10,0)

    F l=0; l<i*4;)
        puts(L+l++);
}

Python 2 , 222 277 bajtów

n,m=input();n-=m+1
s=" '00^>"
j=1;L='  ||  '
a,b=[[[5,5],[10-m,m]][m<9],[n,10-n]][n<9]
print' '*6*a+s
while n>0 or 0<m:N,M=min(n,a),min(m,b);n-=a;m-=b;print '%-*s'%(6*a,N*s),'%5s'%('/\  '*j)+'%*s'%(6*b,M*" <^00'")+'\n'+'%*s'%(-6*a,N*L),'%5s'%('++  '*j),'%*s'%(6*b,M*L)+'\n';j=0

Wypróbuj online!

AWK , 293 bajty

{f=" '00^>"
l="  ||  " 
L="  /\\   "
p="  ++   "
Y=$2
X=$1-Y-1
E="      "
x=$1>11?Y<5?10-Y:X>5?5:X:X
y=$1>11?X<5?10-X:5:Y
printf"%"6*(x+1)"s\n",f
for(;X>0||Y>0;A=B=""){for(i=0;i++<x;B=B (X>=0?l:E))A=A (--X>=0?f:E)
A=A L
B=B p
for(i=0;i++<y&&--Y>=0;B=B l)A=A"<^00' "
print A"\n"B"\n"
L=p=E" "}}

Wypróbuj online!

Próbowałem użyć podstawień ciągów, aby uniknąć niektórych pętli, ale wymagało to znacznie więcej kodu.

Wyjaśnienie

{f=" '00^>"    Let's assign
l="  ||  "     some variables
L="  /\\   "   for the ASCII
p="  ++   "    pieces
Y=$2        The number of sheep that have already jumped
X=$1-Y-1    Sheep patiently waiting to jump
E="      "  A string to keep things spaced properly
x=$1>11?Y<5?10-Y:X>5?5:X:X  If there's enough sheep, let's use 5 per column
y=$1>11?X<5?10-X:5:Y        Otherwise, use enough to get 11 sheep in first row
printf"%"6*(x+1)"s\n",f     Print the top part of the jumping sheep
for(;X>0||Y>0;A=B=""){      Loop until we've printed all the sheep
  for(i=0;i++<x;              Loop over waiting sheep in this row
    B=B (X>=0?l:E))             Build the "legs" string
      A=A (--X>=0?f:E)            Build the "bodies" string
  A=A L                       Add the legs and post 
  B=B p                       for the jumping sheep
  for(i=0;i++<y&&--Y>=0;   Loop over the jumped sheep in this row
    B=B l) A=A"<^00' "     Add to the "legs" and "bodies" string 
  print A"\n"B"\n"         Print what we've got so far
  L=p=E" "                 Prevent the jumping sheep's parts from printing lots of times
}}

Muszę powiedzieć, że sztuka owiec jest raczej urocza. :)

Węgiel , 98 bajtów

Ｎθ≔⁻⊖ＮθηＦ⟦⟦00¶/\¶++ θ⌊⟦⌈⟦⁵⁻χη⟧θ⟧⟧⟦0^>¶\¶+  η⌊⟦⌈⟦⁵⁻χθ⟧η⟧⟧⟧«Ｊ⁰¦⁰‖Ｔ§ι⁰↗Ｆ§ι¹«<^00'¶  || ↗¿¬﹪⊕κ§ι²”|Ｉ4Ｏ

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

Ｎθ

Wprowadź liczbę owiec, które zostały już policzone.

≔⁻⊖Ｎθη

Wprowadź całkowitą liczbę owiec i oblicz, ile jeszcze trzeba policzyć.

Ｆ⟦⟦00¶/\¶++ θ⌊⟦⌈⟦⁵⁻χη⟧θ⟧⟧⟦0^>¶\¶+  η⌊⟦⌈⟦⁵⁻χθ⟧η⟧⟧⟧«

Utwórz tablicę dwóch tablic. Każda tablica ma następujące elementy:

• Sznurek zawierający połowę skaczących owiec
• Liczba owiec po tej stronie ogrodzenia
• Liczba owiec w jednym rzędzie po tej stronie ogrodzenia, która jest albo
  • liczba owiec po tej stronie ogrodzenia, jeśli jest mniejsza niż 5, lub
  • 10 - liczba owiec po drugiej stronie ogrodzenia, jeśli jest mniejsza niż 5, lub
  • 5, jeśli obie strony mają co najmniej 5 owiec

Ｊ⁰¦⁰‖Ｔ§ι⁰↗

Odbij płótno i wydrukuj owce w połowie skaczące.

Ｆ§ι¹«

Zapętlaj owce po tej stronie.

<^00'¶  || ↗

Wydrukuj owcę.

¿¬﹪⊕κ§ι²”|Ｉ4Ｏ

Jeśli jest to koniec rzędu, wydrukuj nowe wiersze i spacje, aby przejść do początku następnej owcy.