Một số người đếm cừu để ngủ. Những người khác đếm dê.

Viết chương trình hoặc hàm lấy số nguyên dương N và tạo ra những con dê tỉnh táo N-1 theo sau là một con dê đang ngủ, như thể ai đó đang đếm N con dê và cuối cùng chúng ngủ thiếp đi.

Dê thức tỉnh trông như thế này:

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

Dê ngủ trông như thế này:

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

Chúng bị xích lại với nhau bằng một khoảng trống giữa râu và đuôi dê liền kề:

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

Đầu ra được phép có các khoảng trắng ở cuối và một dòng mới duy nhất.

Mã ngắn nhất tính bằng byte thắng.

Ví dụ

N = 1:

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

N = 2:

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

N = 3:

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

N = 4:

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

N lớn hơn nên làm việc như là tốt.

MATL , 56 53 byte

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

Hãy thử trực tuyến!

Giải trình

Dê thức

Dê thức tỉnh có thể được đóng gói vào chuỗi

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

và giải nén như sẽ được giải thích trong thời gian ngắn. Tuy nhiên, các ký hiệu trích dẫn đơn sẽ cần được sao chép để thoát chúng, do đó, chuỗi ký tự sẽ phải được định nghĩa là (lưu ý các ký hiệu trích dẫn đơn kèm theo và sao chép của các ký hiệu gốc):

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

Để lưu byte, chúng tôi xác định chuỗi bằng các ký tự một điểm mã ở trên , do đó tránh trùng lặp. Chuỗi ký tự trở thành

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

Khi kết thúc mã, chúng tôi sẽ trừ 1 và chuyển đổi thành char. (Chúng ta có thể làm điều đó ngay bây giờ, ngay sau chuỗi ký tự; nhưng để lại cho đến cuối sẽ lưu một bản sao trích dẫn đơn khác, như chúng ta sẽ thấy).

Để giải thích cách giải nén chuỗi, chúng tôi sẽ làm việc với các ký tự gốc (được tạo ra ở cuối mã bằng cách trừ 1), vì vậy giải thích dễ thực hiện hơn. Trước tiên chúng tôi định hình lại chuỗi

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

thành một mảng char 2D 8 hàng, theo thứ tự chính cột (xuống, sau đó qua). Điều này sẽ tự động đệm cột cuối cùng với char 0 (ở cuối mã, trừ đi 1 sẽ chuyển đổi nó thành số −1, được chuyển đổi thành char cho lại char 0). Char 0 được hiển thị dưới dạng khoảng trắng. Vì vậy, hiệu quả chúng tôi đang đệm với không gian. Kết quả của việc định hình lại là

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

Bây giờ chúng ta lật theo chiều dọc:

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

và sau đó hoán vị và lật theo chiều dọc một lần nữa để tạo ra con dê tỉnh táo:

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

Hai thao tác lật là cần thiết vì chuỗi đóng gói ban đầu là "ngược lại". Điều này là để khai thác thực tế là mảng char 2D thực tế đại diện cho con dê có 6 khoảng trống ban đầu ở hàng đầu tiên, nó sẽ tự động được điền bằng cách đệm khi chuỗi được định hình lại thành mảng 2D 8 hàng. Nhưng phần đệm được thực hiện ở cuối (không bắt đầu) của cột cuối cùng (không phải hàng), do đó lật và chuyển vị.

Dê ngủ

Một con dê ngủ được tạo ra từ một con dê tỉnh táo bởi ký tự chuyển ngữ o, ', -vào -, `, ,tương ứng. Trên thực tế, vì việc chuyển đổi một mã điểm trên, chúng tôi transliterate chars p, (, 'vào ., a, -, mà một lần nữa cứu chúng ta khỏi phải lặp lại các biểu tượng đơn báo giá. Đây là lý do tại sao thao tác trừ một được để lại cho đến cuối chương trình.

Cấu trúc mã

1. Tạo Nthời gian dê tỉnh táo , làm việc với các điểm mã tăng thêm 1.
2. Biến con dê cuối cùng thành một con dê đang ngủ.
3. Nối tất cả các con dê theo chiều ngang. Trừ 1 để mã điểm và chuyển sang char.

Mã nhận xét

