सोने के लिए बकरियों की गिनती

36

कुछ लोग सोने के लिए भेड़ की गिनती करते हैं। दूसरे बकरे गिनते हैं।

एक प्रोग्राम या फ़ंक्शन लिखें जो एक सकारात्मक पूर्णांक एन में लेता है और एन -1 जागृत बकरियों का उत्पादन करता है, उसके बाद एक सो रही बकरी, जैसे कि कोई व्यक्ति एन बकरियों की गिनती कर रहा था और बहुत आखिरी में वे सो गए थे।

इस तरह दिखती हैं बकरियां:

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

सोती हुई बकरियाँ ऐसी दिखती हैं:

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

उन्हें दाढ़ी और आसन्न बकरियों की पूंछ के बीच एक ही स्थान पर एक साथ जंजीर दी गई है:

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

आउटपुट को अनुगामी स्थान और एकल अनुगामी न्यूलाइन की अनुमति है।

बाइट्स में सबसे छोटा कोड जीतता है।

उदाहरण

एन = 1:

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

एन = 2:

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

एन = 3:

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

एन = 4:

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

बड़ा एन भी काम करना चाहिए।

code-golf  string  ascii-art  kolmogorov-complexity 
— केल्विन के शौक
स्रोत
9
मुझे लगता है कि आपकी "बकरियाँ" 4 फुट के गुस्से वाले पक्षियों की तरह दिखती हैं;;
— डिजिटल ट्रॉमा
4
Aww मैं कुछ बकरियों को गिनने की उम्मीद कर रहा था, दूसरे तरीके से नहीं
— बीटा डिके
1
मुझे लगता है कि मुझे पता है कि सोने के लिए बकरियों की गिनती कौन करता है
— लुइस मेंडू
7
मुझे नहीं लगता कि आप बकरी को सोने के लिए गिन सकते हैं जब तक कि "ब्लीएट" आपको नींद का एहसास न कराए: पी +1 महान चुनौती
— डाउनफोएट
1
चिल्लाती हुई बकरियों को गिनते हुए मनोरोगी सो जाते हैं।
— mbomb007

जवाबों:

30

MATL , 56 53 बाइट्स

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

इसे ऑनलाइन आज़माएं!

व्याख्या

बकरी को जगाओ

जागृत बकरी को स्ट्रिंग में पैक किया जा सकता है

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

और जल्द ही समझाया जाएगा। हालाँकि, उन्हें छोड़ने के लिए एकल-उद्धरण प्रतीकों को दोहराया जाना चाहिए , इसलिए स्ट्रिंग शाब्दिक को परिभाषित करना होगा (एकल-उद्धरण चिह्नों और मूल लोगों के दोहराव को नोट करें):

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

बाइट्स को बचाने के लिए, हम ऊपर दिए गए वर्णों को एक कोड बिंदु का उपयोग करके स्ट्रिंग को परिभाषित करते हैं , इस प्रकार दोहराव से बचते हैं। स्ट्रिंग शाब्दिक बन जाता है

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

कोड के अंत में हम 1 को घटाएंगे और चार में बदलेंगे। (हम इसे अभी कर सकते हैं, स्ट्रिंग शाब्दिक के ठीक बाद में; लेकिन इसे अंत तक छोड़ने से एक और एकल-उद्धरण दोहराव बच जाएगा, जैसा कि हम देखेंगे)।

यह समझाने के लिए कि स्ट्रिंग कैसे अनपैक्ड है, हम मूल वर्णों के साथ काम करेंगे (जो कि कोड 1 के अंत में कोड के अंत में निर्मित होते हैं), इसलिए स्पष्टीकरण का पालन करना आसान है। हम पहले स्ट्रिंग को फिर से खोलते हैं

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

स्तंभ-प्रमुख क्रम (नीचे, फिर उस पार) में एक 8-पंक्ति 2 डी चार सरणी में । यह स्वचालित रूप से अंतिम कॉलम को char 0 के साथ डालता है (कोड के अंत में, 1 को घटाकर इसे नंबर −1 में बदल देगा, जो char में फिर से बदलकर char 0 देता है)। चार 0 को एक स्थान के रूप में प्रदर्शित किया जाता है। इतनी प्रभावी रूप से हम रिक्त स्थान के साथ पैडिंग कर रहे हैं। रिहा करने का परिणाम है

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

अब हम लंबवत पलटें:

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

और फिर जागरण बकरी का उत्पादन करने के लिए फिर से लंबवत रूप से स्थानांतरित और फ्लिप करें:

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

