सोते हुए भेड़ की गिनती

11

ज्यादातर लोग ट्रोप से परिचित हैं कि वे भेड़ को सोने के लिए गिना रहे हैं। भेड़ का एक झुंड है, उनमें से कुछ एक बाड़ पर कूदते हैं, और आप भेड़ को कूदते हुए गिनते हैं। माना जाता है, यह आपके दिमाग को शांत करने में मदद करता है और आपको नींद जैसी स्थिति में ले जाता है जिससे आप सो जाएंगे।

यहां दाईं ओर एक ASCII भेड़ का सामना करना पड़ रहा है, जिसे गिना जा रहा है:

'00^>
 ||

यहाँ एक ASCII भेड़ एक बाड़ पर कूद रही है:

'00^>
 /\
 ++

यहाँ एक बाईं ओर है, पहले से ही गिना गया है:

<^00'
  ||

चुनौती

दो इनपुट पूर्णांकों को देखते हुए, nऔर m, n > 2कितने भेड़ कुल का वर्णन करने के साथ , और m > 0यह कहते हुए कि कितनी भेड़ें पहले ही गिनी जा चुकी हैं, एक ASCII कला का प्रतिनिधित्व करते हैं, जो भेड़ को सोने के लिए गिना जाता है।

अब मोड़ के लिए:

  • कलमों के आकार के कारण भेड़ें अंदर होती हैं, शीर्ष पंक्ति केवल अधिकतम 10भेड़ पकड़ सकती है , न कि वर्तमान में कूदने वाली भेड़ की गिनती जो हमेशा शीर्ष पंक्ति में होनी चाहिए।
  • बाद की पंक्तियों में उनके संबंधित पेन के बाहर भेड़ नहीं हो सकती है (आप दूसरी पंक्ति में बाईं ओर अधिक भेड़ नहीं रख सकते हैं, जबकि आप पहली पंक्ति में करते हैं, और दाएं के लिए भी)।
  • यदि 11कुल भेड़ें हैं, तो शीर्ष पंक्ति 10में जंपिंग भेड़ होनी चाहिए ।
  • व्हाट्सएप का अग्रणी / अनुगामी होना, और भेड़ों के बीच व्हाट्सएप कोई फर्क नहीं पड़ता, तब तक:
    1. भेड़ों के बीच न्यूनतम एक व्हाट्सएप चरित्र है
    2. सभी पात्र उचित रूप से पंक्तिबद्ध हैं।

जब तक ये नियम मिलते हैं, तब तक भेड़ की वास्तविक व्यवस्था आपके क्रियान्वयन तक है।

उदाहरण

उदाहरण के लिए, यहां n=3और m=1सबसे सरल मामला है।

         '00^>
'00^>     /\      <^00'
 ||       ++        ||

यहाँ n=11और m=6सबसे अधिक भेड़ें हैं जो एक क्षैतिज रेखा पर फिट हो सकती हैं।

                        '00^>
'00^> '00^> '00^> '00^>  /\   <^00' <^00' <^00' <^00' <^00' <^00'
 ||    ||    ||    ||    ++     ||    ||    ||    ||    ||    ||

यहाँ इसका एक अलग उदाहरण है, साथ n=11औरm=1

                                                      '00^>
'00^> '00^> '00^> '00^> '00^> '00^> '00^> '00^> '00^>  /\   <^00'
 ||    ||    ||    ||    ||    ||    ||    ||    ||    ++     ||

के साथ एक बड़ा उदाहरण n=30औरm=12

                                                '00^>
'00^> '00^> '00^> '00^> '00^> '00^> '00^> '00^>  /\   <^00' <^00'
 ||    ||    ||    ||    ||    ||    ||    ||    ++     ||    || 

'00^> '00^> '00^> '00^> '00^> '00^> '00^> '00^>       <^00' <^00'
 ||    ||    ||    ||    ||    ||    ||    ||           ||    || 

'00^>                                                 <^00' <^00'
 ||                                                     ||    || 

                                                      <^00' <^00'
                                                        ||    || 

                                                      <^00' <^00'
                                                        ||    || 

                                                      <^00' <^00'
                                                        ||    ||

