La plupart des gens connaissent le trope sur le comptage des moutons pour s'endormir. Il y a un troupeau de moutons, certains sautant par-dessus une clôture, et vous comptez les moutons pendant qu'ils sautent. Soi-disant, cela aide à calmer votre esprit et vous met dans un état de sommeil de sorte que vous vous endormez.

Voici un mouton ASCII tourné vers la droite, attendant d'être compté:

'00^>
 ||

Voici un mouton ASCII sautant par-dessus une clôture:

'00^>
 /\
 ++

En voici une tournée vers la gauche, ayant déjà été comptée:

<^00'
  ||

Le défi

Étant donné deux entiers d'entrée, net m, en n > 2décrivant le nombre total de moutons et en m > 0disant combien de moutons ont déjà été comptés, affichez une représentation artistique ASCII du comptage des moutons pour s'endormir.

Maintenant, pour la torsion:

• En raison de la taille des enclos où se trouvent les moutons, la rangée du haut ne peut contenir qu'un maximum de 10moutons, sans compter les moutons qui sautent actuellement, qui doivent également toujours être dans la rangée du haut.
• Les rangées suivantes ne peuvent pas avoir les moutons en dehors de leurs enclos respectifs (vous ne pouvez pas avoir plus de moutons à gauche dans la deuxième rangée que vous n'en avez dans la première rangée, et même pour la droite).
• S'il y a 11ou plus de moutons au total, la rangée du haut doit contenir 10plus les moutons sauteurs.
• Les espaces blancs en tête / arrière et les espaces entre les moutons n'ont pas d'importance, tant que:
  1. Il y a au moins un espace entre les moutons
  2. Tous les personnages s'alignent correctement.

Tant que ces règles sont respectées, la disposition réelle des moutons dépend de votre mise en œuvre.

Exemples

Par exemple, voici n=3et m=1, le cas le plus simple.

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

Voici n=11et m=6, le plus de moutons pouvant tenir sur une seule ligne horizontale.

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

Voici un autre exemple de cela, avec n=11etm=1

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

Un plus grand exemple avec n=30etm=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'
                                                        ||    || 

Voici un exemple avec n=17etm=2

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

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

Voici un exemple avec n=19etm=3

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

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

'00^>
 ||  

Notez que tous ces exemples sont . Pour le dernier, vous pouvez créer un réseau vertical de moutons sur le côté droit, ce qui permettra au côté gauche de tenir sur deux rangées à la place. Ou peut-être un carré de moutons de 2x2 sur le côté droit, qui pourrait également adapter les moutons du côté gauche sur deux rangées. Etc.

E / S et règles

• L'entrée peut être prise dans n'importe quel format raisonnable et par n'importe quelle méthode pratique .
• Les sauts de ligne de début / fin ou d'autres espaces sont facultatifs, à condition que les caractères s'alignent correctement.
• Un programme complet ou une fonction sont acceptables. S'il s'agit d'une fonction, vous pouvez renvoyer la sortie plutôt que de l'imprimer.
• La sortie peut être vers la console, retournée sous forme de liste de chaînes, retournée sous forme de chaîne unique, etc.
• Les failles standard sont interdites.
• Il s'agit de code-golf, donc toutes les règles de golf habituelles s'appliquent et le code le plus court (en octets) l'emporte.

APL (Dyalog Unicode) , 118 octets ^SBCS

Infixe anonyme lambda. Prend ncomme argument de gauche et mcomme argument de droite. Renvoie un résultat de tableau imbriqué, mais l'affichage par défaut de ce tableau imbriqué suit les spécifications. Utilise jusqu'à neuf colonnes pour les moutons comptés et les colonnes restantes pour les moutons en attente.

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

Essayez-le en ligne!

{… } Lambda anonyme; ⍺est l'argument gauche, ⍵est l'argument droit

Cette fonction comporte trois parties distinctes: attente , saut et comptage . Chacun est entre parenthèses, ce qui fait que le résultat est une liste à trois éléments.

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

''(… Les )' ||' trois lignes d'un mouton compté en miroir, celle du milieu étant:

 b←'''00^<' le corps et est affecté à b

↑ mélanger la liste des chaînes dans une matrice de caractères (remplissage avec des espaces)

⌽ miroir qui

S← assigner à S(gros heep S )

⊂ le joindre afin que nous puissions le traiter comme une unité

⍵⍴ utiliser le nombre de moutons comptés pour remodeler cycliquement

(… En )↑ prendre le nombre suivant d'éléments (remplissage avec des éléments prototypiques, c'est-à-dire le même tableau mais avec tous les caractères remplacés par des espaces)

 ⍵÷9 un neuvième du nombre de moutons comptés

 ⌈ rassembler

 9,⍨ ajouter 9 à cela

 r← assigner à r(ce que nous allons r Eshape avec, lignes et colonnes)

 ×/ produit de cette liste (c'est le nombre d'éléments dont nous avons besoin, y compris les remplissages)

r⍴ remodeler cela en un tableau avec les longueurs de dimension r

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

(… Les )' /\' ' ++' trois lignes d'un mouton sauteur, la première étant:

 ¯1↓b supprimer le dernier caractère de b

 '>',⍨ ajouter une tête tournée vers la droite

 s← magasin dans s(petite s Heep)

↑ mélanger la liste des chaînes dans une matrice de caractères (remplissage avec des espaces)

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

⌽S miroir S

s@2 mettre s à la ligne 2 de cela (en remplaçant les données actuelles là-bas)

⊂ le joindre afin que nous puissions le traiter comme une unité

(… )⍴ Remodelez cela cycliquement à la taille suivante:

 ⍵+1 le nombre de moutons comptés plus un

 ⍺- soustrayez cela du total

 w← attribuer à w( w aiting)

(… En )↑ extraire le nombre d'éléments suivant (remplissage avec des éléments prototypiques)

 ⊢/r l'élément le plus à droite de r(c'est-à-dire le nombre de colonnes utilisées pour les moutons comptés)

 ⍵⌊ le minimum du total et que

 10- soustrayez cela de dix

 d← affecter à d( d ifference; colonnes manquantes)

 w÷ diviser wpar ça

 ⌈ arrondir (donne le nombre de lignes nécessaires)

 d,⍨ ajouter d

 r← assigner à r(ce que nous allons r Eshape avec, lignes et colonnes)

 ×/ produit de cette liste (c'est le nombre d'éléments dont nous avons besoin, y compris les remplissages)

r⍴ remodeler cela en un tableau avec les longueurs de dimension r

Javascript, 281 , 293 , 288 octets

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

Soyez prudent lorsque vous utilisez l'extrait ci-dessous, il y a un risque élevé de narcolepsie soudaine induite.

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

Merci à @Jonathan Frech d'avoir enregistré un octet!

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

Essayez-le en ligne!

Déroulé:

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

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

Essayez-le en ligne!

AWK , 293 octets

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

Essayez-le en ligne!

J'ai essayé d'utiliser des substitutions de chaînes pour éviter certaines boucles, mais cela a pris beaucoup plus de code.

Explication

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

Je dois dire que l'art des moutons est plutôt mignon. :)

Fusain , 98 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

Ｎθ

Entrez le nombre de moutons qui ont déjà été comptés.

≔⁻⊖Ｎθη

Saisissez le nombre total de moutons et calculez combien doivent encore être comptés.

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

Créez un tableau de deux tableaux. Chaque tableau comprend les éléments suivants:

• Une chaîne contenant la moitié des moutons sauteurs
• Le nombre de moutons de ce côté de la clôture
• Le nombre de moutons dans une rangée de ce côté de la clôture, qui est soit
  • le nombre de moutons de ce côté de la clôture, s'il est inférieur à 5, ou
  • 10 - le nombre de moutons de l'autre côté de la clôture, si moins de 5, ou
  • 5, si les deux côtés ont au moins 5 moutons

Ｊ⁰¦⁰‖Ｔ§ι⁰↗

Reflétez la toile et imprimez le mouton à demi sauteur.

Ｆ§ι¹«

Faites une boucle à travers les moutons de ce côté.

<^00'¶  || ↗

Imprimez un mouton.

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

Si c'est la fin de la ligne, imprimez quelques nouvelles lignes et espaces pour arriver au début du prochain mouton.