Certaines personnes comptent des moutons pour s'endormir. Les autres comptent les chèvres.

Ecrivez un programme ou une fonction qui prend un nombre entier positif N et génère N-1 chèvres éveillées suivies d'une chèvre endormie, comme si quelqu'un comptait N chèvres et s'est endormi au dernier moment.

Les chèvres éveillées ressemblent à ceci:

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

Les chèvres endormies ressemblent à ceci:

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

Ils sont enchaînés avec un seul espace entre la barbe et la queue des chèvres adjacentes:

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

La sortie est autorisée à avoir des espaces de fin et un seul nouveau trait de fin.

Le code le plus court en octets gagne.

Exemples

N = 1:

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

N = 2:

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

N = 3:

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

N = 4:

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

Un plus grand N devrait aussi bien fonctionner.

MATL , 56 53 octets

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

Essayez-le en ligne!

Explication

Éveiller la chèvre

La chèvre éveillée peut être emballée dans la ficelle

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

et déballé comme cela sera expliqué sous peu. Toutefois, les symboles entre guillemets devraient être dupliqués pour pouvoir y échapper. Le littéral chaîne doit donc être défini comme suit (notez les symboles entre guillemets et la duplication des symboles originaux):

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

Pour sauvegarder des octets, nous définissons la chaîne à l'aide de caractères un point de code au - dessus , évitant ainsi les doublons. Le littéral de chaîne devient

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

À la fin du code, nous allons soustraire 1 et convertir en caractères. (Nous pourrions le faire maintenant, juste après le littéral chaîne; mais le laisser à la fin sauvera une autre duplication entre guillemets, comme nous le verrons).

Pour expliquer comment la chaîne est décompactée, nous allons travailler avec les caractères originaux (produits à la fin du code en sous-traitant 1), ainsi l'explication est plus facile à suivre. Nous remodelons d'abord la ficelle

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

dans un tableau de caractères 2D à 8 lignes, dans l'ordre des colonnes (bas, puis à travers). Ceci remplit automatiquement la dernière colonne avec le caractère 0 (à la fin du code, soustraire 1 le transformera en nombre -1, ce qui converti en caractère donnera à nouveau le caractère 0). Char 0 est affiché comme un espace. Donc, effectivement, nous remplissons d'espaces. Le résultat du remodelage est

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

Nous retournons maintenant verticalement:

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

puis transposez et retournez verticalement pour produire le bouc éveillé:

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

Les deux opérations de retournement sont nécessaires car la chaîne compressée d'origine est "en sens inverse". Cela tient compte du fait que le tableau de caractères 2D représentant la chèvre a 6 espaces initiaux dans sa première ligne, qui sont automatiquement remplis par un remplissage lorsque la chaîne est remodelée dans un tableau 2D à 8 lignes. Mais le remplissage est fait à la fin (pas au début) de la dernière colonne (pas à la ligne), d’où les retournements et la transposition.

Chèvre endormie

Une chèvre de couchage est généré à partir d' une chèvre éveillé par les caractères translittération o, ', -en -, `, ,respectivement. En fait, à cause de l'un code point ci - dessus transformation, nous Translittérer caractères p, (, 'en ., a,- , qui encore une fois nous évite d'avoir à dupliquer le symbole guillemet simple. C’est pourquoi l’opération soustraction 1 a été laissée à la fin du programme.

Structure du code

1. Générer une chèvre éveillée N , en travaillant avec des points de code augmentés de 1.
2. Transformez la dernière chèvre en une chèvre endormie.
3. Concaténer toutes les chèvres horizontalement. Soustrayez 1 aux points de code et transformez-les en caractères.

Code commenté

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

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

Yaay, cordes f !

            __________________________
           / \
          | Cette réponse est baaaaaaad. |
      \ / ___________________________ /
  ___ / o> '  
- (___) " 
 '' ''  

Javascript, 122 octets

Répondre

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

Note latérale
Dans le code suivant (91 octets), les chèvres sont alignées verticalement. Il ne se conforme pas au format de sortie, mais j’estime intéressant de noter que l’alignement horizontal requis dans le format de sortie nécessite davantage d’octets:

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

Lot, 234 octets

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

Prend la contribution de stdin. Batch a des problèmes avec "et >pour diverses raisons, je dois donc utiliser des espaces réservés, puis les permuter à la fin.

Pyke, 56 54 octets

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

Essayez-le ici!

4 octets de trop parce que Pyke n'autorise pas les guillemets doubles dans les chaînes :(

JavaScript (ES6), 110 109 octets

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

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

Avoir à supporter les trois types de citation était ennuyeux, mais heureusement, le commentaire de @ pinkfloydx33 m'a donné l'inspiration que je pouvais ajouter les guillemets arrières à la fin, ce qui me permettait de gagner un octet.

GolfScript , 91 octets

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

Contribution: 3

Sortie:

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

Explication

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

Essayez-le en ligne!

Gelée , 62 56 octets

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

Testez-le sur TryItOnline

Comment?

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

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

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 octets

Un octet ajouté pour le ndrapeau.

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

Construit une chèvre éveillée sous forme de liste de lignes et la glisse dans y. Les cordes se multiplient pour obtenir des a-1chèvres éveillées. Remplace -o'par ,-`in yet le concatène jusqu'au bout. Impressions, séparées par une nouvelle ligne.

