Algumas pessoas contam ovelhas para dormir. Outros contam cabras.

Escreva um programa ou função que capte um número inteiro positivo N e produza cabras N-1 acordadas, seguidas por uma cabra adormecida, como se alguém estivesse contando N cabras e, por fim, adormecesse.

As cabras acordadas ficam assim:

      \
  ___/o>
-(___)"
 '' ''

As cabras adormecidas ficam assim:

      \
  ___/->
,(___)"
 `` ``

Eles estão acorrentados em conjunto com um único espaço entre barba e cauda de cabras adjacentes:

      \       \       \
  ___/o>  ___/o>  ___/->
-(___)" -(___)" ,(___)"
 '' ''   '' ''   `` ``

É permitido que a saída tenha espaços à direita e uma única nova linha à direita.

O código mais curto em bytes vence.

Exemplos

N = 1:

      \
  ___/->
,(___)"
 `` ``

N = 2:

      \       \
  ___/o>  ___/->
-(___)" ,(___)"
 '' ''   `` ``

N = 3:

      \       \       \
  ___/o>  ___/o>  ___/->
-(___)" -(___)" ,(___)"
 '' ''   '' ''   `` ``

N = 4:

      \       \       \       \
  ___/o>  ___/o>  ___/o>  ___/->
-(___)" -(___)" -(___)" ,(___)"
 '' ''   '' ''   '' ''   `` ``

N maior deve funcionar da mesma forma.

MATL , 56 53 bytes

:"'!!((!((!!#*```).?p0```!!!]'8eP!P]'p(.' '.a-'XE&hqc

Experimente online!

Explicação

Cabra acordada

A cabra acordada pode ser empacotada na corda

  '' ''  ")___(->o/___   \

e descompactado como será explicado em breve. No entanto, os símbolos de aspas simples precisariam ser duplicados para escapar deles, portanto a literal da cadeia de caracteres teria que ser definida como (observe os símbolos de aspas simples e a duplicação dos originais):

'  '''' ''''  ")___(->o/___   \'

Para salvar bytes, definimos a string usando caracteres um ponto de código acima , evitando assim a duplicação. A string literal se torna

'!!((!((!!#*```).?p0```!!!]'

No final do código, subtrairemos 1 e converteremos em char. (Poderíamos fazê-lo agora, logo após a string literal; mas deixá-la para o final economizará outra duplicação de aspas simples, como veremos).

Para explicar como a string é descompactada, trabalharemos com os caracteres originais (que são produzidos no final do código com a subtilação de 1), para que a explicação seja mais fácil de seguir. Primeiro remodelamos a string

  '' ''  ")___(->o/___   \

em um array de caracteres 2D de 8 linhas, na ordem principal da coluna (para baixo e depois para o outro lado). Isso preenche automaticamente a última coluna com o caractere 0 (no final do código, subtrair 1 o transformará em número -1, que convertido em char retorna novamente o caractere 0). O caractere 0 é exibido como um espaço. Tão efetivamente estamos preenchendo espaços. O resultado da remodelagem é

  > 
 "o\
')/ 
'__ 
 __ 
'__ 
'(  
 -  

Agora, alternamos verticalmente:

 -  
'(  
'__ 
 __ 
'__ 
')/ 
 "o\
  > 

e depois transponha e vire verticalmente novamente para produzir a cabra acordada:

      \ 
  ___/o>
-(___)" 
 '' ''  

As duas operações de inversão são necessárias porque a sequência empacotada original é "ao contrário". Isso é para explorar o fato de que a matriz de caracteres 2D real que representa a cabra possui 6 espaços iniciais em sua primeira linha, que são preenchidos automaticamente por preenchimento quando a string é remodelada em uma matriz 2D de 8 linhas. Mas o preenchimento é feito no final (não no início) da última coluna (não na linha), daí os movimentos e transposição.

Cabra adormecida

Uma cabra dormir é gerado a partir de uma cabra acordado por caracteres Transliterando o, ', -em -, `, ,respectivamente. Na verdade, por causa da transformação de um código de ponto-acima, transliterá caracteres p, (, 'para ., a, -, que mais uma vez nos salva de ter que duplicar o símbolo aspas simples. É por isso que a operação subtrair uma foi deixada para o final do programa.