दो फ्लिप संचालन की आवश्यकता है क्योंकि मूल पैक्ड स्ट्रिंग "रिवर्स" है। यह इस तथ्य का फायदा उठाने के लिए है कि बकरी का प्रतिनिधित्व करने वाले वास्तविक 2 डी चार सरणी में इसकी पहली पंक्ति में 6 प्रारंभिक स्थान हैं, जो स्ट्रिंग 8-पंक्ति 2 डी सरणी में बदल दिए जाने पर स्वचालित रूप से पैडिंग द्वारा भर जाते हैं। लेकिन पैडिंग अंतिम कॉलम (पंक्ति नहीं) के अंत में (शुरुआत में) किया जाता है, इसलिए फ़्लिप और ट्रांसपोज़ होता है।

सो रही बकरी

एक नींद की बकरी का लिप्यंतरण वर्ण द्वारा एक जाग बकरी से उत्पन्न होता है 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
— लुइस मेंडो
स्रोत
8
यह कुछ गंभीर बकरी सिद्धांत है;)
— कॉनर ओ'ब्रायन
17

पायथन 3.6, 102 बाइट्स

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

हां, एफ-स्ट्रिंग्स !

            __________________________
           / \ _
          | यह जवाब है बाआआआआआद। |
      \ / ___________________________ /
  ___ / ओ> '  
- (___) " 
 '' ''
— लिन
स्रोत
13

जावास्क्रिप्ट, 122 बाइट्स

उत्तर

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

साइड नोट
निम्नलिखित कोड (91 बाइट्स) में बकरियों को लंबवत संरेखित किया जाता है। यह आउटपुट प्रारूप का अनुपालन नहीं करता है, लेकिन मैं यह ध्यान रखना दिलचस्प हो सकता है कि आउटपुट प्रारूप में आवश्यक क्षैतिज संरेखण अधिक बाइट्स की आवश्यकता है:

f=n=>`
      \\
  ___/${--n?'o':'-'}>
${n?'-':','}(___)"
 ${n?'`` ``':`'' ''`}`+(n?f(n):'')
— Hedi
स्रोत
3
ऊर्ध्वाधर प्रस्तुत क्यों शामिल हैं? चुनौती क्षैतिज संरेखण के लिए पूछती है।
— मेगो
5
@Mego यह दिखाने में क्या गलत है कि यह कितना अधिक गोल्फ होने योग्य है?
— नील
2
@ नील क्योंकि यह पूरी तरह से चुनौती के लिए स्पर्शरेखा है।
— मेगो
9
@ मुझे लगता है कि यह नोट करना दिलचस्प है।
— कॉनर ओ'ब्रायन ने
3
@ मुझे लगता है कि यह दिलचस्प हो सकता है। मैंने पोस्ट को अधिक स्पष्ट करने के लिए संपादित किया कि ऊर्ध्वाधर संरेखण एक वैध उत्तर नहीं है।
— हेडी
4

बैच, 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:]=^>%

स्टड से इनपुट लेता है। बैच के पास विभिन्न कारणों से परेशानी है "और >इसलिए मुझे प्लेसहोल्डर्स का उपयोग करना है और फिर उन्हें अंत में स्विच करना है।

— नील
स्रोत
मुझे कोई आइडिया set/pnकाम नहीं था ।_
— कॉनर ओ'ब्रायन ने
^पात्रों निकल जाता है।
— क्रिया
जब मुझे इसकी आवश्यकता हो तो @Krii काम नहीं करता है।
— नील
4

पाइके, 56 54 बाइट्स

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

यहाँ यह कोशिश करो!