यहां एक उदाहरण n=17और हैm=2

                                                '00^>
'00^> '00^> '00^> '00^> '00^> '00^> '00^> '00^>  /\   <^00' <^00'
 ||    ||    ||    ||    ||    ||    ||    ||    ++     ||    ||

'00^> '00^> '00^> '00^> '00^> '00^>
 ||    ||    ||    ||    ||    ||

यहां एक उदाहरण n=19और हैm=3

                                          '00^>
'00^> '00^> '00^> '00^> '00^> '00^> '00^>  /\   <^00' <^00' <^00'
 ||    ||    ||    ||    ||    ||    ||    ++     ||    ||    || 

'00^> '00^> '00^> '00^> '00^> '00^> '00^>
 ||    ||    ||    ||    ||    ||    ||  

'00^>
 ||

ध्यान दें कि ये सभी उदाहरण हैं । पिछले एक के लिए, आप दाएं हाथ पर भेड़ की एक ऊर्ध्वाधर सरणी बना सकते हैं, जो बाएं हाथ की जगह को दो पंक्तियों पर फिट करने की अनुमति देगा। या हो सकता है कि दाएं हाथ पर भेड़ का 2x2 वर्ग, जो दो पंक्तियों में बाएं हाथ की भेड़ को भी फिट करेगा। आदि।

I / O और नियम

  • इनपुट को किसी भी उचित प्रारूप में और किसी भी सुविधाजनक विधि द्वारा लिया जा सकता है ।
  • लीडिंग / ट्रेलिंग न्यूलाइन्स या अन्य व्हाट्सएप वैकल्पिक हैं, बशर्ते कि वर्ण उचित रूप से पंक्तिबद्ध हों।
  • या तो एक पूर्ण कार्यक्रम या एक समारोह स्वीकार्य हैं। यदि कोई फ़ंक्शन है, तो आप इसे प्रिंट करने के बजाय आउटपुट वापस कर सकते हैं।
  • आउटपुट कंसोल के लिए हो सकता है, स्ट्रिंग्स की सूची के रूप में लौटाया जाता है, एकल स्ट्रिंग के रूप में लौटाया जाता है, आदि।
  • मानक खामियों को मना किया जाता है।
  • यह कोड-गोल्फ है इसलिए सभी सामान्य गोल्फिंग नियम लागू होते हैं, और सबसे छोटा कोड (बाइट्स में) जीतता है।
code-golf  string  ascii-art 
— AdmBorkBork
स्रोत
2
@Rod मैंने एक बड़ा उदाहरण जोड़ा है, लेकिन ध्यान दें कि यह केवल एक उदाहरण है और आपका आउटपुट अलग हो सकता है।
— AdmBorkBork
— श्री एक्सकोडर
अनुशंसित परीक्षण मामले: n=11औरm=9
— 16
@ Adám इस n=11तरह के लिए 10 परीक्षण मामले हो सकते हैं 0<m<=10। यह आपको शीर्ष पंक्ति पर सभी भेड़ों को रखने के लिए मजबूर करता है और बाड़ के बाईं ( n-1-m) और दाएं ( m) पर भेड़ की एक गतिशील संख्या निर्धारित पेन आकार का उपयोग नहीं कर सकती है।
— MT0
@ MT0 सच है, लेकिन एक या दो परीक्षण मामलों को दिखाने के लिए पर्याप्त होना चाहिए कि एक समाधान काम करता है।
— Adám

जवाबों:

9

एपीएल (Dyalog यूनिकोड) , 118 बाइट्स SBCS

अनाम शिशु लाम्बा। nबाएं तर्क के mरूप में और सही तर्क के रूप में लेता है। एक नेस्टेड सरणी परिणाम देता है, लेकिन इस नेस्टेड सरणी का डिफ़ॉल्ट प्रदर्शन विनिर्देशों का अनुसरण करता है। गिने हुए भेड़ के लिए नौ कॉलम तक और वेटिंग भेड़ के लिए शेष कॉलम का उपयोग करता है।

