Bazı insanlar uyumak için koyunları sayarlar. Diğerleri keçi sayıyor.

Olumlu bir N tamsayısı alan ve N-1 uyanık keçi çıkaran bir program veya işlev yazın; sanki biri N keçi sayıyormuş ve en sonuncusu da uykuya dalmış gibi bir uyku keçisi çıkarır.

Uyanık keçi şöyle görünür:

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

Uyuyan keçiler şöyle görünür:

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

Bitişik keçilerin kuyruğu ile sakal arasında tek bir boşlukla birlikte zincirlenirler:

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

Çıktının sondaki boşluklara ve sondaki tek bir yeni satır olmasına izin verilir.

Bayt cinsinden en kısa kod kazanır.

Örnekler

N = 1:

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

N = 2:

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

N = 3:

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

N = 4:

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

Büyük N de aynı şekilde çalışmalıdır.

MATL , 56 53 bayt

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

Çevrimiçi deneyin!

açıklama

Uyanık keçi

Uyanık keçi iple doldurulabilir

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

ve paketlenmemiş olarak kısaca açıklanacaktır. Bununla birlikte, tekli teklif sembollerinin, onlardan kaçmak için çoğaltılması gerekir, bu nedenle karakter dizisinin şu şekilde tanımlanması gerekir:

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

Baytları kaydetmek için dizgeyi , üstünde bir kod noktası olan karakterleri kullanarak tanımlarız , böylece çoğaltmayı önleriz. Dize değişmez olur

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

Kodun sonunda 1'i çıkartacağız ve char'e çevireceğiz. (Tam anlamıyla dizgiden hemen sonra bunu yapabiliriz; ancak sonuna kadar bırakmak, göreceğimiz gibi başka bir tek alıntı yinelemesini kurtarır).

