Alcune persone contano le pecore per addormentarsi. Altri contano le capre.

Scrivi un programma o una funzione che accetta un numero intero positivo N e genera N-1 capre svegli seguite da una capra addormentata, come se qualcuno stesse contando N capre e all'ultima si sono addormentate.

Le capre svegli si presentano così:

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

Le capre addormentate sono così:

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

Sono incatenati insieme con un unico spazio tra barba e coda di capre adiacenti:

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

L'output può contenere spazi finali e una nuova riga finale.

Vince il codice più breve in byte.

Esempi

N = 1:

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

N = 2:

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

N = 3:

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

N = 4:

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

N più grande dovrebbe funzionare altrettanto bene.

MATL , 56 53 byte

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

Provalo online!

Spiegazione

Capra sveglia

La capra sveglia può essere inserita nella corda

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

e spacchettato come verrà spiegato a breve. Tuttavia, i simboli a virgoletta singola dovrebbero essere duplicati per sfuggirli, quindi il valore letterale stringa dovrebbe essere definito come (notare i simboli racchiusi tra virgolette singole e la duplicazione di quelli originali):

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

Per salvare i byte, definiamo la stringa usando caratteri un punto di codice sopra quello, evitando così la duplicazione. La stringa letterale diventa

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

Alla fine del codice sottrarremo 1 e convertiremo in carattere. (Potremmo farlo ora, subito dopo la stringa letterale; ma lasciarla per la fine salverà un'altra duplicazione a virgoletta singola, come vedremo).

Per spiegare come la stringa è spacchettata, lavoreremo con i caratteri originali (che vengono prodotti alla fine del codice sottraendo 1), quindi la spiegazione è più facile da seguire. Per prima cosa rimodelliamo la stringa

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

in un array di caratteri 2D a 8 righe, in ordine di colonna maggiore (verso il basso, quindi attraverso). Questo riempie automaticamente l'ultima colonna con char 0 (alla fine del codice, sottraendo 1 la trasformerà in numero −1, che convertita in char restituisce char 0). Il carattere 0 viene visualizzato come spazio. In modo efficace stiamo riempiendo di spazi. Il risultato del rimodellamento è

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

Ora giriamo verticalmente:

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

e quindi trasporre e capovolgere di nuovo verticalmente per produrre la capra sveglia:

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

Le due operazioni di inversione sono necessarie perché la stringa imballata originale è "al contrario". Questo per sfruttare il fatto che l'attuale array di caratteri 2D che rappresenta la capra ha 6 spazi iniziali nella sua prima riga, che vengono riempiti automaticamente con il riempimento quando la stringa viene rimodellata in un array 2D a 8 righe. Ma il padding viene eseguito alla fine (non all'inizio) dell'ultima colonna (non riga), quindi i lanci e la trasposizione.

Capra addormentata

Una capra a pelo è generato da una capra sveglio caratteri traslitterazione o, ', -in -, `, ,rispettivamente. In realtà, a causa della trasformazione di un codice-punto-sopra, traslitterare caratteri p, (, 'in ., a, -, che ci salva ancora una volta di dover duplicare il simbolo singolo-preventivo. Questo è il motivo per cui l'operazione di sottrazione 1 è stata lasciata per la fine del programma.

Struttura del codice

1. Genera Ntempi di capra svegli , lavorando con punti di codice aumentati di 1.
2. Trasforma l'ultima capra in una capra dormiente.
3. Concatena tutte le capre in orizzontale. Sottrai 1 per codificare i punti e il cast per char.

Codice commentato

:                              % (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 byte

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

Yaay, f-stringhe !

            __________________________
           / \
          | Questa risposta è baaaaaaad. |
      \ / ___________________________ /
  ___ / o> '  
- (___)" 
 '' ''  

Javascript, 122 byte

Risposta

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

Nota a margine
Nel seguente codice (91 byte) le capre sono allineate verticalmente. Non è conforme al formato di output ma, sebbene possa essere interessante notare che l'allineamento orizzontale richiesto nel formato di output richiede più byte:

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

Lotto, 234 byte

@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:]=^>%

