Algunas personas cuentan ovejas para dormir. Otros cuentan cabras.

Escriba un programa o función que tome un entero positivo N y produzca N-1 cabras despiertas seguidas de una cabra dormida, como si alguien estuviera contando N cabras y en el último se durmieron.

Las cabras despiertas se ven así:

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

Las cabras dormidas se ven así:

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

Están encadenados con un solo espacio entre la barba y la cola de las cabras adyacentes:

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

La salida puede tener espacios finales y una nueva línea final.

El código más corto en bytes gana.

Ejemplos

N = 1:

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

N = 2:

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

N = 3:

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

N = 4:

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

Un N más grande debería funcionar igual de bien.

MATL , 56 53 bytes

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

Pruébalo en línea!

Explicación

Cabra despierta

La cabra despierta se puede meter en la cuerda.

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

y desempaquetado como se explicará en breve. Sin embargo, los símbolos de comillas simples tendrían que duplicarse para escapar de ellos, por lo que el literal de cadena tendría que definirse como (tenga en cuenta los símbolos de comillas simples y la duplicación de los originales):

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

Para guardar bytes, definimos la cadena usando caracteres un punto de código por encima de eso, evitando así la duplicación. La cadena literal se convierte en

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

Al final del código restaremos 1 y convertiremos a char. (Podríamos hacerlo ahora, justo después del literal de cadena; pero dejarlo para el final ahorrará otra duplicación de comillas simples, como veremos).

Para explicar cómo se desempaqueta la cadena, trabajaremos con los caracteres originales (que se producen al final del código al sustraer 1), por lo que la explicación es más fácil de seguir. Primero reformamos la cuerda

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

en una matriz de caracteres 2D de 8 filas, en orden de columna mayor (abajo, luego a través). Esto rellena automáticamente la última columna con char 0 (al final del código, restando 1 lo transformará en el número −1, que convertido a char devuelve char 0). Char 0 se muestra como un espacio. Así que efectivamente estamos rellenando con espacios. El resultado de la remodelación es

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

Ahora volteamos verticalmente:

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

y luego transponer y voltear verticalmente de nuevo para producir la cabra despierta:

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

Las dos operaciones de volteo son necesarias porque la cadena empaquetada original está "en reversa". Esto es para explotar el hecho de que la matriz de caracteres 2D real que representa a la cabra tiene 6 espacios iniciales en su primera fila, que se rellenan automáticamente al rellenar cuando la cadena se forma en una matriz 2D de 8 filas. Pero el relleno se realiza al final (no al principio) de la última columna (no fila), por lo tanto, se voltea y se transpone.

Cabra dormida

Una cabra dormir se genera a partir de una cabra despierto por caracteres transliteración o, ', -en -, `, ,respectivamente. En realidad, a causa de la transformación de un código de punto anterior, transliteramos caracteres p, (, 'en ., a,- , que a su vez nos salva de tener que duplicar el símbolo con una comilla simple. Esta es la razón por la cual la operación de restar uno se dejó para el final del programa.

Estructura de código

1. Genere un Ntiempo de cabra despierto , trabajando con puntos de código aumentados en 1.
2. Transforma la última cabra en una cabra dormida.
3. Concatenar todas las cabras horizontalmente. Resta 1 a los puntos de código y lanza a 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, cuerdas f !

            __________________________
           / \
          El | Esta respuesta es baaaaaaad. El |
      \ / ___________________________ /
  ___ / o> '  
- (___) " 
 '' ''  

Javascript, 122 bytes

Responder

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

Nota al margen
En el siguiente código (91 bytes) las cabras están alineadas verticalmente. No cumple con el formato de salida, pero podría ser interesante observar que la alineación horizontal requerida en el formato de salida necesita más 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:]=^>%

Toma información de stdin. Batch tiene problemas con" y >por varias razones, así que tengo que usar marcadores de posición y luego cambiarlos al final.

Pyke 56 54 bytes

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

Pruébalo aquí!

4 bytes demasiado porque Pyke no permite comillas dobles en cadenas :(

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>

Tener que admitir los tres tipos de caracteres de comillas fue molesto, pero afortunadamente el comentario de @ pinkfloydx33 me dio la inspiración de que podía agregar las comillas al final, lo que me ahorró 1 byte.

GolfScript , 91 bytes

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

Entrada: 3

Salida:

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

Explicación

~: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      #

Pruébalo en línea!

Gelatina , 62 56 bytes

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

Pruébelo en TryItOnline

¿Cómo?

⁶ẋ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;
}

Pipa , 60 + 1 = 61 bytes

Un byte agregado para la nbandera.

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

Construye una cabra despierta como una lista de líneas y la tira y. Se multiplican las cuerdas para a-1despertar a las cabras. Reemplaza -o'con,-` eny y lo concatena hasta el final. Impresiones, separadas por nueva línea.

Pruébalo en línea!

(Creo que esta es la primera vez que uso la sintaxis de cadena de escape de Pip \"...\", que permite comillas dobles literales en la cadena).

CJam , 58 bytes

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

Pruébalo en línea!

Explicación

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: definición de función agregada

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

des-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 Python2.7 es un byte más corto que Python3 debido a que no necesita parentesis al imprimir.

05AB1E , 66 bytes

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

Pruébalo en línea!

Explicación

’      \ 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

Corre con:

bash my_pgm.bash N

Básicamente el programa imprime N veces de la misma cabra (invertida), y los sustitutos de la primera -, para ,, la primera opara -y la primera '' ''para los acentos abiertos. Luego invierte las líneas.

PHP, 133 131 bytes

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

Encontré dos bytes para jugar golf lejos de una de las versiones sin rizos.

PowerShell v2 +, 96 bytes

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

(ab) usa el Write-Outputformato predeterminado para incluir una nueva línea entre los elementos. Aprovecha la concatenación y multiplicación de cuerdas para construir las cabras línea por línea. El único truco real es la primera línea $n--para generar el número correcto de oídos y luego la disminución posterior $npara que sea correcta para el resto de las líneas.

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 la cadena sin hacer la manipulación de la lista produce un código más corto

Fórmula IBM / Lotus Notes, 187 174 188 bytes (no compite)

EDITAR Encontró un espacio que no debería haber estado allí y eliminó un @Implode innecesario

188 ya que me había perdido el hecho de que la cola de la cabra dormida es 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)

Sin golf:

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:

Cree un formulario de Notas con dos campos llamados a y g.

a = editable, número, g = calculado, texto.

Pegue la fórmula anterior en g y proporcione un valor predeterminado de 0.

Establezca la fuente del formulario en Terminal.

Cree un nuevo documento con el formulario, ingrese un número en ay presione F9 para actualizar las cabras.

Muestras:

No compite ya que el formato se complica cuando el número de cabras alcanza el ancho de la página.

Dado un infinitamente amplia pantalla que debe funcionará para cualquier número de cabras sin embargo . Esto es lo que parece cuando la página no es lo suficientemente ancha.

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

"Ligeramente no golfista"

(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)))))

donde shay una cabra dormida, aagrega una cabra despierta y g(n)es la función de conteo.

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

Explicación:

Pruébalo en línea.

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

Lienzo , 58 bytes.

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

Pruébalo en línea!

Respuesta bastante aburrida, realmente ... construye la cabra despierta, la repite horizontalmente n-1, construye y agrega la cabra dormida, imprime el resultado.