भूत और कद्दू

Question

यहाँ एक ASCII कद्दू जैक-ओ-लैंटर्न में खुदी हुई है। क्या यह प्यारा नहीं है?

((^v^))

यहाँ एक ASCII भूत है। देखो कितना डरावना है!

\{O.O}/

जाहिर है, कद्दू जमीन पर होना चाहिए, उनके बीच की जगह के साथ ताकि वे सड़ न जाएं।

भूत, हालांकि, कद्दू के शीर्ष पर खड़े होना पसंद करते हैं, इसलिए वे भी डरावना हैं । हालांकि, उन्हें दो कद्दू पर खड़े रहना होगा, अन्यथा उनका भूतिया वजन उनके नीचे कद्दू को कुचल देगा। लेकिन, उनके भूतिया जादू कैसे काम करते हैं, इसके कारण , कई भूत कद्दू को ढेर कर सकते हैं और साझा कर सकते हैं, बशर्ते कि भूत या तो निचले कद्दू या निचले भूतों पर समान रूप से विभाजित हो। दूसरे शब्दों में, मानव पिरामिड की तरह एक आकृति का निर्माण । ध्यान दें कि भूत तब तक भूतों पर नहीं टिक सकते हैं जब तक कि नीचे एक कद्दू नहीं है (यह जादू काम करता है)।

दो गैर नकारात्मक पूर्णांक को देखते हुए, gऔर p, की संख्या का प्रतिनिधित्व gमेजबान और pumpkins, उत्पादन सबसे अधिक कॉम्पैक्ट सबसे बाईं ओर गठन संभव हो, ऊपर पिरामिड नियम स्टैकिंग निम्नलिखित। बचे हुए कद्दू और भूत (जो पिरामिड नहीं बनाते हैं) जमीन पर दाईं ओर जाते हैं।

स्पष्टीकरण के लिए, ये संरचनाएँ ठीक हैं (रिक्त नई पंक्ति अलग), और उदाहरण I / O के रूप में कार्य करें:

0p 1g
\{O.O}/

1p 0g
((^v^))

1p 1g
((^v^)) \{O.O}/

2p 1g
    \{O.O}/
((^v^)) ((^v^))

2p 2g
    \{O.O}/
((^v^)) ((^v^)) \{O.O}/

3p 1g
    \{O.O}/
((^v^)) ((^v^)) ((^v^))

3p 2g
    \{O.O}/ \{O.O}/
((^v^)) ((^v^)) ((^v^))

3p 3g
        \{O.O}/
    \{O.O}/ \{O.O}/
((^v^)) ((^v^)) ((^v^))

0p 4g
\{O.O}/ \{O.O}/ \{O.O}/ \{O.O}/

3p 0g
((^v^)) ((^v^)) ((^v^))

7p 6g
            \{O.O}/
        \{O.O}/ \{O.O}/
    \{O.O}/ \{O.O}/ \{O.O}/
((^v^)) ((^v^)) ((^v^)) ((^v^)) ((^v^)) ((^v^)) ((^v^))

ये संरचनाएँ ठीक नहीं हैं

\{O.O}/
((^v^))

    \{O.O}/
((^v^))

((^v^)) ((^v^)) \{O.O}/

    \{O.O}/
    \{O.O}/
((^v^)) ((^v^))

            \{O.O}/
\{O.O}/ ((^v^)) ((^v^))

    ((^v^))
((^v^)) ((^v^))

      \{O.O}/
((^v^)) ((^v^))

इनपुट

किसी भी सुविधाजनक प्रारूप में दो गैर-नकारात्मक पूर्णांक । कम से कम एक संख्या गैर-शून्य होगी। आप इनपुट को या तो क्रम में ले सकते हैं (यानी, उदाहरण में मेरे पास पहले कद्दू थे) - कृपया निर्दिष्ट करें कि आप अपने उत्तर में इनपुट कैसे लेते हैं।

उत्पादन

उपरोक्त नियमों का पालन करते हुए भूत और कद्दू का एक ASCII- कला प्रतिनिधित्व। अग्रणी या अनुगामी न्यूलाइन्स या अन्य व्हाट्सएप वैकल्पिक हैं, बशर्ते कि भूत और कद्दू उचित रूप से पंक्तिबद्ध हों।

