Beberapa orang menghitung domba untuk tidur. Lainnya menghitung kambing.

Tulis program atau fungsi yang menghasilkan bilangan bulat N positif dan mengeluarkan N-1 kambing terjaga diikuti oleh satu kambing tidur, seolah-olah seseorang menghitung N kambing dan pada yang terakhir mereka tertidur.

Kambing terjaga terlihat seperti ini:

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

Kambing tidur terlihat seperti ini:

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

Mereka dirantai bersama dengan satu ruang antara jenggot dan ekor kambing yang berdekatan:

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

Outputnya diizinkan untuk memiliki spasi tambahan dan satu baris tambahan baru.

Kode terpendek dalam byte menang.

Contohnya

N = 1:

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

N = 2:

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

N = 3:

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

N = 4:

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

N yang lebih besar seharusnya bekerja dengan baik.

MATL , 56 53 byte

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

Cobalah online!

Penjelasan

Bangunlah kambing

Kambing yang terjaga dapat dimasukkan ke dalam tali

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

dan membongkar seperti yang akan dijelaskan segera. Namun, simbol tanda kutip tunggal perlu diduplikasi untuk menghindarinya, sehingga string literal harus didefinisikan sebagai (perhatikan simbol tanda kutip tunggal terlampir dan duplikasi yang asli):

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

Untuk menyimpan byte, kita mendefinisikan string menggunakan karakter satu titik kode di atas itu, sehingga menghindari duplikasi. String literal menjadi

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

Di akhir kode kita akan mengurangi 1 dan mengonversi menjadi char. (Kita bisa melakukannya sekarang, tepat setelah string literal; tetapi membiarkannya sampai akhir akan menyimpan duplikasi kutipan tunggal, seperti yang akan kita lihat).

Untuk menjelaskan bagaimana string diurai, kami akan bekerja dengan karakter asli (yang diproduksi di akhir kode dengan subtak 1), sehingga penjelasannya lebih mudah diikuti. Kami pertama-tama membentuk kembali string

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

menjadi array char 2D 8-baris, dalam urutan kolom-utama (turun, lalu lintas). Ini secara otomatis mengisi kolom terakhir dengan char 0 (di akhir kode, mengurangi 1 akan mengubahnya menjadi angka −1, yang dikonversi menjadi char memberi lagi char 0). Karakter 0 ditampilkan sebagai spasi. Jadi secara efektif kita dipenuhi ruang. Hasil pembentukan kembali adalah

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

Kami sekarang membalik secara vertikal:

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

dan kemudian transpos dan balik vertikal lagi untuk menghasilkan kambing yang terjaga:

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

Dua operasi flip diperlukan karena string yang dikemas asli "terbalik". Ini adalah untuk mengeksploitasi fakta bahwa array char 2D aktual yang mewakili kambing memiliki 6 spasi awal di baris pertama, yang secara otomatis diisi dengan padding ketika string dibentuk kembali menjadi array 2D 8-baris. Tetapi padding dilakukan di akhir (bukan awal) dari kolom terakhir (bukan baris), maka membalik dan transpos.

Kambing tidur

Seekor kambing tidur yang dihasilkan dari kambing terjaga dengan transliterasi karakter o, ', -menjadi -, `, ,masing-masing. Sebenarnya, karena transformasi satu-kode-point-atas, kita transliterasi karakter p, (, 'menjadi ., a, -, yang lagi-lagi menyelamatkan kita dari keharusan untuk menduplikasi simbol single-quote. Inilah sebabnya mengapa operasi kurangi-satu dibiarkan pada akhir program.

Struktur kode

1. Hasilkan kambing yang terjaga Nkali, bekerja dengan poin kode meningkat sebesar 1.
2. Ubah kambing terakhir menjadi kambing tidur.
3. Gabungkan semua kambing secara horizontal. Kurangi 1 untuk kode poin dan berikan ke char.

Kode yang dikomentari

