कोआलास, क्रैब्स और कॉमपिलर

Question

दो सकारात्मक पूर्णांक X और Y को देखते हुए, निम्न तीन ASCII- कला जानवरों के किसी भी संयोजन का उत्पादन करते हैं, जैसे कि आउटपुट में सटीक रूप से X अल्पविराम ( ,) और Y अवधियाँ ( .), यदि यह संभव है।

1. कोअला: 1 अल्पविराम, 2 अवधियों

   <.,.>
   

2. केकड़ा: 2 अल्पविराम, 2 अवधि

   ,<..>,
   

3. कमलापिलर: 3 या अधिक अल्पविराम, 1 अवधि

   <,,,.>
   

   या <,,,,.>या <,,,,,.>या <,,,,,,.>या <,,,,,,,.>आदि

अगर इन जानवरों का कोई संयोजन बिल्कुल एक्स कॉमा और वाई अवधि का उत्पादन नहीं कर सकता है, तो एक एकल कमेलोन का उत्पादन करें जो विफलता का सामना करेगा।

~<.,,>~~

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

उदाहरण के लिए, X = 7, Y = 5 के लिए, ये सभी वैध आउटपुट होंगे (खाली लाइनों द्वारा अलग किए गए):

<.,.> <.,.> <,,,,,.>

<.,.>
<,,,,,.>
<.,.>

,<..>, <.,.> <,,,,.>

<,,,,.>
,<..>,
<.,.>

,<..>, <,,,.> ,<..>,

[",<..>,", ",<..>,", "<,,,.>"] (list syntax depends on language)

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

एक्स = 3, वाई = 3 या एक्स = 1, वाई = 5 जैसे इनपुट के लिए जहां कोई समाधान नहीं है, आउटपुट हमेशा रहेगा

~<.,,>~~

शायद एकल-तत्व सूची में।

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

Comments

कोआला जैसा दिखता है :-)

— लुइस मेंडो

मैंने एक छोटा प्रोग्राम बनाया जो प्रत्येक जोड़ी (एक्स, वाई) के लिए संयोजनों की संख्या को आउटपुट करता है। दुर्भाग्य से, मैं इसे केवल (128, 128) तक चला सकता था, क्योंकि यह अधिकतम के बारे में है __int128और मैं एक आकर्षक पुस्तकालय का उपयोग करने के लिए बहुत आलसी था। यहाँ CSV डंप है: pastebin.com/ght5xkRu पहली पंक्ति और कॉलम X और Y मान हैं

— Fytch

Answer 1

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

लैम्ब्डा फ़ंक्शन, x और y को तर्कों के रूप में लेता है और एक स्ट्रिंग देता है

->x,y{c=y-2*n=y-(x>y ?1:0)>>1
x+=-c/2*s=[x-n,c*3].max
x<n||x>n*2?'~<.,,>~~':',<..>, '*(x-n)+'<.,.> '*(2*n-x)+"<%s.> "*c%[?,*s-=c/2*3,?,*3]}

यदि कोई समाधान मौजूद है, तो यह सभी कोआला + कमलापर्स या सभी कोआला + केकड़ों के साथ किया जा सकता है।

सिद्धांत है कि कम से कम कमलापर्स का उपयोग किया जाए। यदि संख्या विषम है, तो हम 1 कमलापार का उपयोग करते हैं। यहां तक ​​कि अगर हम पीरियड्स की तुलना में अधिक कॉमा होते हैं, तो हम 0 कॉमपिलर का उपयोग करते हैं, जिस स्थिति में हम 2 का उपयोग करते हैं।

नॉनकमपिलर (केकड़ों + कोलों) में उपयोग की जाने वाली अवधियों की संख्या आवश्यक रूप से समान है, और नॉनकमपिलर की संख्या आधी है (number of periods)-(number of commapillars)। यदि सभी कोयल के लिए अपर्याप्त अल्पविराम हैं, या सभी केकड़ों के लिए बहुत सारे हैं, तो कोई समाधान संभव नहीं है। अन्यथा, हम एक समाधान लौटाते हैं।