नियम

• या तो एक पूर्ण कार्यक्रम या एक समारोह स्वीकार्य हैं। यदि कोई फ़ंक्शन है, तो आप इसे प्रिंट करने के बजाय आउटपुट वापस कर सकते हैं।
• मानक खामियों को मना किया जाता है।
• यह कोड-गोल्फ है इसलिए सभी सामान्य गोल्फिंग नियम लागू होते हैं, और सबसे छोटा कोड (बाइट्स में) जीतता है।

Comments

7 कद्दू और 6 भूतों के लिए सही गठन क्या है?

— नील

@Neil चूंकि नियम सबसे अधिक कॉम्पैक्ट बाएं-सबसे आउटपुट के लिए पूछते हैं, जो कि 4 कद्दूओं के शीर्ष पर 6 भूतों का एक पिरामिड होगा, जिसमें 3 अतिरिक्त कद्दू होंगे। मैं इसे एक उदाहरण के रूप में जोड़ूंगा।

— AdmBorkBork

ठीक है, कॉम्पैक्ट के आपके उपयोग ने मुझे उलझन में डाल दिया - मैं सभी भूतों को एक ही पंक्ति में रख सकता हूं, इसलिए यह लंबवत रूप से अधिक कॉम्पैक्ट है!

— नील

क्या कद्दू हमेशा भूतों से पहले प्रदान किए जाएंगे?

— गेब्रियल बेनामी

मुझे पसंद है कि भूत और कद्दू एक मानव पिरामिड बना रहे हैं

— मेयोरमोनी

Answer 1

जावास्क्रिप्ट (ईएस 7), 166 164 159 बाइट्स

नील को धन्यवाद देकर 5 बाइट्स बचाए

f=(p,g,j=(g*2)**.5+.5|0,G=j>p-1?p?p-1:0:j,P=`
`,i=~j?g-G*++G/2:G,n=i>0?i>g?g:i:0)=>p|g?f(0,g-n,-1,G-1,P+'    ')+P+'((^v^)) '.repeat(p)+'\\{O.O}/ '.repeat(n):''

प्रारूपित और टिप्पणी की गई

f = (                                    // given:
  p,                                     // - p = number of pumpkins
  g,                                     // - g = number of ghosts
  j = (g * 2) ** .5 + .5 | 0,            // - j = ceil(triangular root of g)
  G = j > p - 1 ? p ? p - 1 : 0 : j,     // - G = max(0, min(p - 1, j))
  P = '\n',                              // - P = padding string (+ line-break)
  i = ~j ?                               // - i =
    g - G * ++G / 2                      //   first iteration: g - G * (G + 1) / 2
  : G,                                   //   next iterations: G
  n = i > 0 ? i > g ? g : i : 0          // - n = max(0, min(i, g)) = number of
) =>                                     //   ghosts to print at this iteration
p | g ?                                  // if there's still something to print:
  f(                                     //   do a recursive call with:
    0,                                   //   - no pumpkin anymore
    g - n,                               //   - the updated number of ghosts
    -1,                                  //   - j = -1 (so that ~j == 0)
    G - 1,                               //   - one less ghost on the pyramid row
    P + '    '                           //   - updated padding string
  ) +                                    //   
  P +                                    //   append padding string
  '((^v^)) '.repeat(p) +                 //   append pumpkins
  '\\{O.O}/ '.repeat(n)                  //   append ghosts
: ''                                     // else: stop

पराधीन गणित

मुश्किल हिस्सा Gभूत पिरामिड की इष्टतम चौड़ाई का पता लगाने के लिए है ।

gऐसे पिरामिड में भूतों की संख्या किसके द्वारा दी गई है:

g = 1 + 2 + 3 + ... + G = G(G + 1) / 2

पारस्परिक रूप से, gभूतों वाले पिरामिड की चौड़ाई परिणामी द्विघात समीकरण की वास्तविक जड़ है:

G² + G - 2g = 0

Δ = 1² - 4(-2g)
Δ = 8g + 1

G = (-1 ± √Δ) / 2

जो निम्नलिखित वास्तविक जड़ ( त्रिकोणीय जड़ के रूप में भी जाना जाता है ) की ओर जाता है:

G = (√(8g + 1) - 1) / 2

हालांकि, पिरामिड की चौड़ाई भी कद्दू की संख्या से सीमित है: हम कद्दू p-1पर भूत से अधिक नहीं हो सकता है p। इसलिए कोड में प्रयुक्त अंतिम सूत्र:

j = ⌈(√(8g + 1) - 1) / 2⌉
G = max(0, min(p - 1, j))

ईएस 6 संस्करण, 173 171 166 बाइट्स

f=(p,g,j=Math.pow(g*2,.5)+.5|0,G=j>p-1?p?p-1:0:j,P=`
`,i=~j?g-G*++G/2:G,n=i>0?i>g?g:i:0)=>p|g?f(0,g-n,-1,G-1,P+'    ')+P+'((^v^)) '.repeat(p)+'\\{O.O}/ '.repeat(n):''

परीक्षण मामले (ES6)

f=(p,g,j=Math.pow(g*2,.5)+.5|0,G=j>p-1?p?p-1:0:j,P=`
`,i=~j?g-G*++G/2:G,n=i>0?i>g?g:i:0)=>p|g?f(0,g-n,-1,G-1,P+'    ')+P+'((^v^)) '.repeat(p)+'\\{O.O}/ '.repeat(n):''

console.log(f(0, 1));
console.log(f(1, 0));
console.log(f(1, 1));
console.log(f(2, 1));
console.log(f(2, 2));
console.log(f(3, 1));
console.log(f(3, 2));
console.log(f(3, 3));
console.log(f(0, 4));
console.log(f(3, 0));
console.log(f(7, 6));

Comments

मुझे लगता है कि j=(g+g)**.5+.5|0काम करना चाहिए।

— नील

अच्छी व्याख्या!

— AdmBorkBork

@ नील यह छोटा और अधिक विश्वसनीय है। (मेरी विधि में कुछ अमान्य मान थे, जो g = 5051 से शुरू हुआ।) धन्यवाद।

— Arnauld

Answer 2

पर्ल, 246 बाइट्स (नईलाइन कोड का हिस्सा नहीं हैं और केवल पठनीयता के लिए प्रदान की जाती हैं)

($c,$d)=<>=~/(\d+)/g;
$p="((^v^)) ";$g="\\{O.O}/ ";
for($f[0]=$c;$d>0;$d--){$f[$b+1]+1<$f[$b]?$f[++$b]++:$f[$b]++;$f[0]+=$d,$d=0 if$b==$c-1;$f[$b]==1?$b=0:1}
$h[0]=($p x$c).$g x($f[0]-$c);$h[$_].=$"x(4*$_).$g x$f[$_]for(1..$#f);
say join$/,reverse@h;

दो नंबर को स्वीकार करता है: पहले कद्दू, उसके बाद भूत। नमूना इनपुट:

5 20

नमूना उत्पादन:

                \{O.O}/ 
            \{O.O}/ \{O.O}/ 
        \{O.O}/ \{O.O}/ \{O.O}/ 
    \{O.O}/ \{O.O}/ \{O.O}/ \{O.O}/ 
((^v^)) ((^v^)) ((^v^)) ((^v^)) ((^v^)) \{O.O}/ \{O.O}/ \{O.O}/ \{O.O}/ \{O.O}/ \{O.O}/ \{O.O}/ \{O.O}/ \{O.O}/ \{O.O}/ \{O.O}/ 

Comments

ओह, आपने मेरे शब्दों को थोड़ा अलग तरीके से पढ़ा कि मैं किस तरह से इरादा कर रहा था - भूत केवल भूतों के शीर्ष पर ढेर कर सकते हैं यदि कोई कद्दू नीचे है, अन्यथा उन्हें सही सिंगल-फाइल पर जाने की आवश्यकता है। यही कारण है कि 0p 4gपरीक्षण के मामले में सभी भूतों को एक पंक्ति में रखा गया है, बजाय स्टैक्ड।

— AdmBorkBork

@TimmyD ठीक है, मैंने इसे अब ठीक कर दिया है। मैं इसे कम करने के लिए थोड़ा गोल्फिंग करने की आवश्यकता होगी।

— गेब्रियल बेनामी