:                              % (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-string !

            __________________________
           / \
          | Jawaban ini adalah baaaaaaad. |
      \ / ___________________________ /
  ___ / o> '  
- (___) " 
 '' ''  

Javascript, 122 byte

Menjawab

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

Catatan sisi
Dalam kode berikut (91 byte) kambing disejajarkan secara vertikal. Itu tidak sesuai dengan format output tetapi saya pikir itu bisa menarik untuk dicatat bahwa perataan horizontal yang diperlukan dalam format output membutuhkan lebih banyak byte:

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

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

Mengambil input dari stdin. Batch memiliki masalah dengan "dan >karena berbagai alasan, jadi saya harus menggunakan placeholder dan kemudian mengubahnya pada akhirnya.

Pyke, 56 54 byte

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

Coba di sini!

4 byte terlalu banyak karena Pyke tidak mengizinkan kuotasi ganda dalam string :(

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>

Harus mendukung ketiga jenis karakter kutipan itu menjengkelkan, tetapi untungnya komentar @ pinkfloydx33 memberi saya kilasan inspirasi bahwa saya bisa menambahkan backquotes pada akhirnya sehingga menghemat 1 byte.

GolfScript , 91 byte

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

Memasukkan: 3

Keluaran:

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

Penjelasan

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

Cobalah online!

Jelly , 62 56 byte

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

Uji di TryItOnline

Bagaimana?

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

Satu byte ditambahkan untuk nbendera.

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

Bangun seekor kambing yang terjaga sebagai daftar garis dan menariknya ke dalam y. Tali-gandakan untuk mendapatkan a-1kambing yang terjaga. Menggantikan -o'dengan ,-`di ydan merangkai sampai akhir. Cetakan, dipisahkan baris baru.

Cobalah online!

(Saya pikir ini adalah pertama kalinya saya menggunakan sintaks-string Pip \"...\", yang memungkinkan untuk tanda kutip ganda literal dalam string.)

CJam , 58 byte

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

Cobalah online!

Penjelasan

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

Edit: Menambahkan definisi fungsi

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

Catatan Python2.7 adalah satu byte lebih pendek dari Python3 karena itu tidak perlu parentesis saat mencetak.

05AB1E , 66 byte

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

Cobalah online!

Penjelasan

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

Jalankan dengan:

bash my_pgm.bash N

Pada dasarnya program cetakan N kali dari kambing yang sama (terbalik), dan pengganti yang pertama -, untuk ,, pertama ountuk -dan yang pertama '' ''untuk tanda kutip mundur. Kemudian membalikkan garis.

PHP, 133 131 byte

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

Saya menemukan dua byte untuk golf dari salah satu versi tanpa keriting.

PowerShell v2 +, 96 byte

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

(ab) menggunakan Write-Outputpemformatan default untuk menyertakan baris baru antar elemen. Memanfaatkan penggabungan string dan multiplikasi untuk membangun kambing baris demi baris. Satu-satunya trik nyata adalah baris pertama $n--untuk menampilkan jumlah telinga yang benar dan kemudian pasca-pengurangan $nsehingga benar untuk sisa baris.

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

Ruby, 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, tampaknya membangun string tanpa melakukan manipulasi daftar menghasilkan kode yang lebih pendek

IBM / Lotus Notes Formula, 187 174 188 byte (tidak bersaing)

EDIT Menemukan ruang yang seharusnya tidak ada di sana dan menghapus @Implode yang tidak dibutuhkan

188 karena saya telah melewatkan fakta bahwa ekor kambing yang tidur berbeda :-(

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

Tidak Disatukan:

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)

Pemakaian:

Buat formulir Notes dengan dua bidang bernama a dan g.

a = dapat diedit, angka, g = dihitung, teks.

Rekatkan rumus di atas ke dalam g dan beri nilai default 0.

Atur font bentuk ke Terminal.

Buat dokumen baru dengan formulir, masukkan nomor dalam dan tekan F9 untuk memperbarui kambing.

Sampel:

Tidak bersaing karena formatnya kacau ketika jumlah kambing mencapai lebar halaman.

Mengingat layar jauh lebar itu harus akan bekerja untuk sejumlah kambing meskipun . Ini terlihat seperti ketika halaman tidak cukup lebar.

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

"Sedikit tidak berbulu"

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

Di mana sada satu kambing tidur, amenambahkan kambing yang terjaga dan g(n)fungsi menghitung.

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

Penjelasan:

Cobalah 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

Kanvas , 58 byte

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

Cobalah online!

Jawaban yang sangat membosankan, sungguh ... membangun kambing yang terjaga, mengulanginya secara horizontal n-1, membangun dan menambahkan kambing yang tidur, mencetak hasilnya.