4 बाइट्स बहुत से हैं क्योंकि Pyke स्ट्रिंग्स में डबल कोट्स की अनुमति नहीं देता है :(

— नीला
स्रोत
3

जावास्क्रिप्ट (ईएस 6), 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 बाइट की बचत हुई।

— नील
स्रोत
क्या आप एक बाइट को बीच में स्विच करके और दो स्ट्रिंग्स को बदलकर एक बाइट बचा सकते हैं '+"'' ''"(मान लें कि सिंगल कोट्स वापस टिक रहे हैं क्योंकि मुझे नहीं पता कि टिप्पणियों में कोड ब्लॉक में बैकटिक कैसे प्राप्त करें)
— Pinkfloydx33
@ pinkfloydx33 मुझे लगा कि मैंने पहले ही कोशिश कर ली है, लेकिन फिर मुझे एहसास हुआ कि मैं अंत में उन बैक टिक्स को जोड़ सकता हूं जो मुझे एक बाइट बचाती है। इसके अलावा एक टिप्पणी कोड ब्लॉक में एक बैक टिक पाने के लिए इसे बैकस्लैश के साथ उपसर्ग करें।
— नील
आप अर्धविराम निकाल सकते हैं
— Howderek
1
@howderek मैंने इसे या f=मेरी बाइट की गिनती में शामिल नहीं किया , यह सिर्फ पूर्णता के लिए है।
— नील
3

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      #

इसे ऑनलाइन आज़माएं!

— FedeWar
स्रोत
5
GoatScript के रूप में लगभग गलत है
— केल्विन के शौक
3

जेली , 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
— जोनाथन एलन
स्रोत
1

पीएचपी, 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");
— जार्ग हुल्सरमन
स्रोत
1
आप कोडिंग तरीका भी साफ कर रहे हैं, जोर्ग। मैं 11 चरणों में 32 बाइट्स से गोल्फ को पार कर सकता था। संकेत चाहिए?
— टाइटस
धन्यवाद मैं केवल इस चुनौती को किसी भी तरह से हल करना चाहता हूं। कभी-कभी साफ बेहतर होता है तो गलत समाधान। आप अपने तरीके से पेस्ट कर सकते हैं।
— जोर्ग हल्सरमैन
मैंने एक अलग दृष्टिकोण लिया; लेकिन अगर आप अपने लिए सुझाव चाहते हैं, तो बस पूछें। पहले 5 चरणों में 24 बाइट्स।
— टाइटस
@ JörgHülsermann अन्य लोगों के उत्तरों को संशोधित करना इस साइट पर भारी पड़ रहा है।
— कारजेनिकेट सिप
@Carcigenicate क्या आपका मतलब है कि मुझे अन्य लोगों या उपाध्यक्षों के उत्तरों को संशोधित करना चाहिए? यदि मैं इस मामले में केवल दिलचस्प हूं, तो किसी समस्या को हल करने के लिए मैं अधिक प्रयास करता हूं। Ascii Art आम तौर पर मेरी प्राथमिकता नहीं है
— Jörg Hülsermann
1

सी ++, 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;
}
— यूरी ब्लोक
स्रोत
2
PPCG में आपका स्वागत है! कृपया एक पंक्ति संस्करण शामिल करें ताकि आप वास्तव में इसे गिन सकें। आप हमेशा एक पठनीय संस्करण को अलग से शामिल कर सकते हैं ताकि लोगों को वन-लाइनर पढ़ना न पड़े। :)
— मार्टिन एंडर
मार्टिन, लिंक के लिए धन्यवाद। मैंने मूल रूप से फ़ाइल के आकार का आकार मापा और अब मैं इसे ठीक करता हूं।
— यूरी ब्लॉक
जवाब वास्तव में फ़ाइल आकार द्वारा मापा जाना चाहिए। मेरा कहना था कि आपका कोड बिना लाइनफीड के काम करता है, इसलिए उत्तर में उस संस्करण को शामिल किया जाना चाहिए।
— मार्टिन एंडर
ठीक है, मैंने आकार फ़ाइल आकार द्वारा लिखा था। यह कोड कैसे काम करता है इसके बारे में - पठनीय और एक पंक्ति संस्करण के बीच कोई अंतर नहीं है।
— यूरी ब्लॉक
मुझे नहीं लगता कि यदि आपके फ़ंक्शन को उनके बिना संकलित नहीं किया जा सकता है, #include <string>तो using namespace std;या तो या using std::string;अपनी बाइट गिनती में शामिल नहीं करना मान्य है ।
— hvd
1

पिप , 60 + 1 = 61 बाइट्स

nध्वज के लिए एक बाइट जोड़ी गई ।

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

लाइनों की एक सूची के रूप में एक जागृत बकरी का निर्माण करता है और इसे में यैंक करता है y। a-1जागृत बकरियों को पाने के लिए स्ट्रिंग-गुणक । के -o'साथ बदल ,-`देता है yऔर इसे अंत तक समेटता है। प्रिंट, न्यूलाइन-अलग।

इसे ऑनलाइन आज़माएं!

