Manche Menschen zählen Schafe, um einzuschlafen. Andere zählen Ziegen.

Schreiben Sie ein Programm oder eine Funktion, die eine positive ganze Zahl N aufnimmt und N-1 wache Ziegen gefolgt von einer schlafenden Ziege ausgibt, als würde jemand N Ziegen zählen und beim letzten Mal sind sie eingeschlafen.

Wachziegen sehen so aus:

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

Schlafende Ziegen sehen so aus:

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

Sie sind mit einem einzigen Zwischenraum zwischen Bart und Schwanz benachbarter Ziegen verkettet:

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

Die Ausgabe darf abschließende Leerzeichen und eine einzelne abschließende Newline enthalten.

Der kürzeste Code in Bytes gewinnt.

Beispiele

N = 1:

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

N = 2:

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

N = 3:

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

N = 4:

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

Größere N sollten genauso gut funktionieren.

MATL , 56 53 Bytes

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

Probieren Sie es online!

Erläuterung

Wach auf, Ziege

Die wache Ziege kann in die Schnur gepackt werden

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

und ausgepackt, wie noch erläutert wird. Die Symbole mit einfachen Anführungszeichen müssten jedoch dupliziert werden, um sie zu umgehen. Daher müsste das Zeichenfolgenliteral definiert werden als (beachten Sie die einschließenden Symbole mit einfachen Anführungszeichen und die Duplizierung der ursprünglichen Symbole):

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

Um Bytes zu sparen, definieren wir die Zeichenfolge mit Zeichen, die einen Codepunkt darüber liegen , um Doppelungen zu vermeiden. Das String-Literal wird

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

Am Ende des Codes werden wir 1 subtrahieren und in char konvertieren. (Wir könnten es jetzt tun, direkt nach dem String-Literal; aber wenn wir es für das Ende belassen, sparen wir eine weitere Duplikation mit einfachen Anführungszeichen, wie wir sehen werden.)

Um zu erklären, wie die Zeichenfolge entpackt wird, arbeiten wir mit den Originalzeichen (die am Ende des Codes durch Untertakten von 1 erzeugt werden), damit die Erklärung leichter zu befolgen ist. Wir formen zuerst die Saite um

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

in ein 8-zeiliges 2D-Zeichen-Array in Spalten-Hauptreihenfolge (nach unten, dann quer). Dadurch wird die letzte Spalte automatisch mit char 0 aufgefüllt (am Ende des Codes wird 1 durch Subtrahieren in die Zahl −1 umgewandelt, was wiederum char 0 ergibt). Char 0 wird als Leerzeichen angezeigt. So effektiv füllen wir uns mit Leerzeichen. Das Ergebnis der Umformung ist

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

Wir kippen jetzt vertikal:

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

und dann transponieren und wieder vertikal drehen, um die wache Ziege zu produzieren:

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

Die beiden Flip-Operationen sind erforderlich, da die ursprüngliche gepackte Zeichenfolge "in umgekehrter Reihenfolge" vorliegt. Dies dient dazu, die Tatsache auszunutzen, dass das tatsächliche 2D-Zeichen-Array, das die Ziege darstellt, in seiner ersten Zeile 6 Anfangsräume aufweist, die automatisch durch Auffüllen gefüllt werden, wenn die Zeichenfolge in ein 8-zeiliges 2D-Array umgewandelt wird. Das Auffüllen erfolgt jedoch am Ende (nicht am Anfang) der letzten Spalte (nicht der Zeile), daher das Umdrehen und Transponieren.

Schlafende Ziege

Ein schlafender Ziege ist aus einer Wach Ziege durch Transliteration Zeichen erzeugt o, ', -in -, `, ,bzw.. Aufgrund der Ein-Code-Punkt-Über-Transformation transliterieren wir Zeichen in " ," , " ," p, " (," , " ," , " ," , " ," , " ," , " ," , " ," , " ," , " ," , " ," , "." Aus diesem Grund wurde die Subtraktionsoperation für das Ende des Programms belassen.'.a-

Code-Struktur

1. Generiere eine Wachziege Nund arbeite mit um 1 erhöhten Codepunkten.
2. Verwandle die letzte Ziege in eine schlafende Ziege.
3. Verketten Sie alle Ziegen horizontal. Subtrahiere 1, um Punkte zu codieren und wirke zu char.

Kommentierter Code