Estrutura de código

1. Gere uma cabra acordada N, trabalhando com pontos de código aumentados em 1.
2. Transforme a última cabra em uma cabra adormecida.
3. Concatene todas as cabras horizontalmente. Subtrair 1 para codificar pontos e converter para char.

Código comentado

:                              % (Step 1) Implicitly input N. Push range [1 2 ... N]
"                              % For each (i.e. repeat N times)
  '!!((!((!!#*```).?p0```!!!]' %   Push this string. Quotes are escaped by duplicating
  8e                           %   Reshape into an 8-row 2D array of char, in
                               %   column-major order, padding last column with
                               %   char 0
  P                            %   Flip vertically
  !P                           %   Transpose and flip vertically
]                              % End
'p(.'                          % (Step 2) Push this string: source for transliteration
'.a-'                          % Push this string: target for transliteration
XE                             % Transliterate. Transforms last goat into sleeping
&h                             % (Step 3) Horizontally concat all 2D char arrays
qc                             % Subtract 1 and convert to char. 0 becomes −1, which
                               % is converted to char 0, which is displayed as a space
                               % Implicitly display 

Python 3.6, 102 bytes

lambda n:f'''{'      \ '*n}
{'  ___/o>'*~-n}  ___/->
{'-(___)" '*~-n},(___)"
{" '' ''  "*~-n} `` ``'''

Yaay, f-strings !

            __________________________
           / \
          | Esta resposta é baaaaaaad. |
      \ / ___________________________ /
  ___ / o> '  
- (___) " 
 '' ''  

Javascript, 122 bytes

Responda

f=(n,r='repeat')=>'      \\ '[r](n--)+`
${'  ___/o>'[r](n)}  ___/->
${'-(___)" '[r](n)},(___)"
`+` '' ''  `[r](n)+' `` ``'

Nota lateral
No código a seguir (91 bytes), as cabras estão alinhadas verticalmente. Ele não está de acordo com o formato de saída, mas eu poderia ser interessante notar que o alinhamento horizontal necessário no formato de saída precisa de mais bytes:

f=n=>`
      \\
  ___/${--n?'o':'-'}>
${n?'-':','}(___)"
 ${n?'`` ``':`'' ''`}`+(n?f(n):'')

Lote, 234 bytes

@echo off
set/pn=
call:l "      \ " "      \"
call:l "  ___/o]" "  ___/-]"
call:l "-(___)@ " ",(___)@"
call:l " '' ''  " " `` ``"
exit/b
:l
set s=%~2
for /l %%i in (2,1,%n%)do call set s=%~1%%s%%
set s=%s:@="%
echo %s:]=^>%

Recebe entrada de stdin. O lote tem problemas com "e >por várias razões, então eu tenho que usar espaços reservados e depois trocá-los no final.

Pyke, 56 54 bytes

Fhqd6*"\
  ___/o>
-(___)
 '' ''"+23\":RI"-o'"",-`".:(P

Experimente aqui!