Essayez-le en ligne!

(Je pense que c'est la première fois que j'utilise la syntaxe de chaîne échappée de Pip \"...\", qui autorise des guillemets doubles dans la chaîne.)

CJam , 58 octets

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

Essayez-le en ligne!

Explication

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 octets

Edit: Ajout de la définition de la fonction

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

dé-golfifié:

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

Remarque Python2.7 est un octet plus court que Python3 car il n'a pas besoin de parentesis lors de l'impression.

05AB1E , 66 octets

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

Essayez-le en ligne!

Explication

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

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

Courir avec:

bash my_pgm.bash N

Fondamentalement , le programme imprime N fois de la même chèvre (inversé), et substitue le premier -, pour ,la première opour -et le premier '' ''pour les accents graves. Puis inverse les lignes.

PHP, 133 131 octets

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

J'ai trouvé deux octets pour jouer au golf loin de l'une des versions sans curlys.

PowerShell v2 +, 96 octets

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

(ab) utilise la Write-Outputmise en forme par défaut pour inclure une nouvelle ligne entre les éléments. Utilise la concaténation et la multiplication de chaînes pour construire les chèvres ligne par ligne. La seule astuce réelle est la première ligne $n--pour afficher le nombre correct d'épis, puis une post-décrémentation, de $nsorte qu'elle soit correcte pour le reste des lignes.

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

Ruby, 102 octets

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

Python 3. 170 octets

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, apparemment, la construction de la chaîne sans faire de manipulation de liste donne un code plus court

Formule IBM / Lotus Notes, 187 174 188 octets (sans concurrence)

MODIFIER Trouver un espace qui n’aurait pas dû être là et supprimer un @Implode inutile.

188 car j'avais manqué le fait que la queue de la chèvre endormie est différente :-(

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)

Usage:

Créez un formulaire Notes avec deux champs nommés a et g.

a = éditable, nombre, g = calculé, texte.

Collez la formule ci-dessus dans g et donnez une valeur par défaut de 0.

Définissez la police de formulaire sur Terminal.

Créez un nouveau document avec le formulaire, entrez un nombre et appuyez sur F9 pour mettre à jour les chèvres.

Échantillons:

Pas de concurrence car le format se gâte lorsque le nombre de chèvres atteint la largeur de la page.

Compte tenu d' un écran infiniment large , il devrait travaillera pour un certain nombre de chèvres quoique . Voici à quoi cela ressemble quand la page n'est pas assez large.

Emacs Lisp, 241 octets

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

"Légèrement non-golfé"

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

où sest une chèvre endormie, aajoute une chèvre éveillée et g(n)est la fonction de comptage.

Java 8, 236 222 218 173 octets

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

Explication:

Essayez-le en ligne.

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

Toile , 58 octets

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

Essayez-le en ligne!

C'est une réponse plutôt ennuyeuse, vraiment ... construit la chèvre éveillée, la répète horizontalement n-1, construit et ajoute la chèvre endormie, affiche le résultat.