{(r⍴(×/r←d,⍨⌈w÷d←10-⍵⌊⊢/r)↑w⍴(w←⍺-⍵+1)⍴⊂s@2⌽S)(↑(s←'>',⍨¯1↓b)' /\' ' ++')(r⍴(×/r←9,⍨⌈⍵÷9)↑⍵⍴⊂S←⌽↑''(b←'''00^<')' ||')}

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

{… } गुमनाम लंबोदर; ⍺बाएं तर्क है, ⍵सही तर्क है

इस फ़ंक्शन के तीन अलग-अलग हिस्से हैं: वेटिंग , जंपिंग और काउंटेड । हर एक को कोष्ठबद्ध किया जाता है, जिसके परिणामस्वरूप परिणाम तीन-तत्व सूची में होता है।

गिना हुआ (r⍴(×/r←9,⍨∘⌈⍵÷9)↑⍵⍴⊂S←⌽↑''(b←'''00^<')' ||')

''(... )' ||' एक मिरर की गिनती की गई भेड़ की तीन लाइनें, बीच की एक:

 b←'''00^<' शरीर और सौंपा गया है b

↑ एक तार मैट्रिक्स में स्ट्रिंग्स की सूची को मिलाएं (रिक्त स्थान के साथ पैडिंग)

⌽ आईना है कि

S← असाइन करना S(बड़ा S heep)

⊂ इसे संलग्न करें ताकि हम एक इकाई के रूप में इससे निपट सकें

⍵⍴ गिने हुए भेड़ की संख्या का उपयोग चक्रीय रूप से पुनर्व्यवस्थित करने के लिए करें

(… )↑ उस से तत्वों की निम्न संख्या लें (प्रोटोटाइप आइटम के साथ पैडिंग, यानी एक ही सरणी लेकिन रिक्त स्थान द्वारा प्रतिस्थापित सभी वर्णों के साथ)

 ⍵÷9 गिने भेड़ की संख्या का नौवां हिस्सा

 ⌈ बढ़ाना

 9,⍨ उस के लिए 9 जोड़ें

 r← करने के लिए आवंटित r(हम क्या करेंगे यह आर के साथ eshape; पंक्तियों और स्तंभों)

 ×/ उस सूची का उत्पाद (यह है कि हमें कितने तत्वों की आवश्यकता है, जिसमें भरना भी शामिल है)

r⍴ आयाम लंबाई के साथ एक सरणी में फेरबदल करें r

जंपिंग (↑(s←'>',⍨¯1↓b)' /\' ' ++')

(... )' /\' ' ++' कूदती भेड़ की तीन पंक्तियाँ, पहली वाली:

 ¯1↓b अंतिम पात्र को छोड़ दें b

 '>',⍨ एक दाएँ हाथ के सिर को जोड़ो

 s← दुकान में s(छोटे एस heep)

↑ एक तार मैट्रिक्स में स्ट्रिंग्स की सूची को मिलाएं (रिक्त स्थान के साथ पैडिंग)

इंतज़ार कर रही (r⍴(×/r←d,⍨⌈w÷d←10-⍵⌊⊢/r)↑w⍴(w←⍺-⍵+1)⍴⊂s@2⌽S)

⌽S आईना S

s@2 डाल s पर (वहाँ मौजूदा डेटा की जगह) है कि पंक्ति 2

⊂ इसे संलग्न करें ताकि हम एक इकाई के रूप में इससे निपट सकें

(… )⍴ साइक्लिकल रूप से निम्न आकार में फेरबदल करें:

 ⍵+1 गिना भेड़ की संख्या एक प्लस

 ⍺- कुल से घटाओ

 w← असाइन करें w( w aiting)

(… )↑ उस से निम्नलिखित तत्वों की संख्या लें (प्रोटोटाइप आइटम के साथ पैडिंग)

 ⊢/r का सबसे सही तत्व r(अर्थात गिने हुए भेड़ के लिए प्रयुक्त कॉलमों की संख्या)

 ⍵⌊ कुल की न्यूनतम और वह

 10- दस से घटाओ

 d← असाइन करना d( d ifference; लापता कॉलम)

 w÷wउस से  भाग दें

 ⌈ राउंड अप (आवश्यक पंक्तियों की संख्या देता है)

 d,⍨ संलग्न d

 r← करने के लिए आवंटित r(हम क्या करेंगे यह आर के साथ eshape; पंक्तियों और स्तंभों)

 ×/ उस सूची का उत्पाद (यह है कि हमें कितने तत्वों की आवश्यकता है, जिसमें भरना भी शामिल है)

r⍴ आयाम लंबाई के साथ एक सरणी में फेरबदल करें r

— एडम
स्रोत
1
@ WeijunZhou आप सही हैं, ठीक कर देंगे।
— 15:
1
मैं सोच रहा था कि इस चुनौती का मैं कैसे जवाब दूंगा। मुझे लगता है कि यह कैसे है: पी
— जे। सेले
1
@ WeijunZhou फिक्स्ड।
— एडम
"हमेशा प्रतीक्षा भेड़ के लिए नौ कॉलम और गिने भेड़ के लिए एक कॉलम होता है।" क्या यह काम करता है n=11,m=9और नियम "शीर्ष पंक्ति में 10 से अधिक कूदने वाली भेड़ें होनी चाहिए।"
— MT0
3

जावास्क्रिप्ट, 281 , 293 , 288 बाइट्स

a="      ";c=((n,m)=>{b="";for(i=0;i<(q=m>(o=(l=(t=n-m-1)?t:0)/9)?m:o);++i){for(j=0;j<3;++j){b+=[a,"'00^> "," ||   "][j].repeat(r=l>i*9?(z=o-i)>1?9:Math.ceil(z*9):0)+a.repeat((l>9?9:l)-r)+(i?"     ":["'00^>"," /\\  "," ++  "][j])+[a," <^00'","   || "][j].repeat(m>i?1:0)+"\n"}}return b});

नीचे दिए गए स्निपेट का उपयोग करते समय सावधान रहें, अचानक प्रेरित नार्कोलेप्सी का भारी जोखिम है। 

  <form id="form">
    <input type="text" name="n" placeholder="n (sheep total)">
    <input type="text" name="m" placeholder="m (sheep in right hand field)">
    <button type="submit">Let's Go!</button>    
  </form>

  <pre id="output">
  </pre>

  <script>
    a="      ";c=((n,m)=>{b="";for(i=0;i<(q=m>(o=(l=(t=n-m-1)?t:0)/9)?m:o);++i){for(j=0;j<3;++j){b+=[a,"'00^> "," ||   "][j].repeat(r=l>i*9?(z=o-i)>1?9:Math.ceil(z*9):0)+a.repeat((l>9?9:l)-r)+(i?"     ":["'00^>"," /\\  "," ++  "][j])+[a," <^00'","   || "][j].repeat(m>i?1:0)+"\n"}}return b});
      form.addEventListener("submit", function(e){
        e.preventDefault();
  
        var n = parseInt(form.n.value);
        var m = parseInt(form.m.value);
  
        if(n != NaN && m != NaN){
          if(m > n){
            output.innerText = "C'mon man, how can you have more sheep in the right hand field than there are sheep in general?";
          }
          else{
            output.innerText = c(n, m);
          }
        }
        else{
          output.innerText = "Numbers only please.";
        }
      });
    </script>
स्निपेट का विस्तार करें

— Jhal
स्रोत
2
यह n = 50, m = 3 के लिए 4 गिने हुए भेड़ को दिखाता है और n = 20, m = 3 के लिए भेड़ों को गुमराह भी करता है। इसके अलावा n = 20, m = 1 में 2 गिने हुए भेड़ दिखाई देते हैं।
— ale10ander
2
उन त्रुटियों को ठीक किया। यह भी पाया गया कि कुछ भेड़ गोलाई की त्रुटियों के कारण बच रहे थे।
— झाल
यदि m = nआपको कोई त्रुटि मिलती है।
— २१:०१ पर मार्टोर
यह एक ऐसा परिदृश्य है जिसे मैंने नजरअंदाज किया। जिस तरह से प्रश्न में लिखा गया था कि: m = दाहिने हाथ में भेड़ की गिनती n = कुल में भेड़ की गिनती है और वहाँ एक भेड़ भी बाड़ कूद रही है। इसलिए n मी के बराबर नहीं हो सकता है, इसलिए मैंने इसका हिसाब नहीं दिया।
— झाल
2

सी, 392 बाइट्स

एक बाइट को बचाने के लिए @ जोनाथन फ्रेच को धन्यवाद!

#define F;for(
x,y,k;p(L,a,b,t)char L[][78];{F k=5;k--;)L[x=a*4+(t<2)][y=b*6+k]=t?"'00^>"[k]:"<^00'"[k];L[++x][y-=~!t]=47;L[x][++y]=92;L[x][--y]=L[x+=(t>1)][y]=t<2?'|':43;}i,l;f(n,m){char L[i=n*4][78]F;i--;){F L[i][l=77]=0;l--;)L[i][l]=32;}F l=n+~m;++i<l&&i<9+!m;)p(L,0,i,1);l-=i;p(L,0,i++,2)F;i<11&&m--;)p(L,0,i++,0)F i=0;l--;)p(L,++i,0,1)F i=1;m-->0;)p(L,i++,10,0)F l=0;l<i*4;)puts(L+l++);}

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

