Niektórzy liczą owce, aby zasnąć. Inni liczą kozy.

Napisz program lub funkcję, która przyjmuje dodatnią liczbę całkowitą N i wysyła N-1 przebudzonych kóz, a następnie jedną śpiącą kozę, tak jakby ktoś liczył N kóz, a na ostatniej zasnął.

Przebudźcie się kozy wyglądają tak:

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

Śpiące kozy wyglądają tak:

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

Są one połączone łańcuchem z pojedynczym odstępem między brodą a ogonem sąsiednich kóz:

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

Dane wyjściowe mogą mieć końcowe spacje i jedną końcową nową linię.

Najkrótszy kod w bajtach wygrywa.

Przykłady

N = 1:

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

N = 2:

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

N = 3:

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

N = 4:

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

Większy N powinien równie dobrze działać.

MATL , 56 53 bajtów

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

Wypróbuj online!

Wyjaśnienie

Przebudźcie się koza

Przebudzoną kozę można zapakować w sznurek

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

i rozpakowane, co zostanie wkrótce wyjaśnione. Jednak symbole pojedynczego cudzysłowu musiałyby zostać zduplikowane , aby je uniknąć, więc literał ciąg musiałby zostać zdefiniowany jako (zwróć uwagę na otaczające symbole pojedynczego cudzysłowu i powielenie oryginalnych):

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

Aby zapisać bajty, definiujemy ciąg za pomocą znaków o jeden punkt kodowy powyżej , unikając w ten sposób powielania. Literał łańcuchowy staje się

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

Na końcu kodu odejmiemy 1 i przekonwertujemy na char. (Moglibyśmy to zrobić teraz, zaraz po literałach ciągu; ale pozostawienie go na koniec uratuje kolejne powielanie pojedynczych cudzysłowów, jak zobaczymy).

Aby wyjaśnić, w jaki sposób ciąg jest rozpakowywany, będziemy pracować z oryginalnymi znakami (które są tworzone na końcu kodu przez odjęcie 1), więc wyjaśnienie jest łatwiejsze do naśladowania. Najpierw przekształcamy ciąg

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

w 8-rzędową tablicę znaków 2D, w porządku według kolumny (w dół, potem w poprzek). To automatycznie uzupełnia ostatnią kolumnę char 0 (na końcu kodu odejmowanie 1 przekształci ją w liczbę -1, co po konwersji na char daje ponownie char 0). Char 0 jest wyświetlany jako spacja. Tak skutecznie wypełniamy spacjami. Rezultatem przekształcenia jest

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

Teraz odwracamy w pionie:

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

a następnie transponuj i ponownie obróć w pionie, aby obudzić kozę:

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

Dwie operacje odwracania są potrzebne, ponieważ oryginalny spakowany ciąg znaków jest „odwrócony”. Ma to na celu wykorzystanie faktu, że rzeczywista tablica znaków 2D reprezentująca kozę ma 6 początkowych spacji w pierwszym rzędzie, które są automatycznie wypełniane przez wypełnienie, gdy łańcuch jest przekształcany w 8-rzędową tablicę 2D. Ale wypełnianie odbywa się na końcu (nie na początku) ostatniej kolumny (nie w wierszu), stąd odwrócenie i transpozycja.

Śpiąca koza

Śpiąca koza jest generowany z obudzić kozła przez transliteracji znaków o, ', -na -, `, ,odpowiednio. W rzeczywistości, ze względu na transformację jednego kodu punktowego powyżej, transliteracji znaków p, (, 'na ., a, -, który ponownie ratuje nas od konieczności powielania symbolu apostrofu. Dlatego na końcu programu pozostawiono operację odejmowania-jeden.

Struktura kodu

1. Generuj Nczasy przebudzenia kozy , pracując z punktami kodowymi zwiększonymi o 1.
2. Przekształć ostatnią kozę w śpiącą kozę.
3. Połącz wszystkie kozy poziomo. Odejmij 1 od punktów kodowych i rzutuj na char.

Skomentowany kod

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

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

Tak, f-stringi !

            __________________________
           / \
          | Ta odpowiedź to baaaaaaad. |
      \ / ___________________________ /
  ___ / o> ”  
- (___) ” 
 '' '  

JavaScript, 122 bajty

Odpowiedź

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

Uwaga dodatkowa
W poniższym kodzie (91 bajtów) kozy są ustawione pionowo. Nie jest on zgodny z formatem wyjściowym, ale może warto zauważyć, że wyrównanie w poziomie wymagane w formacie wyjściowym wymaga więcej bajtów:

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

Partia, 234 bajty

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

Pobiera dane wejściowe ze standardowego wejścia. Batch ma problemy z "iz >różnych powodów, więc muszę użyć symboli zastępczych, a następnie zmienić je na końcu.

