บางคนนับแกะเพื่อนอน คนอื่นนับแพะ

เขียนโปรแกรมหรือฟังก์ชั่นที่ใช้จำนวนเต็มบวก 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 และแปลงเป็นถ่าน (เราสามารถทำได้ทันทีหลังจากสตริงตัวอักษร แต่การปล่อยให้จบจะช่วยให้การทำซ้ำการอ้างอิงเดียวอีกครั้งตามที่เราจะเห็น)

เพื่ออธิบายวิธีคลายสตริงเราจะทำงานร่วมกับอักขระดั้งเดิม (ซึ่งผลิตที่ท้ายรหัสโดยการลบ 1) เพื่อให้คำอธิบายง่ายขึ้น ก่อนอื่นเราปรับรูปร่างสตริง

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

ลงในอาร์เรย์ถ่าน 8 แถว 8 แถวตามลำดับคอลัมน์ (ลงจากนั้นข้าม) สิ่งนี้จะรองคอลัมน์สุดท้ายโดยอัตโนมัติด้วยอักขระถ่าน 0 (ในตอนท้ายของรหัสการลบ 1 จะเปลี่ยนเป็นหมายเลข −1 ซึ่งแปลงเป็นถ่านให้ถ่านอีกครั้ง 0) Char 0 แสดงเป็นช่องว่าง อย่างมีประสิทธิภาพดังนั้นเราจึงมีช่องว่างภายใน ผลลัพธ์ของการปรับรูปร่างใหม่คือ

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

ตอนนี้เราพลิกแนวตั้ง:

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

จากนั้นขนย้ายและพลิกในแนวตั้งอีกครั้งเพื่อสร้างแพะที่ตื่นอยู่:

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

จำเป็นต้องใช้การพลิกสองครั้งเนื่องจากสตริงที่บรรจุดั้งเดิมคือ "ย้อนกลับ" นี่คือการใช้ประโยชน์จากข้อเท็จจริงที่ว่าอาร์เรย์ถ่าน 2 มิติที่เป็นตัวแทนของแพะนั้นมีช่องว่างเริ่มต้น 6 ช่องในแถวแรกของมันซึ่งจะถูกเติมโดยอัตโนมัติด้วยการเติมเมื่อสตริงถูกเปลี่ยนเป็นสตริง 2D 8 แถว แต่การเติมจะทำที่ท้าย (ไม่ใช่จุดเริ่มต้น) ของคอลัมน์สุดท้าย (ไม่ใช่แถว) ดังนั้นการพลิกและการแปลง

นอนหลับแพะ

แพะนอนถูกสร้างขึ้นจากแพะตื่นโดยตัวอักษร transliterating o, ', -เข้า-, `, ,ตามลำดับ จริงเพราะการเปลี่ยนแปลงหนึ่งรหัสจุดข้างต้นเราแปลตัวอักษรp, (, 'เข้า., a, -อีกครั้งซึ่งช่วยเราจากที่มีการทำซ้ำสัญลักษณ์อ้างเดียว นี่คือเหตุผลที่การดำเนินการลบหนึ่งถูกทิ้งไว้ที่ส่วนท้ายของโปรแกรม

โครงสร้างรหัส

1. สร้างเวลาในการตื่นของแพะNทำงานกับคะแนนรหัสเพิ่มขึ้น 1
2. เปลี่ยนแพะตัวสุดท้ายให้กลายเป็นแพะหลับ
3. เชื่อมแพะทุกตัวในแนวนอน ลบ 1 ถึงรหัสคะแนนและโยนเพื่อถ่าน

รหัสแสดงความคิดเห็น

:                              % (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} `` ``'''

Yaay, f-strings !

            __________________________
           / \
          | คำตอบนี้คือ 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>

การที่ต้องสนับสนุนตัวละครทั้งสามชนิดนั้นน่ารำคาญ แต่ความเห็นของ @fullf33x โชคดีที่ทำให้ฉันมีแรงบันดาลใจที่ฉันสามารถเพิ่ม backquotes ในตอนท้ายซึ่งช่วยฉันได้ 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;
}

Pip , 60 + 1 = 61 ไบต์

เพิ่มหนึ่งไบต์สำหรับnแฟล็ก

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

โครงสร้างแพะตื่นตัวเป็นรายการของเส้นและ yanks yมันเข้าไป การคูณสตริงเพื่อให้a-1แพะตื่นตัว แทนที่-o'ด้วย,-`in yและต่อท้ายจนจบ พิมพ์คั่นด้วยบรรทัดใหม่

ลองออนไลน์!

(ฉันคิดว่านี่เป็นครั้งแรกของฉันที่ใช้ Pip-escaped-string syntax \"...\"ซึ่งอนุญาตให้ใช้อัญประกาศคู่ที่แท้จริงในสตริง)

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

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

หมายเหตุ 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, 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 ของแพะเดียวกัน (ย้อนกลับ) และทดแทนแรก-สำหรับ,ครั้งแรกoสำหรับ-และเป็นครั้งแรก'' ''สำหรับ backticks จากนั้นฝืนเส้น

PHP, 133 131 ไบต์

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

ฉันพบสองไบต์ที่จะตีกอล์ฟให้ห่างจากรุ่นใดรุ่นหนึ่งโดยไม่ต้องใช้ curlys

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)

Ungolfed:

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)

การใช้งาน:

สร้างฟอร์ม Notes ที่มีสองฟิลด์ชื่อ a และ g

a = แก้ไขได้, ตัวเลข, g = คำนวณ, ข้อความ

วางสูตรด้านบนลงใน g และกำหนดค่าเริ่มต้นเป็น 0

ตั้งค่าฟอนต์ฟอร์มเป็นเทอร์มินัล

สร้างเอกสารใหม่ด้วยแบบฟอร์มป้อนหมายเลขในและกด 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)))))

"ungolfed เล็กน้อย"

(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)อยู่และเป็นฟังก์ชั่นการนับ

Java 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

Canvas ขนาด 58 ไบต์

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

ลองออนไลน์!

คำตอบที่น่าเบื่อสวยจริง ๆ ... สร้างแพะที่ตื่นแล้วซ้ำอีกn-1ครั้งในแนวนอนสร้างและเพิ่มแพะนอนหลับพิมพ์ผลลัพธ์