unrolled:

#define F;for(

x, y, k;
p(L, a, b, t) char L[][78];
{
    F k=5; k--;)
        L[x=a*4+(t<2)][y=b*6+k] = t ? "'00^>"[k] : "<^00'"[k];

    L[++x][y-=~!t] = 47;
    L[x][++y] = 92;
    L[x][--y] = L[x+=(t>1)][y] = t<2 ? '|' : 43;
}

i, l;
f(n, m)
{
    char L[i=n*4][78]
    F; i--;)
    {
        F L[i][l=77]=0; l--;)
            L[i][l] = 32;
    }

    F l=n+~m; ++i<l&&i<9+!m;)
        p(L,0,i,1);

    l-=i;
    p(L,0,i++,2)

    F; i<11&&m--;)
        p(L,0,i++,0)

    F i=0; l--;)
        p(L,++i,0,1)

    F i=1; m-->0;)
        p(L,i++,10,0)

    F l=0; l<i*4;)
        puts(L+l++);
}
— Steadybox
स्रोत
y+=1+!tहो सकता है y-=~!t।
— जोनाथन फ्रीच
@JonathanFrech हां, धन्यवाद!
— स्टेडीबॉक्स
1

पायथन 2 , 222 277 बाइट्स

n,m=input();n-=m+1
s=" '00^>"
j=1;L='  ||  '
a,b=[[[5,5],[10-m,m]][m<9],[n,10-n]][n<9]
print' '*6*a+s
while n>0 or 0<m:N,M=min(n,a),min(m,b);n-=a;m-=b;print '%-*s'%(6*a,N*s),'%5s'%('/\  '*j)+'%*s'%(6*b,M*" <^00'")+'\n'+'%*s'%(-6*a,N*L),'%5s'%('++  '*j),'%*s'%(6*b,M*L)+'\n';j=0

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