(मुझे लगता है कि यह पिप के बच-स्ट्रिंग सिंटैक्स का उपयोग करने वाला मेरा पहला अवसर है \"...\", जो स्ट्रिंग में शाब्दिक दोहरे उद्धरणों की अनुमति देता है।)

— DLosc
स्रोत
1

सीजेएम , 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
— बिजनेस कैट
स्रोत
1

पायथन 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 की तुलना में कम है, क्योंकि इसे मुद्रण करते समय माता-पिता की आवश्यकता नहीं है।

— Tigr
स्रोत
इनपुट प्राप्त करने की आवश्यकता है n, और आपने सोते हुए बकरी के लिए पूंछ परिवर्तन को याद किया है (क्या आपने पाई 3.6 उत्तर भी देखा है?)।
— जोनाथन एलन
नमस्ते! यदि आप इनपुट को संभालना चाहते हैं, तो पूंछ में परिवर्तन है, यह निश्चित नहीं था। मेरे खुद के लिखने के बाद Python3.6 उत्तर पर एक नज़र थी। हालांकि यह इनपुट प्राप्त करता है?
— बाघ
आह अच्छा। यह या तो एक कार्यक्रम या एक समारोह होना चाहिए। अब के लिए बदतर समाधान के साथ अद्यतन करेगा
— ,:
हां, समारोह या कार्यक्रम, आपको मिल गया! आप दो कथनों को अलग करने के लिए print "...1 ;का उपयोग करके, एक जगह पर अंतरिक्ष को हटा सकते हैं और एक पंक्ति में सब कुछ रख सकते हैं । पूंछ अभी भी गोल्फ कोड में नहीं दिखाया गया है, लेकिन ऐसा लगता है कि आपने इसे गिना है, सभी को इसे 112 बाइट्स करना चाहिए ।
— जोनाथन एलन
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
— kalsowerus
स्रोत
0

बैश + जीएनयू कोरुटिल्स, 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

मूल रूप से कार्यक्रम प्रिंट एन एक ही बकरी (विपरीत) के समय, और विकल्प पहले -, के लिए ,, पहले oके लिए -और पहली '' ''बैकटिक के लिए। फिर लाइनों को उलट देता है।

— andlrc
स्रोत
0

PHP, 133 131 बाइट्स

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

मुझे दो बाइट्स मिलीं जो कि बिना कर्ल के एक संस्करण से दूर थीं।

— टाइटस
स्रोत
0

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>  ___/->
-(___)" -(___)" -(___)" ,(___)"
 '' ''   '' ''   '' ''   `` ``
— AdmBorkBork
स्रोत
0

रूबी, 102 बाइट्स

m=-1+n=gets.to_i
puts'      \ '*n,'  ___/o>'*m+'  ___/->',(?-+a='(___)" ')*m+?,+a," '' ''  "*m+" ``"*2
— cia_rana
स्रोत
0

पायथन 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])))

हम्म, जाहिरा तौर पर सूची हेरफेर उपज कम कोड के बिना स्ट्रिंग का निर्माण

— Jeffrey04
स्रोत
0

आईबीएम / लोटस नोट्स फॉर्मूला, 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)

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)

उपयोग:

A और g नाम के दो फ़ील्ड के साथ नोट्स फॉर्म बनाएँ।

a = संपादन योग्य, संख्या, g = संगणित, पाठ।

उपरोक्त सूत्र को g में पेस्ट करें और 0 का एक डिफ़ॉल्ट मान दें।

फॉर्म फॉण्ट को टर्मिनल पर सेट करें।

फ़ॉर्म के साथ एक नया दस्तावेज़ बनाएं, एक नंबर दर्ज करें और बकरियों को अपडेट करने के लिए F9 दबाएं।

नमूने:

यहाँ छवि विवरण दर्ज करें

यहाँ छवि विवरण दर्ज करें

यहाँ छवि विवरण दर्ज करें

जब बकरियों की संख्या पृष्ठ की चौड़ाई तक पहुँच जाती है तो प्रारूप गड़बड़ नहीं होता।

एक असीम चौड़ी स्क्रीन यह देखते हुए करना चाहिए बकरियों के किसी भी संख्या के लिए काम करेंगे , हालांकि । यह तब दिखता है जब पृष्ठ व्यापक नहीं होता है।

यहाँ छवि विवरण दर्ज करें

— ElPedro
स्रोत
यह गैर-प्रतिस्पर्धा क्यों है? हर उत्तर ऐसा ही है। इसे रैपिंग कहा जाता है।
— mbomb007 19
स्पष्टीकरण के लिए धन्यवाद @ mbomb007। ईमानदार होने की कोशिश कर रहा था और मुझसे बेहतर गोल्फरों का अनादर नहीं कर रहा था। मैं इसके लिए नया हूं। ठीक है यह प्रतिस्पर्धा। यह नहीं जीतेगा, लेकिन मुझे यकीन है कि बहुत से लोटस नोट्स
— गोल्फर्स
सच कहूं तो, मुझे यकीन है कि बहुत सारे लोटस नोट्स गोल्फर्स नहीं होंगे।
— एलपेड्रो
0

एमएसीएस लिस्प, 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)गिनती कार्य है।

— भगवान युमा
स्रोत
0

जावा 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
— केविन क्रूज़सेन
स्रोत
0

कैनवस , 58 बाइट्स

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

इसे ऑनलाइन आज़माएं!

बहुत ही उबाऊ उत्तर, वास्तव में ... जागृत बकरी का निर्माण करता है, इसे क्षैतिज रूप से दोहराता है n-1, बनाता है और सोते हुए बकरी को जोड़ता है, परिणाम को प्रिंट करता है।

— hakr14
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.