Muitas pessoas estão familiarizadas com a questão de contar ovelhas para adormecer. Há um rebanho de ovelhas, algumas delas pulando uma cerca, e você conta as ovelhas quando elas pulam. Supostamente, isso ajuda a acalmar sua mente e coloca você em um estado de sono para que você adormeça.

Aqui está uma ovelha ASCII voltada para a direita, esperando para ser contada:

'00^>
 ||

Aqui está uma ovelha ASCII pulando uma cerca:

'00^>
 /\
 ++

Aqui está um voltado para a esquerda, já tendo sido contado:

<^00'
  ||

O desafio

Dadas duas entradas inteiras, ne m, n > 2descrevendo quantas ovelhas totalizam e m > 0dizendo quantas ovelhas já foram contadas, produz uma representação de arte ASCII da contagem de ovelhas para adormecer.

Agora, para a reviravolta:

• Devido ao tamanho das canetas nas quais as ovelhas estão, a linha superior pode conter apenas um máximo de 10ovelhas, sem contar as ovelhas que estão pulando no momento, que também devem estar sempre na linha superior.
• As linhas subsequentes não podem ter as ovelhas fora de suas respectivas canetas (você não pode ter mais ovelhas à esquerda na segunda linha do que na primeira linha e o mesmo para a direita).
• Se houver 11ou mais ovelhas totais, a linha superior deve ter 10mais as ovelhas saltadoras.
• Os espaços em branco à esquerda / à esquerda e os espaços entre as ovelhas não importam, desde que:
  1. Há no mínimo um caractere de espaço em branco entre ovelhas
  2. Todos os caracteres estão alinhados adequadamente.

Desde que essas regras sejam cumpridas, o arranjo real das ovelhas depende da sua implementação.

Exemplos

Por exemplo, aqui está n=3e m=1, o caso mais simples.

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

Aqui está n=11e m=6, o máximo de ovelhas que podem caber em uma linha horizontal.

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

Aqui está um exemplo diferente disso, com n=11em=1

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

Um exemplo maior com 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'
                                                        ||    || 

Aqui está um exemplo com n=17em=2

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

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

Aqui está um exemplo com n=19em=3

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

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

'00^>
 ||  

Observe que todos esses são exemplos . No último, você pode acabar criando uma matriz vertical de ovelhas no lado direito, o que permitirá que o lado esquerdo se encaixe em duas linhas. Ou talvez um quadrado 2x2 de ovelhas no lado direito, que também encaixaria a ovelha do lado esquerdo em duas fileiras. Etc.

E / S e regras

• A entrada pode ser obtida em qualquer formato razoável e por qualquer método conveniente .
• Novas linhas à esquerda / à direita ou outro espaço em branco são opcionais, desde que os caracteres sejam alinhados adequadamente.
• Um programa completo ou uma função são aceitáveis. Se uma função, você pode retornar a saída em vez de imprimi-la.
• A saída pode ser no console, retornada como uma lista de cadeias, retornada como uma única cadeia, etc.
• As brechas padrão são proibidas.
• Isso é código-golfe, portanto todas as regras usuais de golfe se aplicam e o código mais curto (em bytes) vence.

APL (Dyalog Unicode) , 118 bytes ^SBCS

Infix anônimo lambda. Toma ncomo argumento à esquerda e mcomo argumento à direita. Retorna um resultado de matriz aninhada, mas a exibição padrão dessa matriz aninhada segue as especificações. Usa até nove colunas para ovelhas contadas e as colunas restantes para ovelhas em espera.

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

Experimente online!

{... } lambda anônima; ⍺é argumento à esquerda, ⍵é argumento à direita

Essa função possui três partes distintas: Aguardando , Pulando e Contado . Cada um está entre parênteses, fazendo com que o resultado seja uma lista de três elementos.

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