— TFeld
स्रोत
पर विफल n=11औरm=2 ।
— आदम
जब मैंने इसे चलाया तो मुझे पहली पंक्ति में 11 भेड़ें नहीं मिलीं।
— रॉबर्ट बेंसन
1
@RobertBenson धन्यवाद, तय
— TFeld
0

AWK , 293 बाइट्स

{f=" '00^>"
l="  ||  " 
L="  /\\   "
p="  ++   "
Y=$2
X=$1-Y-1
E="      "
x=$1>11?Y<5?10-Y:X>5?5:X:X
y=$1>11?X<5?10-X:5:Y
printf"%"6*(x+1)"s\n",f
for(;X>0||Y>0;A=B=""){for(i=0;i++<x;B=B (X>=0?l:E))A=A (--X>=0?f:E)
A=A L
B=B p
for(i=0;i++<y&&--Y>=0;B=B l)A=A"<^00' "
print A"\n"B"\n"
L=p=E" "}}

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

मैंने कुछ छोरों से बचने के लिए स्ट्रिंग प्रतिस्थापन का उपयोग करने की कोशिश की, लेकिन इसमें बहुत अधिक कोड लिया गया।

व्याख्या

{f=" '00^>"    Let's assign
l="  ||  "     some variables
L="  /\\   "   for the ASCII
p="  ++   "    pieces
Y=$2        The number of sheep that have already jumped
X=$1-Y-1    Sheep patiently waiting to jump
E="      "  A string to keep things spaced properly
x=$1>11?Y<5?10-Y:X>5?5:X:X  If there's enough sheep, let's use 5 per column
y=$1>11?X<5?10-X:5:Y        Otherwise, use enough to get 11 sheep in first row
printf"%"6*(x+1)"s\n",f     Print the top part of the jumping sheep
for(;X>0||Y>0;A=B=""){      Loop until we've printed all the sheep
  for(i=0;i++<x;              Loop over waiting sheep in this row
    B=B (X>=0?l:E))             Build the "legs" string
      A=A (--X>=0?f:E)            Build the "bodies" string
  A=A L                       Add the legs and post 
  B=B p                       for the jumping sheep
  for(i=0;i++<y&&--Y>=0;   Loop over the jumped sheep in this row
    B=B l) A=A"<^00' "     Add to the "legs" and "bodies" string 
  print A"\n"B"\n"         Print what we've got so far
  L=p=E" "                 Prevent the jumping sheep's parts from printing lots of times
}}