Riceve input dallo stdin. Batch ha problemi con "e >per vari motivi, quindi devo usare i segnaposto e poi cambiarli alla fine.

Pyke, 56 54 byte

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

Provalo qui!

4 byte in eccesso perché Pyke non consente le doppie virgolette nelle stringhe :(

JavaScript (ES6), 110 109 byte

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

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

Dover supportare tutti e tre i tipi di personaggi con virgolette è stato fastidioso, ma fortunatamente il commento di @ pinkfloydx33 mi ha dato il lampo di ispirazione che ho potuto aggiungere i backquotes alla fine risparmiando così 1 byte.

GolfScript , 91 byte

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

Ingresso: 3

Produzione:

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

Spiegazione

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

Provalo online!

Gelatina , 62 56 byte

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

Provalo su TryItOnline

Come?

⁶ẋ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 byte

$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 byte

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 byte

Un byte aggiunto per il nflag.

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

Costruisce una capra sveglia come un elenco di righe e la trascina dentro y. String si moltiplica per ottenerea-1 capre sveglie. Sostituisce -o'con ,-`in ye lo concatena fino alla fine. Stampe separate da nuova riga.

Provalo online!

(Penso che questa sia la prima volta che utilizzo la sintassi della stringa con escape di Pip \"...\", che consente letteralmente doppie virgolette nella stringa.)

CJam , 58 byte

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

Provalo online!

Spiegazione

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 byte

Modifica: aggiunta la definizione della funzione

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

de-golfified:

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 è più corto di un byte rispetto a Python3 poiché non necessita di parentesi durante la stampa.

05AB1E , 66 byte

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

Provalo online!

Spiegazione

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

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

Corri con:

bash my_pgm.bash N

Fondamentalmente il programma stampa N volte della stessa capra (invertita) e sostituisce il primo -con ,il primo ocon -il primo '' ''con il backtick. Quindi inverte le linee.

PHP, 133 131 byte

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

Ho trovato due byte per giocare a golf lontano da una versione senza curly.

PowerShell v2 +, 96 byte

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

(ab) utilizza la Write-Outputformattazione predefinita per includere una nuova riga tra gli elementi. Sfrutta la concatenazione e la moltiplicazione delle stringhe per costruire le capre riga per riga. L'unico vero trucco è la prima riga $n--per generare il numero corretto di orecchie e quindi post-decremento, $nquindi è corretta per il resto delle linee.

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

Rubino, 102 byte

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

Python 3. 170 byte

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, apparentemente costruendo la stringa senza fare manipolazione di lista si ottiene un codice più breve

Formula IBM / Lotus Notes, 187 174 188 byte (non in competizione)

MODIFICARE Trovato uno spazio che non avrebbe dovuto essere lì e rimosso un @Implode non necessario

188 come avevo perso il fatto che la coda della capra addormentata è diversa :-(

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:

Creare un modulo Note con due campi denominati a e g.

a = modificabile, numero, g = calcolato, testo.

Incolla la formula sopra in g e assegna un valore predefinito di 0.

Impostare il carattere del modulo su Terminale.

Crea un nuovo documento con il modulo, inserisci un numero in a e premi F9 per aggiornare le capre.

Campioni:

Non competere poiché il formato incasina quando il numero di capre raggiunge la larghezza della pagina.

Dato uno schermo infinitamente vasta che dovrebbe funziona per qualsiasi numero di capre però . Questo è come appare quando la pagina non è abbastanza ampia.

Emacs Lisp, 241 byte

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

"Leggermente ungolfed"

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

dove sc'è una capra che dorme, aaggiunge una capra sveglia ed g(n)è la funzione di conteggio.

Java 8, 236 222 218 173 byte

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

Spiegazione:

Provalo 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 byte

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

Provalo online!

Risposta piuttosto noiosa, davvero ... costruisce la capra sveglia, la ripete in senso orizzontale n-1volte, costruisce e aggiunge la capra addormentata, stampa il risultato.