परीक्षण कार्यक्रम में टिप्पणी की

स्पष्टता के लिए गिरगिट के बजाय "विफल" का उपयोग करता है

f=->x,y{c=y-2*n=y-(x>y ?1:0)>>1
#n=noncommapillars=y>>1 as they have 2 periods. c=commapillars=y-2*n, 1 for odd y, 0 for even y.
#if x>y there are too many commas to have 0 commapillars for even y. noncommapillars= y-1 >> 1, so 2 commapillars

x+=-c/2*s=[x-n,c*3].max
# s=number of commas allocated to commapillars. x-n to allow all noncommapillars to be koalas, but at least 3 per commapillar.
#-c/2 == -1 if there are commapillars, 0 if not (Ruby truncates toward -inf). Subtract commas for commapillars from x if necessary

x<n||x>n*2?'fail':',<..>, '*(x-n)+'<.,.> '*(2*n-x)+"<%s.> "*c%[?,*s-=c/2*3,?,*3]}
#if x<n (insufficient commas for all koalas) or x>n*2 (too many for all crabs) return fail. Else...
#return string off crabs, koalas, and (using % operator like sprintf) c commapillars (0..2), the second with 3 commas (if present) and the first with the rest.  



10.times{|j|10.times{|i|puts "%-20s %s"%[?.*j+?,*i,f[i,j]]}}
#all x,y from 0..9

उत्पादन

,                    fail
,,                   fail
,,,                  fail
,,,,                 fail
,,,,,                fail
,,,,,,               fail
,,,,,,,              fail
,,,,,,,,             fail
,,,,,,,,,            fail
.                    fail
.,                   fail
.,,                  fail
.,,,                 <,,,.>
.,,,,                <,,,,.>
.,,,,,               <,,,,,.>
.,,,,,,              <,,,,,,.>
.,,,,,,,             <,,,,,,,.>
.,,,,,,,,            <,,,,,,,,.>
.,,,,,,,,,           <,,,,,,,,,.>
..                   fail
..,                  <.,.>
..,,                 ,<..>,
..,,,                fail
..,,,,               fail
..,,,,,              fail
..,,,,,,             <,,,.> <,,,.>
..,,,,,,,            <,,,,.> <,,,.>
..,,,,,,,,           <,,,,,.> <,,,.>
..,,,,,,,,,          <,,,,,,.> <,,,.>
...                  fail
...,                 fail
...,,                fail
...,,,               fail
...,,,,              <.,.> <,,,.>
...,,,,,             <.,.> <,,,,.>
...,,,,,,            <.,.> <,,,,,.>
...,,,,,,,           <.,.> <,,,,,,.>
...,,,,,,,,          <.,.> <,,,,,,,.>
...,,,,,,,,,         <.,.> <,,,,,,,,.>
....                 fail
....,                fail
....,,               <.,.> <.,.>
....,,,              ,<..>, <.,.>
....,,,,             ,<..>, ,<..>,
....,,,,,            fail
....,,,,,,           fail
....,,,,,,,          <.,.> <,,,.> <,,,.>
....,,,,,,,,         <.,.> <,,,,.> <,,,.>
....,,,,,,,,,        <.,.> <,,,,,.> <,,,.>
.....                fail
.....,               fail
.....,,              fail
.....,,,             fail
.....,,,,            fail
.....,,,,,           <.,.> <.,.> <,,,.>
.....,,,,,,          <.,.> <.,.> <,,,,.>
.....,,,,,,,         <.,.> <.,.> <,,,,,.>
.....,,,,,,,,        <.,.> <.,.> <,,,,,,.>
.....,,,,,,,,,       <.,.> <.,.> <,,,,,,,.>
......               fail
......,              fail
......,,             fail
......,,,            <.,.> <.,.> <.,.>
......,,,,           ,<..>, <.,.> <.,.>
......,,,,,          ,<..>, ,<..>, <.,.>
......,,,,,,         ,<..>, ,<..>, ,<..>,
......,,,,,,,        fail
......,,,,,,,,       <.,.> <.,.> <,,,.> <,,,.>
......,,,,,,,,,      <.,.> <.,.> <,,,,.> <,,,.>
.......              fail
.......,             fail
.......,,            fail
.......,,,           fail
.......,,,,          fail
.......,,,,,         fail
.......,,,,,,        <.,.> <.,.> <.,.> <,,,.>
.......,,,,,,,       <.,.> <.,.> <.,.> <,,,,.>
.......,,,,,,,,      <.,.> <.,.> <.,.> <,,,,,.>
.......,,,,,,,,,     <.,.> <.,.> <.,.> <,,,,,,.>
........             fail
........,            fail
........,,           fail
........,,,          fail
........,,,,         <.,.> <.,.> <.,.> <.,.>
........,,,,,        ,<..>, <.,.> <.,.> <.,.>
........,,,,,,       ,<..>, ,<..>, <.,.> <.,.>
........,,,,,,,      ,<..>, ,<..>, ,<..>, <.,.>
........,,,,,,,,     ,<..>, ,<..>, ,<..>, ,<..>,
........,,,,,,,,,    <.,.> <.,.> <.,.> <,,,.> <,,,.>
.........            fail
.........,           fail
.........,,          fail
.........,,,         fail
.........,,,,        fail
.........,,,,,       fail
.........,,,,,,      fail
.........,,,,,,,     <.,.> <.,.> <.,.> <.,.> <,,,.>
.........,,,,,,,,    <.,.> <.,.> <.,.> <.,.> <,,,,.>
.........,,,,,,,,,   <.,.> <.,.> <.,.> <.,.> <,,,,,.>