मुझे कहना होगा कि भेड़ की कला बल्कि प्यारा है। :)

— रॉबर्ट बेन्सन
स्रोत
0

चारकोल , 98 बाइट्स

Ｎθ≔⁻⊖ＮθηＦ⟦⟦00¶/\¶++ θ⌊⟦⌈⟦⁵⁻χη⟧θ⟧⟧⟦0^>¶\¶+  η⌊⟦⌈⟦⁵⁻χθ⟧η⟧⟧⟧«Ｊ⁰¦⁰‖Ｔ§ι⁰↗Ｆ§ι¹«<^00'¶  || ↗¿¬﹪⊕κ§ι²”|Ｉ4Ｏ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

Ｎθ

भेड़ की संख्या को इनपुट करें जो पहले ही गिना जा चुका है।

≔⁻⊖Ｎθη

भेड़ की कुल संख्या का इनपुट करें और गणना करें कि कितने को अभी भी गिनने की आवश्यकता है।

Ｆ⟦⟦00¶/\¶++ θ⌊⟦⌈⟦⁵⁻χη⟧θ⟧⟧⟦0^>¶\¶+  η⌊⟦⌈⟦⁵⁻χθ⟧η⟧⟧⟧«

दो सरणियों की एक सरणी बनाएँ। प्रत्येक सरणी में निम्नलिखित तत्व होते हैं:

  • कूदती भेड़ों का आधा भाग वाला तार
  • बाड़ के उस तरफ भेड़ की संख्या
  • बाड़ के उस तरफ एक पंक्ति में भेड़ों की संख्या, जो या तो है
    • बाड़ के उस तरफ भेड़ की संख्या, यदि 5 से कम हो, या
    • 10 - बाड़ के दूसरी तरफ भेड़ की संख्या, यदि 5 से कम हो, या
    • 5, यदि दोनों पक्षों में कम से कम 5 भेड़ें हों
Ｊ⁰¦⁰‖Ｔ§ι⁰↗

कैनवास को प्रतिबिंबित करें और आधा कूदने वाली भेड़ प्रिंट करें।

Ｆ§ι¹«

उस तरफ भेड़ के माध्यम से लूप।

<^00'¶  || ↗

एक भेड़ प्रिंट।

¿¬﹪⊕κ§ι²”|Ｉ4Ｏ

यदि यह पंक्ति का अंत है, तो अगली भेड़ों की शुरुआत के लिए कुछ नई रूपरेखाओं और स्थानों को प्रिंट करें।

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