Dizenin nasıl açıldığını açıklamak için orijinal karakterlerle (kodun sonunda 1'i kullanarak üretilir) çalışacağız, böylece açıklamayı takip etmek daha kolaydır. İlk önce dizgiyi yeniden şekillendiririz

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

8 sıralı 2B karakter dizisine, sütun ana sırada (aşağı, sonra çapraz). Bu otomatik olarak son sütunu char 0 ile doldurur (kodun sonunda, 1 çıkarması, onu char 'e dönüştürür, bu char char' a tekrar char 0 verir). Char 0 boşluk olarak gösterilir. Yani etkili bir şekilde boşluklarla doluyuz. Yeniden şekillendirmenin sonucu

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

Şimdi dikey olarak çeviriyoruz:

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

ve sonra uyanık keçiyi üretmek için tekrar dikey olarak çevirin ve ters çevirin:

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

Orijinal çevirme ipinin "ters" olduğu için iki çevirme işlemi gereklidir. Bu, keçiyi temsil eden gerçek 2D karakter dizisinin ilk satırında 6 başlangıç ​​boşluğuna sahip olması gerçeğinden yararlanmak, bu durum dizge 8 satır 2D diziye yeniden şekillendirildiğinde otomatik olarak doldurma ile doldurulur. Ancak dolgu, son sütunun sonunda (başlangıçta değil) (satırda değil) yapılır, bu nedenle çevirir ve transpoze edilir.

Uyuyan keçi

Bir uyku keçi transliterasyonu karakter ile bir uyanıklık keçi oluşturulur o, ', -içine -, `, ,sırasıyla. Aslında, çünkü tek kod noktası yukarıda dönüşümün, biz karakter çevirisini p, (, 'içine ., a, -yine tek tırnak sembolü çoğaltmak zorunda bizi kurtarır hangi. Bu yüzden çıkarma işlemi bir programın sonuna bırakıldı.

Kod yapısı

1. Uyanık bir keçi Nsüreleri yaratın , kod puanlarıyla çalışın 1.
2. Son keçiyi uyuyan bir keçiye dönüştürün.
3. Tüm keçileri yatay olarak birleştirin. Noktaları kodlamak için 1'i çıkartın ve karaktere dönüştürün

Yorumlanan kod

:                              % (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 bayt

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

Yaay, f-dizeleri !

            __________________________
           / \
          | Bu cevap baaaaaaad. |
      \ / ___________________________ /
  ___ / o> '  
- (___)" 
 '' ''  

Javascript, 122 bayt

Cevap

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

Yan not
Aşağıdaki kodda (91 bayt) keçiler dikey olarak hizalanır. Çıktı formatına uymuyor ancak çıktı formatında gerekli olan yatay hizalamanın daha fazla bayta ihtiyaç duyduğunu not etmek ilginç olabilir:

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

Toplu iş, 234 bayt

@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'den girdi alır. Küme çeşitli nedenlerle "ve >çeşitli nedenlerle sorun yaşadığı için yer tutucuları kullanmam ve sonunda bunları değiştirmem gerekiyor.

Pyke, 56 54 bayt

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

Burada dene!

4 bayt çok fazla çünkü Pyke karakter dizisinde çift tırnak işaretine izin vermiyor :(

JavaScript (ES6), 110 109 bayt

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

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

Üç tür alıntı karakterini de desteklemek zorunda kalmak can sıkıcıydı, ama neyse ki @ pinkfloydx33'ın yorumu bana en sonunda tekrar alıntılar ekleyebildiğim için bana ilham verdi.

GolfScript , 91 bayt

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

Giriş: 3

Çıktı:

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

açıklama

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

Çevrimiçi deneyin!

Jöle , 62 56 bayt

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

TryItOnline'da test edin

Nasıl?

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

$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 bayt

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 bayt

nBayrak için bir bayt eklendi .

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

Satır listesi olarak uyanık bir keçi inşa eder ve içine çeker y. a-1Uyanık keçileri almak için string ile çarpar . Yerini -o'ile ,-`de yve sonuna kadar bitiştirir bunu. Yazdırır, yeni satır ayrılmış.

Çevrimiçi deneyin!

(Sanırım bu, Pip'in dizedeki \"...\"değişmez çift tırnaklara izin veren kaçan dize sözdizimini ilk kez kullanıyorum .)

CJam , 58 bayt

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

Çevrimiçi deneyin!

açıklama

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 bayt

Düzenleme: Eklenen işlev tanımı

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

Not Python2.7, Python3'ten bir bayt daha kısadır, çünkü yazdırırken parantez gerektirmez.

05AB1E , 66 bayt

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

Çevrimiçi deneyin!

açıklama

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

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

Çalıştır:

bash my_pgm.bash N

Temel olarak Program yazdırır K aynı keçi (ters) bir kez ve yerine ilk -için, ,birinci oiçin -ve birinci '' ''ters tırnakların için. Sonra hatları tersine çevirir.

PHP, 133 131 bayt

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

Kıvırcıksız versiyondan birinden uzaklaşmak için iki bayt buldum.

PowerShell v2 +, 96 bayt

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

(ab) Write-Outputöğeler arasına yeni bir satır eklemek için varsayılan biçimlendirmeyi kullanır . Keçileri satır satır oluşturmak için dize birleştirme ve çarpma işlemlerinden yararlanır. Tek gerçek püf noktası, $n--doğru sayıda kulak çıkaran ilk satır ve sonra da azaldıktan sonra $ngeri kalan satırlar için doğru olanıdır .

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

Ruby, 102 bayt

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

Python 3. 170 bayt

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, görünüşe göre liste manipülasyon yapmadan dize inşa kısa kod verimi

IBM / Lotus Notes Formülü, 187 174 188 bayt (rekabet etmiyor)

EDIT Orada olmaması gereken bir yer bulundu ve gereksiz bir @Implode kaldırıldı

Uyuyan keçinin kuyruğunun farklı olduğu gerçeğini kaçırdığım için 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)

Kullanımı:

A ve g adlı iki alan içeren bir Notlar formu oluşturun.

a = düzenlenebilir, sayı, g = hesaplanan, metin.

Yukarıdaki formülü g'ye yapıştırın ve varsayılan bir 0 değeri verin.

Form yazı tipini Terminal olarak ayarlayın.

Formla yeni bir belge oluşturun, içine bir sayı girin ve keçileri güncellemek için F9 tuşuna basın.

Örnekler:

Keçi sayısı sayfanın genişliğine ulaştığında biçim karışır gibi rekabet etmiyor.

Bir sonsuz geniş ekran Verilen gerektiğini keçi herhangi bir sayı için çalışacak olsa . Sayfa yeterince geniş olmadığı zamanki gibi görünüyor.

Emacs Lisp, 241 bayt

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

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

sbir uyku keçisi nerede auyanık bir keçi ekler ve g(n)sayma işlevidir.

Java 8, 236 222 218 173 bayt

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

Açıklama:

Çevrimiçi deneyin.

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

Tuval , 58 bayt

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

Çevrimiçi deneyin!

Oldukça sıkıcı cevap, gerçekten ... uyanık keçiyi oluşturur, yatay olarak tekrarlar n-1, uyuyan keçiyi oluşturur ve ekler, sonucu yazdırır.