Contando cabras para dormir

36

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.

Pasatiempos de Calvin
fuente
99
Creo que sus "cabras" se parecen más a pájaros enojados de cuatro patas ;-)
Digital Trauma
44
Aww esperaba contar algunas cabras, no al revés
Beta Decay
1
Creo que sé quién cuenta las cabras para dormir
Luis Mendo
77
No creo que puedas contar la cabra para dormir a menos que "bleeeeeeet" te haga sentir sueño: P +1 gran desafío
Downgoat
1
Los psicópatas se duermen contando cabras gritando.
mbomb007

Respuestas:

30

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 
Luis Mendo
fuente
8
Esta es una teoría seria de la cabra;)
Conor O'Brien
17

Python 3.6, 102 bytes

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

Yaay, cuerdas f !

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

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):'')
Hedi
fuente
3
¿Por qué incluir la presentación vertical? El desafío pide una alineación horizontal.
Mego
55
@Mego ¿Qué tiene de malo mostrar cuánto más golfable hubiera sido?
Neil
2
@Neil Porque es completamente tangencial al desafío.
Mego
99
@Mego, creo que es interesante tener en cuenta.
Conor O'Brien
3
@Mego, pensé que podría ser interesante. Edité la publicación para que sea más obvio que la alineación vertical no es una respuesta válida.
Hedi
4

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.

Neil
fuente
No tenía idea de que set/pnfunciona ._.
Conor O'Brien
Los ^personajes escapa.
Krii
@Krii no funciona cuando lo necesito.
Neil
4

Pyke 56 54 bytes

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

Pruébalo aquí!

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

Azul
fuente
3

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.

Neil
fuente
Se puede guardar un byte al cambiar el tipo de cotización en el medio y la concatenación de dos cadenas '+"'' ''"(asume comillas simples están de vuelta garrapatas ya que no tengo idea de cómo conseguir un acento grave en un bloque de código en los comentarios)
pinkfloydx33
@ pinkfloydx33 Pensé que ya lo había intentado, pero luego me di cuenta de que podía agregar esos ticks al final, lo que me ahorra un byte. También para obtener una marca de retroceso en un bloque de código de comentario, simplemente prefijelo con una barra diagonal inversa.
Neil
Puede quitar el punto
howderek
1
@howderek No lo incluí ni f=en el recuento de bytes, solo está ahí para completar.
Neil
3

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!

FedeWar
fuente
55
Casi mal interpretado como GoatScript
Calvin's Hobbies
3

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
Jonathan Allan
fuente
1

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");
Jörg Hülsermann
fuente
1
Estás codificando demasiado limpio, Jörg. Podría jugar golf de 32 bytes en 11 pasos. ¿Quieres pistas?
Tito
Gracias, solo quiero resolver este desafío de alguna manera. A veces es mejor limpiar que una solución incorrecta. Puedes pegar tu camino.
Jörg Hülsermann
Tomé un enfoque diferente; pero si quieres consejos para los tuyos, solo pregunta. 24 bytes en los primeros 5 pasos.
Tito
@ JörgHülsermann Modificar las respuestas de otras personas parece estar muy mal visto en este sitio.
Carcigenicate
@Carcigenicate ¿Quiso decir que debería modificar las respuestas de otras personas o viceversa? Tiendo más a resolver un problema limpio si solo soy interesante como en este caso. Ascii Art normalmente no es mi prioridad
Jörg Hülsermann
1

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;
}
Yurii Blok
fuente
2
Bienvenido a PPCG! Incluya la versión de una línea para que realmente pueda contarla. Siempre puede incluir una versión legible por separado para que las personas no tengan que leer la frase. :)
Martin Ender
Martin, gracias por el enlace. Originalmente medí el tamaño por tamaño de archivo y ahora lo arreglo.
Yurii Blok
Las respuestas deben medirse por el tamaño del archivo. Mi punto era que su código funciona sin los avances de línea, por lo que la respuesta debería incluir esa versión.
Martin Ender
Bien, escribí el tamaño por tamaño de archivo. Acerca de cómo funciona este código: no hay diferencia entre la versión legible y la versión de una línea.
Yurii Blok
No creo que sea válida para que no incluya el #include <string>yo bien using namespace std;o using std::string;en su cuenta de bytes si su función no se puede compilar sin ellos.
hvd
1

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

DLosc
fuente
1

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
Gato de negocios
fuente
1

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.

tigr
fuente
Necesita recibir información n, y se ha perdido el cambio de cola para la cabra dormida (¿también vio la respuesta Py 3.6?).
Jonathan Allan
¡Hola! El cambio de cola está ahí, no estaba seguro de si necesitaba manejar la entrada. Eché un vistazo a la respuesta de Python3.6 después de escribir la mía. Sin embargo, ¿eso recibe información?
tigr
Ah ok Tiene que ser un programa o una función. Se actualizará con una solución peor, por ahora :(
tigr
Sí, función o programa, ¡lo tienes! Puede eliminar el espacio print "...y colocar todo en una línea, usando 1 ;para separar las dos declaraciones. La cola todavía no está en el código de golf que se muestra, pero parece que la has contado, todo eso debería tener 112 bytes .
Jonathan Allan
1

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
kalsowerus
fuente
0

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.

andlrc
fuente
0

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.

Titus
fuente
0

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>  ___/->
-(___)" -(___)" -(___)" ,(___)"
 '' ''   '' ''   '' ''   `` ``
AdmBorkBork
fuente
0

Ruby, 102 bytes

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

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

Jeffrey04
fuente
0

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:

ingrese la descripción de la imagen aquí

ingrese la descripción de la imagen aquí

ingrese la descripción de la imagen aquí

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.

ingrese la descripción de la imagen aquí

ElPedro
fuente
¿Por qué no es competitivo? Cada respuesta es así. Eso se llama envoltura.
mbomb007
Gracias por la aclaración @ mbomb007. Estaba tratando de ser honesto y no faltarle el respeto a los mejores golfistas que yo. Soy nuevo en esto. Ok, compite. No ganará, pero apuesto a que no habrá demasiados golfistas de Lotus Notes para
vencerme
Para ser honesto, apuesto a que no habrá muchos golfistas de Lotus Notes.
ElPedro
0

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.

Lord Yuuma
fuente
0

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
Kevin Cruijssen
fuente
0

Lienzo , 58 bytes.

>o/___¶ ")___(-∙ \;∔± ''2×∔╶╷×>-/___¶ ")___(,∙ \;∔± ``2×∔+

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.

hakr14
fuente