4 bytes a mais porque o Pyke não permite aspas duplas nas strings :(

JavaScript (ES6), 110 109 bytes

f=
n=>`      \\       \\
  ___/o>  ___/->
-(___)" ,(___)"
 '' ''   `.replace(/^.{8}/gm,"$&".repeat(n-1))+"`` ``"
;

<input type=number min=1 oninput=o.textContent=f(this.value)><pre id=o>

Ter que suportar todos os três tipos de caracteres de citação foi irritante, mas felizmente o comentário de @ pinkfloydx33 me deu o flash de inspiração de que eu poderia adicionar as aspas no final, economizando 1 byte.

GolfScript , 91 bytes

~:a 1-:b;"      \\ "a*n"  ___/o>"b*"  ___/->"n"-(___)\" "b*",(___)\""n" '' ''  "b*" `` ``"n

Entrada: 3

Saída:

      \       \       \ 
  ___/o>  ___/o>  ___/->
-(___)" -(___)" ,(___)"
 '' ''   '' ''   `` ``

Explicação

~:a 1-:b;      # Parse and save the input
"      \\ "a*n # Repeat the first line 'a' times
"  ___/o>"b*   # Repeat the head 'b' times
"  ___/->"n    # Then add the sleeping goat's head
"-(___)\" "b*  # Idem
",(___)\""n    #
" '' ''  "b*   # Idem
" `` ``"n      #

Experimente online!

Geléia , 62 56 bytes

⁶ẋ6;“\   ___/o>-(___)"  '' ''  ”s8
¢“-,o-'`”yЀ
’1£ẋ€ż¢Y

Teste-o em TryItOnline

Quão?

⁶ẋ6;“\   ___/o>-(___)"  '' ''  ”s8 - Link 1: make a goat, niladic
⁶ẋ6                                - space character, ⁶, repeated 6 times
    “\   ___/o>-(___)"  '' ''  ”   - rest of the awake goat text
   ;                               - concatenate
                                s8 - split into length 8 parts

¢“-,o-'`”yЀ - Link 2: put a goat to sleep, niladic
¢            - last link (make a goat)
 “-,o-'`”    - characters to remap
         yЀ - map for each (change "-" into ",", "o" into "-", and "-" into "`"

’1£ẋ€ż¢Y - Main link: n
’        - decrement (nAwakeGoats)
 1£      - call link 1 as a nilad (make an awake goat)
   ẋ€    - repeat nAwakeGoats times
      ¢  - last link (make a sleeping goat)
     ż   - zip
       Y - join with line feeds
         - implicit print

PHP, 200 bytes

$a=["      \ ","  ___/o>",'-(___)" '," '' ''  "," `` ``  "];$z=8*$n=$argv[1];for($i=0;$i<4;)$o.=str_repeat($a[$i],$i++==3?$n-1:$n);$o[$z*2-2]="-";$o[$z*3-8]=",";$o.=$a[4];echo chunk_split($o,$z,"\n");

C ++, 180 bytes

auto f(int n)
{
string a,b,c,d;
while(n--)
{
a+="      \\ ";
b+="  ___/";b+=n?"o>":"->\n";
c+=n?"-(___)\" ":",(___)\" \n";
d+=n?R"( '' ''  )":" `` ``  \n";
}
return a+'\n'+b+c+d;
}

Pip , 60 + 1 = 61 bytes

Um byte adicionado para o nsinalizador.

YsX6.\"\   ___/o>-(___)"  '' ''  \"<>8yXa-1.YyR^"-o'"Y^",-`"

Constrói uma cabra acordada como uma lista de linhas e a puxa y. String se multiplica para obter a-1cabras acordadas. Substitui -o'por ,-`in ye concatena até o final. Imprime, separado por nova linha.

Experimente online!

(Acho que é a minha primeira vez usando a sintaxe de cadeia de caracteres de escape de Pip \"...\", que permite aspas duplas literais na cadeia de caracteres.)

CJam , 58 bytes

ri{S6*"\   ___/o>,(___)\"  '' ''  "+\{'o`"`-"er}|8/}%W%zN*

Experimente online!

Explicação

ri                               e# Read an integer from input
{                                e# Map the following block to the range 0..input-1
 S6*                             e#  Push 6 space characters
 "\   ___/o>,(___)\"  '' ''  "+  e#  Push this string and concatenate with the spaces
 \                               e#  Bring the number being mapped to the top
 {                               e#  If it's 0, execute this block:
  'o`                            e#   Push the string "'o"
  "`-"                           e#   Push the string "`-"
  er                             e#   Transliterate the large string by replacing characters
                                 e#    from "'o" with respective characters from "`-"; this
                                 e#    makes the sleeping goat.
 }|                              e#  (end if)
 8/                              e#  Split the string into chunks of length 8
}%                               e# (end map)
W%                               e# Reverse the array, since the sleeping goat was made at 
                                 e#  the beginning
z                                e# Transpose
N*                               e# Join with newlines

Python 2.7, 101 113 bytes

Editar: definição de função adicionada

def f(n):
 m=n-1
 print "      \ "*n+"\n"+"  ___/o>"*m+"  ___/->\n"+'-(___)" '*n+"\n"+" '' ''  "*m+" ``"*2

desc Golfificado:

m=n-1              # Replacement variable. Saves 6 bytes
"      \ "*n+"\n"+ # Print ears, same for all goats!
"  ___/o>"*m+      # Print eyes of n-1 awake goat
"  ___/->\n"+      # Print eye of sleeping goat
'-(___)" '*m+      # Print body of n-1 awake goat
',(___)"\n'+       # Print body of sleeping goat
+" '' ''  "*m+     # Print the legs of n-1 awake goat
" ``"*2            # Print legs of sleeping goat using *2 operator to save 1 byte

Nota O Python2.7 é um byte menor que o Python3, pois não precisa de parentese durante a impressão.

05AB1E , 66 bytes

’      \ 0  ___/1>02(___)" 0 33 33  ’0¡v123SDys…o-'S:I<×?ys…-,`S:,

Experimente online!

Explicação

’      \ 0  ___/1>02(___)" 0 33 33  ’0¡v123SDys…o-'S:I<×?ys…-,`S:,   Argument n
’      \ 0  ___/1>02(___)" 0 33 33  ’   The goat, newline replaced by 0 and the eye replaced by 1
0¡                              Split on 0
  v                             For each y in array, do:
   123SD                          Push the array [1,2,3] twice
        ys…o-'S:                  Replace [1,2,3] with ['o','-','\'']
                I<×?              Print that n-1 times without newline
                    ys…-,`S:,     Replace [1,2,3] with ['-',',','`'] and print

Bash + GNU Coreutils, 165 155 bytes

a=" \      
>o/___  
 \")___(-
  '' '' "
eval paste -d \'\' $(seq $1|while read;do
printf '<(echo "$a") '
done) | sed "s/-/,/;s/o/-/;s/'' ''/"'`` ``/'|rev

Correr com:

bash my_pgm.bash N

Basicamente, o programa imprime N vezes do mesmo cabra (invertida), e substitui a primeira -, por ,, o primeiro opara -e do primeiro '' ''para os crases. Então inverte as linhas.

PHP, 133 131 bytes

for(;$y<32;$y+=8)for($x=$argv[1];$x--;)echo substr("      \   ___/".($x?"o>-(___)\"  '' ''  ":"->,(___)\"  `` ``  "),$y,8),"
"[$x];

Eu encontrei dois bytes para jogar golfe longe de uma versão sem curlys.

PowerShell v2 +, 96 bytes

param($n)'      \ '*$n--
'  ___/o>'*$n+'  ___/->'
'-(___)" '*$n+',(___)"'
" '' ''  "*$n+' `` ``'

(ab) usa a Write-Outputformatação padrão para incluir uma nova linha entre elementos. Aproveita a concatenação e multiplicação de cordas para construir as cabras linha por linha. O único truque real é a primeira linha $n--a produzir o número correto de orelhas e depois o decréscimo, $npara que fique correta no restante das linhas.

PS C:\Tools\Scripts\golfing>  1..4|%{.\counting-goats-to-sleep.ps1 $_}
      \ 
  ___/->
,(___)"
 `` ``
      \       \ 
  ___/o>  ___/->
-(___)" ,(___)"
 '' ''   `` ``
      \       \       \ 
  ___/o>  ___/o>  ___/->
-(___)" -(___)" ,(___)"
 '' ''   '' ''   `` ``
      \       \       \       \ 
  ___/o>  ___/o>  ___/o>  ___/->
-(___)" -(___)" -(___)" ,(___)"
 '' ''   '' ''   '' ''   `` ``

Ruby, 102 bytes

m=-1+n=gets.to_i
puts'      \ '*n,'  ___/o>'*m+'  ___/->',(?-+a='(___)" ')*m+?,+a," '' ''  "*m+" ``"*2

Python 3. 170 bytes

lambda n:'\n'.join(map(lambda*l:''.join(l),*map(lambda w:(' '*6+'\ ','  ___/'+(w and'o'or'-')+'>',(w and'-'or',')+'(___)" ',w and" '' ''  "or' `` ``  '),range(n)[::-1])))

hmm, aparentemente construir a string sem fazer a manipulação da lista gera um código mais curto

Fórmula IBM / Lotus Notes, 187 174 188 bytes (não competindo)

EDIT Encontrei um espaço que não deveria estar lá e removeu um @Implode desnecessário

188 como eu tinha perdido o fato de que a cauda da cabra adormecida é diferente :-(

B:=@Repeat("      \\  ";a);C:=@Repeat("     /o> ";a-1)+"     /->";D:=@Repeat("  ---    ";a);E:=@Repeat(",(___)\"  ";a);F:=@Repeat(" `` ``   ";a);@Implode(B:C:D:E:F;@NewLine)

Ungolfed:

B:=@Repeat("      \\  ";a);
C:=@Repeat("     /o> ";a-1)+"     /->";
D:=@Repeat("  ---    ";a);
E:=@Repeat("`(___)\"  ";a-1)+",(___)\"  ";
F:=@Repeat(" `` ``   ";a);
@Implode(B:C:D:E:F;@NewLine)

Uso:

Crie um formulário do Notes com dois campos chamados a e g.

a = editável, número, g = computado, texto.

Cole a fórmula acima em ge dê um valor padrão de 0.

Defina a fonte do formulário como Terminal.

Crie um novo documento com o formulário, digite um número em a e pressione F9 para atualizar as cabras.

Amostras:

Não competindo, pois o formato atrapalha quando o número de cabras atinge a largura da página.

Dada uma tela infinitamente ampla que deve vai funcionar para qualquer número de cabras embora . É assim que parece quando a página não é larga o suficiente.

Emacs Lisp, 241 bytes

(defvar s'("     \\""  ___/->"",(___)\""" `` ``"))(defun a()(dotimes(n 4 g)(setf(nth n g)(format"%s%s"(nth n'("     \\  ""  ___/o>""-(___)\" "" '' ''  "))(nth n g)))))(defun g(n)(let((g(copy-seq s)))(mapcar'message(dotimes(i(- n 1)g)(a)))))

"Ligeiramente não-destruído"

(defvar s'("     \\""  ___/->"",(___)\""" `` ``"))
(defun a()(dotimes(n 4 g)(setf(nth n g)(format"%s%s"(nth n'("     \\  ""  ___/o>""-(___)\" "" '' ''  "))(nth n g)))))
(defun g(n)(let((g(copy-seq s)))(mapcar'message(dotimes(i(- n 1)g)(a)))))

onde sestá uma cabra adormecida, aadiciona uma cabra acordada e g(n)é a função de contagem.

Java 8, 236 222 218 173 bytes

n->{String x="\n",a="",b=a,c=a,d=a;for(;n-->0;a+="      \\ ",b+="  ___/"+(n<1?"-":"o")+">",c+=(n<1?",":"-")+"(   )\" ")d+=(n<1?" `` ``":" '' ''")+"  ";return a+x+b+x+c+x+d;}

Explicação:

Experimente online.

n->{                                // Method with integer parameter and String return-type
  String x="\n",                    //  New-line String to reduce bytes
         a="",                      //  Row 1 String, starting empty
         b=a,                       //  Row 2 String, starting empty
         c=a,                       //  Row 3 String, starting empty
         d=a;                       //  Row 4 String, starting empty
  for(;n-->0;                       //  Loop `n` times:
    a+="      \\ ",                 //   Append the horns to row 1
    b+="  ___/"+(n<1?"-":"o")+">",  //   Append the back and head to row 2
    c+=(n<1?",":"-")+"(   )\" ")    //   Append the tail, body, and beard to row 3
    d+=(n<1?" `` ``":" '' ''")+"  ";//   Append the legs to row 4
  return a+x+b+x+c+x+d;}            //  Return the four rows, separated by new-lines

Tela , 58 bytes

>o/___¶ ")___(-∙ \；∔± ''２×∔╶╷×>-/___¶ ")___(,∙ \；∔± ``２×∔＋

Experimente online!

Resposta bastante chata, realmente ... constrói a cabra acordada, repete-a horizontalmente n-1, constrói e adiciona a cabra adormecida, imprime o resultado.