Ziegen zählen, um zu schlafen

36

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.

Calvins Hobbys
quelle
9
Ich denke, Ihre "Ziegen" sehen eher aus wie vierfüßige böse Vögel ;-)
Digital Trauma
4
Oh, ich hatte gehofft, ein paar Ziegen zu zählen, nicht umgekehrt
Beta-Zerfall
1
Ich glaube, ich weiß, wer Ziegen zum Schlafen zählt
Luis Mendo
7
Ich glaube nicht, dass man Ziegen in den Schlaf zählen kann, es sei denn, "bleeeeeeet" macht schläfrig: P +1 große Herausforderung
Downgoat
1
Psychopathen schlafen ein, indem sie schreiende Ziegen zählen.
mbomb007

Antworten:

30

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 
Luis Mendo
quelle
8
Dies ist eine ernsthafte Ziege Theorie;)
Conor O'Brien
17

Python 3.6, 102 Bytes

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

Ja, F-Saiten !

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

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):'')
Hedi
quelle
3
Warum sollte die vertikale Einreichung berücksichtigt werden? Die Herausforderung erfordert eine horizontale Ausrichtung.
Mego
5
@Mego Was ist falsch daran zu zeigen, wie viel mehr Golf es gewesen wäre?
Neil
2
@Neil Weil es für die Herausforderung völlig tangential ist.
Mego
9
@Mego Ich finde es interessant zu bemerken.
Conor O'Brien
3
@Mego Ich dachte, es könnte interessant sein. Ich habe den Beitrag bearbeitet, um zu verdeutlichen, dass die vertikale Ausrichtung keine gültige Antwort ist.
Hedi
4

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.

Neil
quelle
Ich hatte keine set/pnahnung werke ._.
Conor O'Brien
Die ^Fluchtzeichen.
Krii
@Krii Funktioniert nicht, wenn ich es brauche.
Neil
4

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

Blau
quelle
3

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.

Neil
quelle
Können Sie ein Byte durch Umschalten der Kursart in der Mitte und verketten zwei Strings speichern '+"'' ''"(nehmen einfache Anführungszeichen sind Zecken zurück , da ich keine Ahnung , wie haben in den Kommentaren ein Graviszeichen in einen Code - Block zu erhalten)
pinkfloydx33
@ pinkfloydx33 Ich dachte, ich hätte das schon versucht, aber dann wurde mir klar, dass ich diese Back Ticks am Ende hinzufügen könnte, was mir ein Byte erspart. Um einen Back-Tick in einem Kommentar-Code-Block zu erhalten, muss ihm lediglich ein Backslash vorangestellt werden.
Neil
Sie können das Semikolon
howderek
1
@howderek Ich habe es oder das f=in meiner Byteanzahl nicht eingeschlossen , es ist nur der Vollständigkeit halber da.
Neil
3

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!

