어떤 사람들은 잠을 자기 위해 양을 센다. 다른 사람들은 염소를 센다.

양의 정수 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 0으로 채 웁니다 (코드의 끝에서 1을 빼면 숫자 -1로 변환되어 char로 변환되면 char 0이 다시 나타납니다). 문자 0이 공백으로 표시됩니다. 효과적으로 우리는 공백으로 채워집니다. 모양을 바꾼 결과는

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

이제 수직으로 뒤집습니다.

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

그런 다음 조옮김 염소를 만들기 위해 다시 세로로 뒤집고 뒤집습니다.

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

압축 된 원래 문자열이 "역방향"이므로 두 번의 플립 조작이 필요합니다. 이는 염소를 나타내는 실제 2D 문자 배열의 첫 번째 행에 6 개의 초기 공백이 있으며 문자열이 8 행 2D 배열로 재 형성 될 때 패딩으로 자동 채워집니다. 그러나 패딩은 마지막 열 (행이 아닌)의 끝 (시작이 아님)에서 이루어 지므로 뒤집기와 조옮김이 이루어집니다.

잠자는 염소

잠자는 염소 음역 문자에 의해 깨어 염소에서 발생하는 o, ', -에 -, `, ,각각. 사실, 때문에 하나의 코드 포인트 - 위의 변환, 우리는 문자를 음역 p, (, '로 ., a, -, 다시 작은 따옴표 기호를 복제하는 데에서 우리를 절약 할 수있다. 이것이 프로그램의 끝 부분에 빼기 1 연산이 남아있는 이유입니다.

코드 구조

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 

파이썬 3.6, 102 바이트

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

야이, f- 줄 !

            __________________________
           / \
          | 이 답변은 baaaaaaad입니다. |
      \ / ___________________________ /
  ___ / o> '  
-(___) " 
 '' ''  

자바 스크립트, 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에서 입력을받습니다. 일괄에 문제가 "그리고 >내가 자리 표시자를 사용하고 말을 전환 할 수 있도록 여러 가지 이유로 있습니다.

파이크, 56 54 바이트

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

여기 사용해보십시오!

Pyke가 문자열에서 큰 따옴표를 허용하지 않기 때문에 4 바이트가 너무 많습니다 :(

자바 스크립트 (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플래그에 1 바이트가 추가되었습니다 .

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

행 목록으로 깨어있는 염소를 구성하고 안으로 들어갑니다 y. a-1깨어있는 염소 를 얻기 위해 문자열 곱하기 . 대체합니다 -o'과 ,-`의 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

파이썬 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보다 1 바이트 짧습니다.

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

배시 + GNU로 coreutils, 165 155 바이트

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 번을 인쇄하고 (역전), 첫 번째 -, for ,, 첫 번째 및 백틱 의 첫 번째 o를 대체합니다 . 그런 다음 줄을 반대로 바꿉니다.-'' ''

PHP, 133131 바이트

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

곱슬 머리없이 버전 중 하나에서 멀리 떨어져있는 2 바이트를 발견했습니다.

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

루비, 102 바이트

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

파이썬 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 / 로터스 노트 화학식, 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에 붙여 넣고 기본값 0을 지정하십시오.

양식 글꼴을 터미널로 설정하십시오.

양식을 사용하여 새 문서를 만들고 a에 숫자를 입력 한 다음 F9를 눌러 염소를 업데이트하십시오.

시료:

염소 수가 페이지 너비에 도달하면 형식이 엉망이되어 경쟁하지 않습니다.

그것은 무한히 와이드 스크린을 감안 해야 염소의 수에 대한 작동합니다 생각을 . 페이지가 충분히 넓지 않을 때의 모습입니다.

이맥스 리스프, 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, 수면 염소를 만들고 추가하고, 결과를 인쇄합니다.