La maggior parte delle persone ha familiarità con il trope sul contare le pecore per addormentarsi. C'è un gregge di pecore, alcune delle quali saltano sopra una recinzione e tu conti le pecore mentre saltano. Presumibilmente, questo aiuta a calmare la mente e ti porta in uno stato simile al sonno in modo che ti addormenti.

Ecco una pecora ASCII rivolta a destra, in attesa di essere contata:

'00^>
 ||

Ecco una pecora ASCII che salta sopra una recinzione:

'00^>
 /\
 ++

Eccone uno rivolto a sinistra, essendo già stato contato:

<^00'
  ||

La sfida

Dati due numeri interi di input ne m, n > 2descrivendo il numero totale di pecore e m > 0dicendo quante pecore sono già state contate, ha prodotto una rappresentazione in arte ASCII del conteggio delle pecore per addormentarsi.

Ora per il colpo di scena:

• A causa delle dimensioni delle penne in cui si trovano le pecore, la fila superiore può contenere solo un massimo di 10pecore, senza contare le pecore che saltano attualmente, che devono anche essere sempre nella fila superiore.
• Le file successive non possono avere le pecore al di fuori delle rispettive penne (non puoi avere più pecore a sinistra nella seconda fila di quante ne trovi nella prima fila, e lo stesso vale per la destra).
• Se ci sono 11o più pecore totali, la fila superiore deve contenere 10più le pecore che saltano in essa.
• Gli spazi bianchi iniziali / finali e gli spazi bianchi tra le pecore non contano, purché:
  1. C'è un minimo di un carattere spazio tra le pecore
  2. Tutti i personaggi si allineano in modo appropriato.

Finché vengono rispettate queste regole, l'effettiva disposizione delle pecore dipende dalla vostra implementazione.

Esempi

Ad esempio, ecco n=3e m=1, il caso più semplice.

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

Ecco n=11e m=6, la maggior parte delle pecore che possono stare su una linea orizzontale.

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

Ecco un diverso esempio di ciò, con n=11em=1

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

Un esempio più grande con n=30em=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'
                                                        ||    || 

Ecco un esempio con n=17em=2

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

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

Ecco un esempio con n=19em=3

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

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

'00^>
 ||  

Si noti che tutti questi sono esempi . Per l'ultimo, potresti finire creando una serie verticale di pecore sul lato destro, che consentirà invece al lato sinistro di adattarsi su due file. O forse un quadrato 2x2 di pecore sul lato destro, che si adatterebbe anche sul lato sinistro delle pecore su due file. Eccetera.

I / O e regole

• L'input può essere preso in qualsiasi formato ragionevole e con qualsiasi metodo conveniente .
• Le linee guida iniziali / finali o altri spazi bianchi sono opzionali, a condizione che i caratteri siano allineati in modo appropriato.
• È accettabile un programma completo o una funzione. Se una funzione, è possibile restituire l'output anziché stamparlo.
• L'output può essere sulla console, restituito come un elenco di stringhe, restituito come singola stringa, ecc.
• Sono vietate le scappatoie standard .
• Si tratta di code-golf, quindi si applicano tutte le normali regole del golf e vince il codice più breve (in byte).

APL (Dyalog Unicode) , 118 byte ^SBCS

Infografica anonima lambda. Prende ncome argomento sinistro e mcome argomento giusto. Restituisce un risultato di matrice nidificata, ma la visualizzazione predefinita di questa matrice nidificata segue le specifiche. Utilizza fino a nove colonne per le pecore contate e le colonne rimanenti per le pecore in attesa.

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

Provalo online!

{... } lambda anonimo; ⍺è argomento sinistro, ⍵è argomento giusto

Questa funzione ha tre parti distinte: Waiting , Jumping e Counted . Ognuno è tra parentesi, facendo sì che il risultato sia un elenco di tre elementi.

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