FedeWar
quelle
5
Fast falsch verstanden als GoatScript
Calvins Hobbys
3

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
Jonathan Allan
quelle
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
quelle
1
Du codierst viel zu sauber, Jörg. Davon konnte ich 32 Bytes in 11 Schritten abschlagen. Willst du Tipps?
Titus
Danke, ich möchte diese Herausforderung nur auf irgendeine Weise lösen. Manchmal ist sauber besser als eine falsche Lösung. Sie können Ihren Weg einfügen.
Jörg Hülsermann
Ich habe einen anderen Ansatz gewählt; Aber wenn Sie Tipps für Ihre möchten, fragen Sie einfach. 24 Bytes in den ersten 5 Schritten.
Titus
@ JörgHülsermann Das Modifizieren der Antworten anderer Leute scheint auf dieser Seite sehr verpönt zu sein.
Carcigenicate
@Carcigenicate Meinten Sie, ich sollte Antworten von anderen Personen oder umgekehrt ändern? Ich neige eher dazu, ein Problem sauber zu lösen, wenn ich nur so interessant bin wie in diesem Fall. ASCII-Kunst ist normalerweise nicht meine Priorität
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
quelle
2
Willkommen bei PPCG! Bitte geben Sie die einzeilige Version an, damit Sie sie tatsächlich zählen können. Sie können jederzeit eine lesbare Version separat einbinden, damit die Leser den Einzeiler nicht lesen müssen. :)
Martin Ender
Martin, danke für den Link. Ich habe die Größe ursprünglich anhand der Dateigröße gemessen und jetzt korrigiere ich sie.
Yurii Blok
Antworten sollten in der Tat anhand der Dateigröße gemessen werden. Mein Punkt war, dass Ihr Code ohne die Zeilenvorschübe funktioniert, daher sollte die Antwort diese Version enthalten.
Martin Ender
Okay, ich habe die Größe nach Dateigröße geschrieben. Wie dieser Code funktioniert - es gibt keinen Unterschied zwischen einer lesbaren und einer einzeiligen Version.
Yurii Blok
Ich denke nicht, dass es gültig ist, das #include <string>und entweder using namespace std;oder using std::string;in Ihrer Byteanzahl nicht einzuschließen, wenn Ihre Funktion nicht ohne sie kompiliert werden kann.
HDV
1

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

DLosc
quelle
1

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
Geschäfts-Katze
quelle
1

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.

tigr
quelle
nSie müssen Eingaben erhalten und haben den Schwanzwechsel für die schlafende Ziege verpasst (haben Sie auch die Py 3.6-Antwort gesehen?).
Jonathan Allan
Hallo! Der Schwanzwechsel ist da, ich war mir nicht sicher, ob du mit Eingaben umgehen musstest. Schauen Sie sich die Python3.6-Antwort an, nachdem Sie meine eigene geschrieben haben. Erhält es aber Eingaben?
Tigr
Ach ja ok Es muss entweder ein Programm oder eine Funktion sein. Wird mit schlechterer Lösung aktualisiert,
vorerst
Ja, Funktion oder Programm, Sie haben es verstanden! Sie können das Leerzeichen entfernen print "...und alles in eine Zeile setzen, indem Sie ;die beiden Anweisungen durch eine 1 trennen. Das Heck ist immer noch nicht in dem angezeigten Code enthalten, aber es sieht so aus, als hätten Sie es gezählt. Das alles sollte 112 Bytes ergeben .
Jonathan Allan
1

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
kalsowerus
quelle
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

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.

undlrc
quelle
0

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.

Titus
quelle
0

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

Ruby, 102 Bytes

m=-1+n=gets.to_i
puts'      \ '*n,'  ___/o>'*m+'  ___/->',(?-+a='(___)" ')*m+?,+a," '' ''  "*m+" ``"*2
cia_rana
quelle
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, anscheinend ergibt das Konstruieren der Zeichenkette ohne Listenmanipulation einen kürzeren Code

Jeffrey04
quelle
0

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:

Bildbeschreibung hier eingeben

Bildbeschreibung hier eingeben

Bildbeschreibung hier eingeben

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.

Bildbeschreibung hier eingeben

ElPedro
quelle
Warum ist es nicht konkurrierend? Jede Antwort ist so. Das nennt man Wickeln.
mbomb007
Danke für die Klarstellung @ mbomb007. Ich habe versucht, ehrlich zu sein und keine besseren Golfer als mich zu missachten. Ich bin neu in diesem Bereich. Ok, es konkurriert. Es wird nicht gewinnen, aber ich wette, es wird nicht zu viele Lotus Notes-Golfer geben, die mich mit der Formel-Sprache schlagen können ☺
ElPedro
Um ehrlich zu sein, ich wette, es wird nicht zu viele Lotus Notes-Golfer geben.
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)))))

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

Lord Yuuma
quelle
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;}

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

Canvas , 58 Byte

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

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.

hakr14
quelle