Pyke, 56 54 bajtów

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

Wypróbuj tutaj!

4 bajty za dużo, ponieważ Pyke nie dopuszcza podwójnych cudzysłowów w ciągach :(

JavaScript (ES6), 110 109 bajtów

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

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

Konieczność obsługi wszystkich trzech rodzajów znaków cytowania była irytująca, ale na szczęście komentarz @ pinkfloydx33 dał mi błysk inspiracji, że mogłem dodać cudzysłowy na końcu, oszczędzając w ten sposób 1 bajt.

GolfScript , 91 bajtów

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

Wkład: 3

Wydajność:

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

Wyjaśnienie

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

Wypróbuj online!

Galaretka , 62 56 bajtów

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

Przetestuj w TryItOnline

W jaki sposób?

⁶ẋ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 bajtów

$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 bajtów

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

Pypeć , 60 + 1 = 61 bajtów

Dodano jeden bajt dla nflagi.

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

Konstruuje obudzoną kozę jako listę linii i wciąga ją y. Sznurek mnoży, aby a-1obudzić kozy. Zastępuje -o'z ,-`INy i Łączy go do końca. Wydruki, oddzielone znakiem nowej linii.

Wypróbuj online!

(Wydaje mi się, że po raz pierwszy używam składni Pip-a \"...\", która pozwala na dosłowne podwójne cudzysłowy w ciągu).

CJam , 58 bajtów

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

Wypróbuj online!

Wyjaśnienie

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 bajtów

Edycja: Dodano definicję funkcji

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

od golfa:

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

Uwaga: Python2.7 jest o jeden bajt krótszy niż Python3, ponieważ nie wymaga nawiasów podczas drukowania.

05AB1E , 66 bajtów

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

Wypróbuj online!

Wyjaśnienie

’      \ 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 bajtów

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

Biegnij z:

bash my_pgm.bash N

Zasadniczo drukuje programu N razy tego samego kozła (odwrócone) i substytuty pierwsi -, dla ,, pierwszy ona -i pierwszy '' ''dla backticks. Następnie odwraca linie.

PHP, 133 131 bajtów

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

Znalazłem dwa bajty do gry w golfa z dala od jednej wersji bez kręconych.

PowerShell v2 +, 96 bajtów

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

(ab) używa domyślnego Write-Outputformatowania, aby uwzględnić nową linię między elementami. Wykorzystuje konkatenację i mnożenie łańcucha w celu konstruowania kóz linia po linii. Jedyną sztuczką jest pierwsza linia, $n--która wypisuje prawidłową liczbę uszu, a następnie dekrementacja, $nwięc jest poprawna dla pozostałych linii.

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

Rubin, 102 bajty

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

Python 3. 170 bajtów

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, najwyraźniej konstruowanie łańcucha bez manipulowania listą daje krótszy kod

Formuła IBM / Lotus Notes, 187 174 188 bajtów (nie konkuruje)

EDYCJA Znaleziono miejsce, które nie powinno tam być i usunęło niepotrzebne @Implode

188, ponieważ przeoczyłem fakt, że ogon śpiącej kozy jest inny :-(

B:=@Repeat("      \\  ";a);C:=@Repeat("     /o> ";a-1)+"     /->";D:=@Repeat("  ---    ";a);E:=@Repeat(",(___)\"  ";a);F:=@Repeat(" `` ``   ";a);@Implode(B:C:D:E:F;@NewLine)

Nie golfowany:

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)

Stosowanie:

Utwórz formularz Notatki z dwoma polami o nazwach ai g.

a = edytowalny, liczba, g = obliczony, tekst.

Wklej powyższą formułę do g i ustaw domyślną wartość 0.

Ustaw czcionkę formularza na Terminal.

Utwórz nowy dokument za pomocą formularza, wprowadź cyfrę ai naciśnij F9, aby zaktualizować kozy.

Próbki:

Nie konkuruje, ponieważ format zepsuje się, gdy liczba kóz osiągnie szerokość strony.

Biorąc nieskończenie szeroki ekran to powinno będą pracować dla dowolnej liczby kóz though . Tak to wygląda, gdy strona nie jest wystarczająco szeroka.

Emacs Lisp, 241 bajtów

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

„Nieco golfa”

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

gdzie sjest jedna śpiąca koza, adodaje obudzoną kozę i g(n)jest funkcją liczenia.

Java 8, 236 222 218 173 bajtów

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

Wyjaśnienie:

Wypróbuj 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

Płótno , 58 bajtów

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

Wypróbuj online!

Dość nudna odpowiedź, naprawdę ... buduje obudzoną kozę, powtarza ją poziomo n-1, buduje i dodaje śpiącego kozła, drukuje wynik.