''(... )' ||' le tre linee di una pecora contata specchiata, quella centrale è:

 b←'''00^<' il corpo ed è assegnato a b

↑ mescola l'elenco delle stringhe in una matrice di caratteri (riempimento con spazi)

⌽ rispecchiarlo

S← assegnare a S(big S heep)

⊂ racchiuderlo in modo che possiamo gestirlo come un'unità

⍵⍴ usa il numero di pecore contate per rimodellare ciclicamente quello

(... )↑ prendi il seguente numero di elementi (imbottitura con oggetti prototipici, cioè lo stesso array ma con tutti i caratteri sostituiti da spazi)

 ⍵÷9 un nono del numero di pecore contate

 ⌈ arrotondare

 9,⍨ appendice 9 a quello

 r← assegnare r(ciò che vogliamo r eshape con; righe e colonne)

 ×/ prodotto di tale elenco (ecco quanti elementi sono necessari, inclusi i riempimenti)

r⍴ rimodellarlo in un array con le lunghezze delle dimensioni r

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

(... )' /\' ' ++' le tre linee di una pecora che salta, la prima è:

 ¯1↓b rilascia l'ultimo carattere da b

 '>',⍨ aggiungere una testa rivolta a destra

 s← Conservare in s(piccola s Heep)

↑ mescola l'elenco delle stringhe in una matrice di caratteri (riempimento con spazi)

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

⌽S specchio S

s@2 mettilo s alla riga 2 (sostituendo i dati attuali lì)

⊂ racchiuderlo in modo che possiamo gestirlo come un'unità

(... )⍴ ridisegnare ciclicamente le dimensioni seguenti:

 ⍵+1 il numero di pecore contate più uno

 ⍺- sottrarlo dal totale

 w← assegnare a w( w aiting)

(... )↑ prendi il seguente numero di elementi da quello (imbottitura con oggetti prototipici)

 ⊢/r l'elemento più a destra di r(ovvero il numero di colonne utilizzate per le pecore contate)

 ⍵⌊ il minimo del totale e quello

 10- sottrailo da dieci

 d← assegnare a d( d ifference; colonne mancanti)

 w÷ dividere wper quello

 ⌈ arrotondare per eccesso (fornisce il numero di righe necessarie)

 d,⍨ aggiungere d

 r← assegnare r(ciò che vogliamo r eshape con; righe e colonne)

 ×/ prodotto di tale elenco (ecco quanti elementi sono necessari, inclusi i riempimenti)

r⍴ rimodellarlo in un array con le lunghezze delle dimensioni r

Javascript, 281 , 293 , 288 byte

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

Fai attenzione quando usi lo snippet di seguito, c'è un forte rischio di improvvisa narcolessia indotta.

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

Grazie a @Jonathan Frech per aver salvato un byte!

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

Provalo online!

srotolato:

#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 byte

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

Provalo online!

AWK , 293 byte

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

Provalo online!

Ho provato a usare le sostituzioni di stringhe per evitare alcuni loop, ma ci è voluto molto più codice.

Spiegazione

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

Devo dire che l'arte delle pecore è piuttosto carina. :)

Carbone , 98 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

Ｎθ

Inserisci il numero di pecore che sono già state contate.

≔⁻⊖Ｎθη

Inserisci il numero totale di ovini e calcola quanti devono ancora essere contati.

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

Creare una matrice di due matrici. Ogni array ha i seguenti elementi:

• Una stringa contenente metà delle pecore che saltano
• Il numero di pecore su quel lato della recinzione
• Il numero di pecore in una fila su quel lato della recinzione, che è uno dei due
  • il numero di pecore su quel lato della recinzione, se inferiore a 5, oppure
  • 10 - il numero di pecore dall'altra parte della recinzione, se inferiore a 5, oppure
  • 5, se entrambe le parti hanno almeno 5 pecore

Ｊ⁰¦⁰‖Ｔ§ι⁰↗

Rifletti la tela e stampa la mezza pecora che salta.

Ｆ§ι¹«

Passa attraverso le pecore da quel lato.

<^00'¶  || ↗

Stampa una pecora.

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

Se questa è la fine della riga, stampa alcune righe e spazi per arrivare all'inizio della pecora successiva.