''(… )' ||' As três linhas de uma ovelha contada espelhada, sendo a do meio:

 b←'''00^<' o corpo e é designado para b

↑ misture a lista de strings em uma matriz de caracteres (preenchimento com espaços)

⌽ espelhar isso

S← atribuir a S(big S heep)

⊂ anexá-lo para que possamos lidar com isso como uma unidade

⍵⍴ use o número de ovelhas contadas para remodelar ciclicamente

(… )↑ Pegue o seguinte número de elementos (preenchimento com itens prototípicos, ou seja, a mesma matriz, mas com todos os caracteres substituídos por espaços)

 ⍵÷9 um nono do número de ovelhas contadas

 ⌈ arredondar para cima

 9,⍨ acrescentar 9 a isso

 r← atribuir a r(o que vai r eshape com; linhas e colunas)

 ×/ produto dessa lista (são quantos elementos precisamos, incluindo preenchimentos)

r⍴ remodelar isso para uma matriz com os comprimentos de cota r

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

(… )' /\' ' ++' As três linhas de uma ovelha saltadora, sendo a primeira:

 ¯1↓b solte o último caractere de b

 '>',⍨ anexar uma cabeça voltada para a direita

 s← loja em s(pequeno s heep)

↑ misture a lista de strings em uma matriz de caracteres (preenchimento com espaços)

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

⌽S espelho S

s@2 coloque s na linha 2 disso (substituindo os dados atuais lá)

⊂ anexá-lo para que possamos lidar com isso como uma unidade

(… )⍴ Remodelar ciclicamente isso para o seguinte tamanho:

 ⍵+1 o número de ovelhas contadas mais uma

 ⍺- subtrair que do total

 w← atribuir a w( w aiting)

(… )↑ Pegue o seguinte número de elementos (preenchimento com itens prototípicos)

 ⊢/r o elemento mais à direita de r(ou seja, o número de colunas usadas para ovelhas contadas)

 ⍵⌊ o mínimo do total e que

 10- subtrair que de dez

 d← atribuir a d( d ifference; colunas ausentes)

 w÷ dividir wpor isso

 ⌈ arredondar para cima (fornece o número de linhas necessárias)

 d,⍨ acrescentar d

 r← atribuir a r(o que vai r eshape com; linhas e colunas)

 ×/ produto dessa lista (são quantos elementos precisamos, incluindo preenchimentos)

r⍴ remodelar isso para uma matriz com os comprimentos de cota 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});

Tenha cuidado ao usar o trecho abaixo, pois há um grande risco de narcolepsia induzida 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

Agradecemos a Jonathan Frech por salvar um 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++);}

Experimente online!

Desenrolado:

#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

Experimente online!

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

Experimente online!

Tentei usar substituições de string para evitar alguns loops, mas foi preciso muito mais código.

Explicação

{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 dizer que a arte das ovelhas é bem fofa. :)

Carvão , 98 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

Ｎθ

Insira o número de ovelhas que já foram contadas.

≔⁻⊖Ｎθη

Insira o número total de ovelhas e calcule quantas ainda precisam ser contadas.

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

Crie uma matriz de duas matrizes. Cada matriz possui os seguintes elementos:

• Uma corda contendo metade das ovelhas saltadoras
• O número de ovelhas naquele lado da cerca
• O número de ovelhas em uma linha do lado da cerca, ou seja,
  • o número de ovelhas desse lado da cerca, se inferior a 5, ou
  • 10 - o número de ovelhas do outro lado da cerca, se for menor que 5, ou
  • 5, se ambos os lados tiverem pelo menos 5 ovelhas

Ｊ⁰¦⁰‖Ｔ§ι⁰↗

Reflita a tela e imprima as ovelhas pulando pela metade.

Ｆ§ι¹«

Passe pelas ovelhas daquele lado.

<^00'¶  || ↗

Imprima uma ovelha.

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

Se este for o fim da linha, imprima algumas linhas e espaços novos para chegar ao início da próxima ovelha.