:                              % (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, dây f !

            Ngày mai
           / \
          | Câu trả lời này là baaaaaaad. |
      \ / ___________________________ /
  ___ / o> '  
- (___) " 
 '' ''  

Javascript, 122 byte

Câu trả lời

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

Lưu ý bên
Trong đoạn mã sau (91 byte), những con dê được xếp dọc. Nó không tuân thủ định dạng đầu ra nhưng tôi có thể thú vị lưu ý rằng căn chỉnh ngang được yêu cầu trong định dạng đầu ra cần nhiều byte hơn:

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

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

Lấy đầu vào từ stdin. Batch gặp rắc rối với "và >vì nhiều lý do khác nhau nên tôi phải sử dụng trình giữ chỗ và sau đó chuyển đổi chúng ở cuối.

Pyke, 56 54 byte

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

Hãy thử nó ở đây!

Quá nhiều 4 byte vì Pyke không cho phép trích dẫn kép trong chuỗi :(

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>

Phải hỗ trợ cả ba loại nhân vật trích dẫn thật khó chịu, nhưng may mắn thay, nhận xét của @ Pinkfloydx33 đã mang đến cho tôi cảm hứng mà tôi có thể thêm các backquote vào cuối do đó tiết kiệm cho tôi 1 byte.

GolfScript , 91 byte

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

Đầu vào: 3

Đầu ra:

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

Giải trình

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

Hãy thử trực tuyến!

Thạch , 62 56 byte

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

Kiểm tra nó tại TryItOnline

Làm sao?

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

$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

Thêm một byte cho ncờ.

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

Xây dựng một con dê tỉnh táo như một danh sách các dòng và đưa nó vào y. Nhân chuỗi để có được những a-1con dê tỉnh táo. Thay thế -o'bằng ,-`trong yvà nối nó đến cuối. In, phân tách dòng mới.

Hãy thử trực tuyến!

(Tôi nghĩ rằng đây là lần đầu tiên tôi sử dụng cú pháp chuỗi thoát của Pip \"...\", cho phép trích dẫn hai chữ trong chuỗi.)

CJam , 58 byte

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

Hãy thử trực tuyến!

Giải trình

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

Chỉnh sửa: Đã thêm định nghĩa hàm

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

khử golf:

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

Lưu ý Python2.7 ngắn hơn một byte so với Python3 do nó không cần cha mẹ khi in.

05AB1E , 66 byte

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

Hãy thử trực tuyến!

Giải trình

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

Chạy với:

bash my_pgm.bash N

Về cơ bản các bản in chương trình N lần của con dê giống (đảo ngược), và sản phẩm thay thế là người đầu tiên -, cho ,, là người đầu tiên ocho -và là người đầu tiên '' ''cho backticks. Sau đó đảo ngược các dòng.

PHP, 133 131 byte

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

Tôi tìm thấy hai byte để chơi golf từ một trong những phiên bản không có xoăn.

PowerShell v2 +, 96 byte

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

(ab) sử dụng định Write-Outputdạng mặc định để bao gồm một dòng mới giữa các thành phần. Tận dụng nối chuỗi và nhân để xây dựng đường dê theo từng dòng. Bí quyết thực sự duy nhất là dòng đầu tiên $n--đưa ra số tai chính xác và sau đó giảm dần $nđể nó chính xác cho phần còn lại của dòng.

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, rõ ràng là xây dựng chuỗi mà không thực hiện thao tác danh sách mang lại mã ngắn hơn

Công thức ghi chú của IBM / Lotus, 187 174 188 byte (không cạnh tranh)

EDIT Tìm thấy một không gian không nên ở đó và xóa @Implode không cần thiết

188 như tôi đã bỏ lỡ thực tế là đuôi của con dê đang ngủ là khác nhau :-(

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

Ung dung:

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)

Sử dụng:

Tạo một biểu mẫu Ghi chú với hai trường có tên a và g.

a = có thể chỉnh sửa, số, g = tính toán, văn bản.

Dán công thức trên vào g và cho aa giá trị mặc định là 0.

Đặt phông chữ biểu mẫu thành Terminal.

Tạo một tài liệu mới với biểu mẫu, nhập số vào a và nhấn F9 để cập nhật những con dê.

Mẫu:

Không cạnh tranh vì định dạng lộn xộn khi số lượng dê đạt đến chiều rộng của trang.

Với một màn hình vô cùng rộng nó nên sẽ làm việc cho bất kỳ số lượng dê mặc dù . Đây là những gì nó trông giống như khi trang không đủ rộng.

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

"Hơi vô duyên"

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

nơi smột con dê đang ngủ, athêm một con dê tỉnh táo và g(n)là chức năng đếm.

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

Giải trình:

Hãy thử trực tuyến.

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/___¶ ")___(-∙ \；∔± ''２×∔╶╷×>-/___¶ ")___(,∙ \；∔± ``２×∔＋

Hãy thử trực tuyến!

Câu trả lời khá nhàm chán, thực sự ... xây dựng con dê tỉnh táo, lặp đi lặp lại theo chiều ngang n-1, xây dựng và thêm con dê đang ngủ, in kết quả.