Деякі люди рахують овець, щоб заснути. Інші рахують козлів.

Напишіть програму або функцію, яка приймає натуральне ціле число 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-рядовий двовимірний масив знаків у порядку основного стовпця (вниз, потім поперек). Це автоматично прошиває останній стовпчик із символом char 0 (наприкінці коду віднімання 1 перетворить його на число −1, яке перетворене в char дає знову char 0). Char 0 відображається як пробіл. Настільки ефективно ми прокладаємо пробіли. Результатом переформатування є

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

Тепер перевертаємо вертикально:

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

а потім знову перенесіть і переверніть вертикально, щоб створити неспану козу:

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

Дві операції фліп потрібні, оскільки початкова упакована рядок "знаходиться в зворотному порядку". Цим потрібно скористатися тим фактом, що фактичний 2D-матричний діапазон, що представляє козу, має в своєму першому рядку 6 початкових пробілів, які автоматично заповнюються за допомогою прокладки, коли рядок переробляється в 8-рядовий 2D-масив. Але прокладка робиться в кінці (не на початку) останнього стовпця (а не ряду), звідси перевертається і переноситься.

Спляча коза

Сплячий козел генерується з активного козла з допомогою транслітерації символів 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-string !

            __________________________
           / \
          | Ця відповідь - бааааааад. |
      \ / ___________________________ /
  ___ / о> '  
- (___) " 
 '' ''  

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. Batch має проблеми з "і >з різних причин , тому я повинен використовувати наповнювачі , а потім увімкніть їх в кінці.

Пайк, 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' на ,-`в yі поєднує його до кінця. Відбитки, розділені новими рядками

Спробуйте в Інтернеті!

(Я думаю, що це вперше я використовую синтаксис врятованого рядка Піпа \"...\", який дозволяє отримати буквальні подвійні лапки в рядку.)

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, тому що він не потребує парентезу під час друку.

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для -і першу '' ''для зворотних посилань. Потім переверніть лінії.

PHP, 133 131 байт

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

Рубін, 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 / Lotus Notes, 187 174 188 байт (не конкурує)

EDIT Знайшов простір, який там не мав бути, і видалив непотрібний @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.

a = редагована, число, g = обчислена, текст.

Вставте вищевказану формулу в g і задайте значення за замовчуванням 0.

Встановіть шрифт форми на Terminal.

Створіть новий документ із формою, введіть число в а та натисніть 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)є функцією підрахунку.

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

Полотно , 58 байт

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

Спробуйте в Інтернеті!

Дуже нудна відповідь, справді ... будує козла, що не буває, повторює його по горизонталі n-1раз, будує та додає сплячу козу, друкує результат.