:                              % (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} `` ``'''

Ja, F-Saiten !

            __________________________
           / \
          | Diese Antwort ist baaaaaaad. |
      \ / ___________________________ /
  ___ / o> '  
- (___) " 
 '' ''  

Javascript, 122 Bytes

Antworten

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

Randnotiz
Im folgenden Code (91 Bytes) sind die Ziegen vertikal ausgerichtet. Es entspricht nicht dem Ausgabeformat, aber es könnte interessant sein, festzustellen, dass die im Ausgabeformat erforderliche horizontale Ausrichtung mehr Bytes benötigt:

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

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

Übernimmt die Eingabe von stdin. Batch hat Probleme mit "und >aus verschiedenen Gründen, daher muss ich Platzhalter verwenden und sie am Ende austauschen.

Pyke, 56 54 Bytes

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

Probieren Sie es hier aus!

4 Bytes zu viel, weil Pyke keine doppelten Anführungszeichen in Strings zulässt :(

JavaScript (ES6), 110 bis 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>

Die Unterstützung aller drei Arten von Anführungszeichen war ärgerlich, aber zum Glück ließ mich der Kommentar von @ pinkfloydx33 inspirieren, dass ich die Anführungszeichen am Ende hinzufügen und so 1 Byte sparen konnte.

GolfScript , 91 Bytes

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

Eingang: 3

Ausgabe:

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

Erläuterung

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

Probieren Sie es online!

Jelly , 62 56 Bytes

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

Testen Sie es bei TryItOnline

Wie?

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

Ein Byte für das nFlag hinzugefügt .

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

Konstruiert eine wache Ziege als eine Liste von Linien und reißt sie hinein y. String-Multiplikatoren, um a-1Ziegen zu wecken. Ersetzt -o'durch ,-`in yund verkettet es bis zum Ende. Ausdrucke, durch Zeilenvorschub getrennt.

Probieren Sie es online!

(Ich denke, dies ist das erste Mal, dass ich Pip 'Escape-String-Syntax verwende \"...\", die wörtliche doppelte Anführungszeichen in der Zeichenfolge zulässt.)

CJam , 58 Bytes

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

Probieren Sie es online!

Erläuterung

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

Bearbeiten: Funktionsdefinition hinzugefügt

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

entschärft:

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

Hinweis Python2.7 ist ein Byte kürzer als Python3, da beim Drucken keine Klammerung erforderlich ist.

05AB1E , 66 Bytes

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

Probieren Sie es online!

Erläuterung

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

Laufen mit:

bash my_pgm.bash N

Grundsätzlich gibt das Programm N - mal die gleichen Ziege (umgekehrt), und ersetzt die erste -, für ,die erste ofür -und die erste '' ''für die Backticks. Dann kehrt man die Zeilen um.

PHP, 133 131 Bytes

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

Ich fand zwei Bytes zum Golfen entfernt von einer der Versionen ohne Curlys.

PowerShell v2 +, 96 Byte

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

(ab) verwendet die Standardformatierung Write-Output, um eine neue Zeile zwischen Elementen einzufügen. Nutzt die Verkettung und Multiplikation von Zeichenfolgen, um die Ziegen zeilenweise zu konstruieren. Der einzige wirkliche Trick ist, dass die erste Zeile $n--die richtige Anzahl von Ohren ausgibt und diese dann nachträglich dekrementiert, $ndamit sie für den Rest der Zeilen korrekt ist.

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, anscheinend ergibt das Konstruieren der Zeichenkette ohne Listenmanipulation einen kürzeren Code

IBM / Lotus Notes Formula, 187 174 188 Bytes (nicht konkurrierend)

BEARBEITEN Sie haben einen Bereich gefunden, der nicht vorhanden sein sollte, und haben einen nicht benötigten @Implode entfernt

188 da ich die Tatsache verpasst hatte, dass der Schwanz der schlafenden Ziege anders ist :-(

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)

Verwendung:

Erstellen Sie ein Notes-Formular mit zwei Feldern mit den Namen a und g.

a = editierbar, Nummer, g = berechnet, Text.

Fügen Sie die obige Formel in g ein und geben Sie einen Standardwert von 0 an.

Setzen Sie die Formularschriftart auf Terminal.

Erstellen Sie ein neues Dokument mit dem Formular, geben Sie eine Nummer in a ein und drücken Sie F9, um die Ziegen zu aktualisieren.

Proben:

Nicht konkurrieren, da das Format durcheinander kommt, wenn die Anzahl der Ziegen die Breite der Seite erreicht.

Einen unendlich breiten Bildschirm gegeben es sollte für eine beliebige Anzahl von Ziegen funktioniert allerdings . So sieht es aus, wenn die Seite nicht breit genug ist.

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

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

Wo sist eine schlafende Ziege, afügt eine wache Ziege hinzu und g(n)ist die Zählfunktion.

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

Erläuterung:

Probieren Sie es online aus.

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

Canvas , 58 Byte

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

Probieren Sie es online!

Ziemlich langweilige Antwort, wirklich ... baut die Wachziege, wiederholt sie horizontal n-1, baut und fügt die schlafende Ziege hinzu, druckt das Ergebnis.