La mayoría de las personas están familiarizadas con el tropo sobre contar ovejas para conciliar el sueño. Hay un rebaño de ovejas, algunas de ellas saltando sobre una cerca, y cuentas las ovejas mientras saltan. Supuestamente, esto ayuda a calmar tu mente y te pone en un estado de sueño para que te duermas.

Aquí hay una oveja ASCII mirando hacia la derecha, esperando ser contada:

'00^>
 ||

Aquí hay una oveja ASCII saltando sobre una cerca:

'00^>
 /\
 ++

Aquí hay uno hacia la izquierda, que ya se ha contado:

<^00'
  ||

El reto

Dados dos enteros de entrada ny m, al n > 2describir cuántas ovejas en total y m > 0decir cuántas ovejas ya se han contado, genera una representación artística ASCII de contar ovejas para conciliar el sueño.

Ahora para el giro:

• Debido al tamaño de los corrales en los que se encuentran las ovejas, la fila superior solo puede contener un máximo de 10ovejas, sin contar las ovejas que saltan actualmente, que también deben estar siempre en la fila superior.
• Las filas siguientes no pueden tener las ovejas fuera de sus corrales respectivos (no puede tener más ovejas a la izquierda en la segunda fila que en la primera fila, y lo mismo para la derecha).
• Si hay 11o más ovejas en total, la fila superior debe tener 10más las ovejas saltarinas.
• El espacio en blanco inicial / final y el espacio en blanco entre las ovejas no importa, siempre que:
  1. Hay un mínimo de un carácter de espacio en blanco entre ovejas
  2. Todos los personajes se alinean apropiadamente.

Mientras se cumplan estas reglas, la disposición real de las ovejas depende de su implementación.

Ejemplos

Por ejemplo, aquí está n=3y m=1, el caso más simple.

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

Aquí está n=11y m=6, la mayoría de las ovejas que pueden caber en una línea horizontal.

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

Aquí hay un ejemplo diferente de eso, con n=11ym=1

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

Un ejemplo más grande con n=30ym=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'
                                                        ||    || 

Aquí hay un ejemplo con n=17ym=2

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

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

Aquí hay un ejemplo con n=19ym=3

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

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

'00^>
 ||  

Tenga en cuenta que todos estos son ejemplos . Para el último, puede terminar creando una matriz vertical de ovejas en el lado derecho, lo que permitirá que el lado izquierdo encaje en dos filas. O tal vez un cuadrado de ovejas de 2x2 en el lado derecho, que también cabría las ovejas del lado izquierdo en dos filas. Etc.

E / S y reglas

• La entrada puede tomarse en cualquier formato razonable y por cualquier método conveniente .
• Las nuevas líneas iniciales / finales u otros espacios en blanco son opcionales, siempre que los caracteres se alineen adecuadamente.
• Un programa completo o una función son aceptables. Si es una función, puede devolver el resultado en lugar de imprimirlo.
• La salida puede ser a la consola, devuelta como una lista de cadenas, devuelta como una sola cadena, etc.
• Las lagunas estándar están prohibidas.
• Este es el código de golf, por lo que se aplican todas las reglas habituales de golf, y gana el código más corto (en bytes).

APL (Dyalog Unicode) , ^{SBCS de} 118 bytes

Anónimo infijo lambda. Toma ncomo argumento izquierdo y mcomo argumento derecho. Devuelve un resultado de matriz anidada, pero la visualización predeterminada de esta matriz anidada sigue las especificaciones. Utiliza hasta nueve columnas para ovejas contadas y las columnas restantes para ovejas en espera.

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

Pruébalo en línea!

{... } lambda anónimo; ⍺es argumento izquierdo, ⍵es argumento correcto

Esta función tiene tres partes distintas: Esperando , Saltando y Contada . Cada uno está entre paréntesis, lo que hace que el resultado sea una lista de tres elementos.

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

