有些人数羊入睡。其他人则数山羊。

编写一个程序或函数，该程序接受一个正整数N并输出N-1个清醒的山羊，然后输出一个熟睡的山羊，就好像有人在计数N个山羊，最后他们睡着了一样。

清醒的山羊看起来像这样：

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

睡觉的山羊看起来像这样：

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

它们通过相邻山羊的胡须和尾巴之间的单个空间链接在一起：

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

输出允许有尾随空格和一个尾随换行符。

以字节为单位的最短代码获胜。

例子

N = 1：

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

N = 2：

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

N = 3：

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

N = 4：

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

较大的N也应该工作。

MATL，56 53字节

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

在线尝试！

说明

清醒的山羊

清醒的山羊可以装进绳子里

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

并打开包装，稍后将对此进行说明。但是，单引号符号必须进行复制才能转义，因此字符串文字必须定义为（请注意，单引号符号与原始符号重复）：

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

为了节省字节，我们使用比字符串高一个代码点的字符来定义字符串，从而避免重复。字符串文字变为

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

在代码末尾，我们将减去1并转换为char。（我们现在可以在字符串文字之后立即执行此操作；但是将其保留在末尾将保存另一个单引号重复项，正如我们将看到的那样）。

为了说明如何解压缩字符串，我们将使用原始字符（在代码末尾加上1来产生），因此更易于理解。我们首先重塑琴弦

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

进入8行2D char数组，按列优先顺序排列（从下到上）。这会自动用char 0填充最后一列（在代码末尾，减去1会将其转换为数字-1，转换为char会再次给出char 0）。字符0显示为空格。因此，我们有效地填充了空格。重塑的结果是

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

现在，我们垂直翻转：

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

然后转置并再次垂直翻转以产生清醒的山羊：

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

因为原始打包的字符串是“反向”，所以需要两个翻转操作。这是为了利用以下事实：代表山羊的实际2D字符数组在其第一行中有6个初始空格，当字符串重新成形为8行2D数组时，这些空格会通过填充自动填充。但是填充是在最后一列（不是行）的末尾（不是开始）完成的，因此是翻转和转置。

睡山羊

睡眠山羊从清醒山羊由字符音译产生o，'，-成-，`，,分别。其实，这是因为一个码点，上述改造，我们音译字符p，(，'为.，a，-，这又不必重复单引号符号拯救我们。这就是在程序结束时保留减一运算的原因。

代码结构

1. 生成一个清醒的山羊N时间，使代码点增加1。
2. 将最后一只山羊变成沉睡的山羊。
3. 水平连接所有山羊。减去1以编码点并转换为char。

注释代码

:                              % (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个字节

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

耶，f弦！

            __________________________
           / \
          | 这个答案是baaaaaaad。|
      \ / ___________________________ /
  ___ / o>'  
-（___）” 
 ''''  

Javascript，122个字节

回答

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

旁注
在以下代码（91字节）中，山羊垂直对齐。它不符合输出格式，但是我可能注意到有趣的一点是，输出格式中所需的水平对齐需要更多字节：

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

批次，234个字节

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

接受来自stdin的输入。批处理由于各种原因"而有麻烦，>因此我必须使用占位符，然后在最后切换它们。

Pyke，56 54字节

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

在这里尝试！

4个字节过多，因为Pyke不允许在字符串中使用双引号:(

的JavaScript（ES6），110个 109字节

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

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

必须支持所有三种引号字符很烦人，但是幸运的是，@ pinkfloydx33的注释使我产生了灵感，可以在末尾添加反引号，从而节省了1个字节。

GolfScript，91个字节

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

输入： 3

输出：

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

说明

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

在线尝试！

果冻，62 56 字节

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

在TryItOnline上进行测试

怎么样？

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

$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个字节

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

点，60 +1 = 61字节

为n标志添加一个字节。

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

将清醒的山羊构造为行列表并将其拉入y。字符串相乘得到a-1清醒的山羊。-o'用,-`in 替换y并将其连接到末尾。打印，以换行符分隔。

在线尝试！

（我认为这是我第一次使用Pip的转义字符串语法\"...\"，该语法允许在字符串中使用文字双引号。）

CJam，58个字节

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

在线尝试！

说明

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字节

编辑：添加了函数定义

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

去胶化：

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

注意Python2.7比Python3短一个字节，因为它在打印时不需要括号。

05AB1E，66个字节

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

在线尝试！

说明

’      \ 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，165155字节

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

运行：

bash my_pgm.bash N

基本上，该程序打印同一只山羊的N次（反转），并用first -，替换,，first ofor -和'' ''backticks 替换。然后反转线。

PHP，133131字节

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

我发现有两个字节可以远离没有卷发的版本之一。

PowerShell v2 +，96字节

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

（ab）使用默认Write-Output格式在元素之间包含换行符。利用字符串连接和乘法来逐行构建山羊。唯一真正的技巧是在第一行$n--中输出正确数量的耳朵，然后输出递减数，$n以便对其余各行都正确。

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

Ruby，102个字节

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

Python 3. 170字节

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

嗯，显然在不执行列表操作的情况下构造了字符串会产生较短的代码

IBM / Lotus Notes的式，187个 174 188字节（未竞争）

编辑找到了一个不该存在的空间，并删除了不需要的@Implode

188因为我错过了睡觉的山羊的尾巴不同的事实:-(

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

取消高尔夫：

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)

用法：

创建一个具有两个名为a和g的字段的Notes表单。

a =可编辑的数字，g =计算的文本。

将上面的公式粘贴到g中，并给出a的默认值0。

将表单字体设置为Terminal。

使用该表单创建一个新文档，在a中输入数字，然后按F9键更新山羊。

样品：

当山羊的数量达到页面宽度时，由于格式混乱，因此无法竞争。

尽管屏幕无限宽，它应该适用于任何数量的山羊。这是页面不够宽时的样子。

Emacs Lisp，241个字节

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

“略有高尔夫球”

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

这里s是一只熟睡的山羊，a加上一只清醒的山羊，g(n)是计数功能。

爪哇8，236个 222 218 173字节

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

说明：

在线尝试。

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

画布，58 字节

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

在线尝试！

答案很无聊，真的……建造了清醒的山羊，水平重复了n-1几次，建立并添加了沉睡的山羊，打印结果。