Answer 2

Befunge, 249 218 बाइट्स

&::00p&::00g\`-2/:20p2*-3*:30p\20g-`:!00g20g-*\30g*+:30g-v>:#,_@
"~<.,,>~~"0_v#\g03+`g050`\0:-g02\p05:-\*2g02:-*/6+3g03p04<^
$"<">:#,_40p>:!#|_3-0" >.,,"40g3>3g#<\#-:#1_
0" ,>..<,">:#,_$>:!#|_1-
#@_1-0" >.,.<">:#,_$>:!

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

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

Answer 3

सी # 6, 321 303 बाइट्स

using System.Linq;string F(int x,int y)=>S(x,y)??"~<.,,>~~";string S(int x,int y)=>x<0|y<0?null:y<1?x<1?"":null:y*3>x?S(x-1,y-2)!=null?S(x-1,y-2)+"<.,.> ":S(x-2,y-2)!=null?S(x-2,y-2)+",<..>, ":null:string.Concat(new int[y].Select((_,k)=>k<1?C(x-y*3+3):C(3)));string C(int x)=>$"<{new string(',',x)}.> ";

पुकारते हैं F()। अन्य दो कार्य सहायक हैं। repl.it डेमो

// Coalesce failed combinations with commaleon
string F(int x,int y)=>S(x,y)??"~<.,,>~~";
// Get successful combination or null
string S(int x,int y)=>
    x<0|y<0
        // Fail: Out of range
        ?null
        :y<1
            ?x<1
                // Successful: All commas and periods accounted for
                ?""
                // Fail: Not enough periods for commas
                :null
            :y*3>x
                // Not all commapillars
                ?S(x-1,y-2)!=null
                    // Try koala
                    ?S(x-1,y-2)+"<.,.> "
                    // Try crab
                    :S(x-2,y-2)!=null
                        ?S(x-2,y-2)+",<..>, "
                        // Epic fail
                        :null
                // All commapillars
                :string.Concat(new int[y].Select((_,k)=>k<1
                    // This commapillar takes most of commas
                    ?C(x-y*3+3)
                    // The rest each takes 3
                    :C(3)));
// Generate single commapillar
string C(int x)=>$"<{new string(',',x)}.> ";