''(… )' ||' Las tres líneas de una oveja contada reflejada, la del medio es:

 b←'''00^<' el cuerpo y se le asigna a b

↑ mezclar la lista de cadenas en una matriz de caracteres (relleno con espacios)

⌽ espejo que

S← asignar a S(gran S heep)

⊂ adjuntarlo para que podamos tratarlo como una unidad

⍵⍴ use el número de ovejas contadas para remodelar cíclicamente ese

(... )↑ tome el siguiente número de elementos de eso (relleno con elementos prototípicos, es decir, la misma matriz pero con todos los caracteres reemplazados por espacios)

 ⍵÷9 una novena cantidad de ovejas contadas

 ⌈ redondeo

 9,⍨ agregar 9 a eso

 r← asignar a r(lo que queramos r eshape con; filas y columnas)

 ×/ producto de esa lista (esta es la cantidad de elementos que necesitamos, incluidos los rellenos)

r⍴ remodelar eso a una matriz con las longitudes de dimensión r

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

(... )' /\' ' ++' las tres líneas de una oveja saltando, la primera es:

 ¯1↓b soltar el último personaje de b

 '>',⍨ agregar una cabeza hacia la derecha

 s← almacenar en s(pequeño s heep)

↑ mezclar la lista de cadenas en una matriz de caracteres (relleno con espacios)

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

⌽S espejo S

s@2 poner s en la línea 2 de eso (reemplazando los datos actuales allí)

⊂ adjuntarlo para que podamos tratarlo como una unidad

(… )⍴ Reestructura cíclicamente eso al siguiente tamaño:

 ⍵+1 la cantidad de ovejas contadas más una

 ⍺- restar eso del total

 w← asignar a w( w aiting)

(... )↑ tome el siguiente número de elementos de eso (relleno con elementos prototípicos)

 ⊢/r el elemento más a la derecha de r(es decir, el número de columnas usadas para ovejas contadas)

 ⍵⌊ el mínimo del total y que

 10- restar eso de diez

 d← asignar a d( d ifference; columnas faltantes)

 w÷ dividir wpor eso

 ⌈ redondear hacia arriba (da el número de filas necesarias)

 d,⍨ adjuntar d

 r← asignar a r(lo que queramos r eshape con; filas y columnas)

 ×/ producto de esa lista (esta es la cantidad de elementos que necesitamos, incluidos los rellenos)

r⍴ remodelar eso a una matriz con las longitudes de dimensión r

Javascript, 281 , 293 , 288 bytes

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

Tenga cuidado al usar el fragmento a continuación, existe un gran riesgo de narcolepsia inducida repentina.

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

¡Gracias a @Jonathan Frech por guardar 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++);}

Pruébalo en línea!

Desenrollado:

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

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

Pruébalo en línea!

AWK , 293 bytes

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

Pruébalo en línea!

Intenté usar sustituciones de cadenas para evitar algunos bucles, pero tomó mucho más código.

Explicación

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

Debo decir que el arte de las ovejas es bastante lindo. :)

Carbón , 98 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

Ｎθ

Ingrese el número de ovejas que ya se han contado.

≔⁻⊖Ｎθη

Ingrese el número total de ovejas y calcule cuántas aún deben contarse.

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

Crea una matriz de dos matrices. Cada matriz tiene los siguientes elementos:

• Una cuerda que contiene la mitad de las ovejas saltando
• El número de ovejas en ese lado de la cerca.
• El número de ovejas en una fila en ese lado de la cerca, que es
  • el número de ovejas en ese lado de la cerca, si son menos de 5, o
  • 10 - el número de ovejas en el otro lado de la cerca, si es menos de 5, o
  • 5, si ambos lados tienen al menos 5 ovejas

Ｊ⁰¦⁰‖Ｔ§ι⁰↗

Refleja el lienzo e imprime la oveja que salta a medias.

Ｆ§ι¹«

Recorre las ovejas de ese lado.

<^00'¶  || ↗

Imprime una oveja.

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

Si este es el final de la fila, imprima algunas líneas nuevas y espacios para llegar al comienzo de la próxima oveja.