काकुरो संयोजन

Question

काकुरो संयोजन

क्योंकि मैं मानसिक अंकगणित नहीं कर सकता, इसलिए मैं अक्सर काकोरो पहेली के साथ संघर्ष करता हूं , जिसके लिए पीड़ित को बार-बार काम करने की आवश्यकता होती है, जो कि 1 से 9 की रेंज में अलग-अलग संख्याओं (समावेशी) की संख्या 1 से 45 की संख्या में होती है जब आप जानते हैं कि कैसे कई नंबर हैं। उदाहरण के लिए, यदि आप जानना चाहते हैं कि 3 संख्याओं में से 23 कैसे प्राप्त करें, तो एकमात्र उत्तर 6 + 8 + 9 है (यह किलर सुडोकू के समान विचार है यदि आप इससे परिचित हैं)।

कभी-कभी आपके पास अन्य जानकारी होगी, जैसे कि नंबर 1 मौजूद नहीं हो सकता है, इस प्रकार केवल 2 संख्याओं में 8 प्राप्त करने के लिए, आप केवल 2 + 6 और 3 + 5 का उपयोग कर सकते हैं (आप 4 + 4 का उपयोग नहीं कर सकते, क्योंकि वे हैं अलग नहीं है)। वैकल्पिक रूप से, यह हो सकता है कि आप पहले से ही समाधान में एक 3 पा चुके हैं, और इसलिए 19 की तरह 3 संख्याओं में 3 + 7 + 9 होना चाहिए।

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

इनपुट

आपका समाधान एकल एएससीआईआई स्ट्रिंग के रूप में इनपुट प्राप्त कर सकता है , स्टड के माध्यम से, कमांड लाइन तर्क, फ़ंक्शन का तर्क, स्टैक पर छोड़ा गया मान या आपकी पसंदीदा गूढ़ भाषा जो भी पागलपन काम करती है। स्ट्रिंग फॉर्म में है

number_to_achieve number_of_numbers_required list_of_rejected_numbers list_of_required_numbers

पहले 2 तर्क विशिष्ट बेस -10 गैर-नकारात्मक गैर-शून्य पूर्णांक हैं, जो क्रमशः 1 से 45 और 1 से 9 सीमा में हैं (दशमलव बिंदु का उपयोग अमान्य इनपुट होगा), दो सूचियां केवल एक साथ बिना किसी परिसीमन के एक साथ फंसे हुए हैं। पुनरावृत्ति के बिना कोई विशेष आदेश, या '0' नहीं है अगर वे खाली सूची हैं। सूचियों (0 को छोड़कर) के बीच कोई साझा अंक नहीं हो सकता है। सीमांकक एकल रिक्त स्थान हैं।

उत्पादन

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

यदि कोई अमान्य इनपुट प्रदान किया जाता है तो मुझे परवाह नहीं है कि आपका कार्यक्रम क्या करता है, हालांकि मैं यह नहीं चाहता था कि यह मेरे बूट सेक्टर को शून्य कर दे।

उदाहरण

इस उदाहरण इनपुट के लिए

19 3 0 0

अपेक्षित आउटपुट होगा

5
 2     89
  3   7 9
   4 6  9
   4  78 
    56 8 

प्रत्येक "लापता" संख्या के स्थान पर रिक्त स्थान पर ध्यान दें, ये आवश्यक हैं; मैं उन जगहों के बारे में परेशान नहीं हूँ जिनके पास एक संख्या नहीं है (जैसे कि लापता 9s ऊपर)। आप मान सकते हैं कि आप जो भी प्रिंट कर रहे हैं वह मोनो-स्पेस फ़ॉन्ट का उपयोग करेगा। आदेश को भी नोट करें, जिसमें छोटे से छोटे अंकों के साथ समाधान को पहले सूचीबद्ध किया गया है, और फिर सबसे छोटे अगले सबसे छोटे अंक के साथ आदि।

एक अन्य उदाहरण, जो कि ऊपर दिया गया है, के आधार पर

19 3 57 9

अपेक्षित आउटपुट होगा

2
 2     89
   4 6  9

ध्यान दें कि हर परिणाम में एक 9 होता है, और किसी भी परिणाम में 5 या 7 नहीं होते हैं।

यदि कोई समाधान नहीं हैं, उदाहरण के लिए

20 2 0 0

फिर आपको बस एक लाइन को 0 पर आउटपुट देना चाहिए।

0

मैंने जानबूझकर इस प्रश्न के मज़े के इनपुट हिस्से को पार्स किया है। यह कोड-गोल्फ है, सबसे छोटी समाधान जीत हो सकती है।

Comments

+1 एस्प। "... के बजाय मैं अपने बूट सेक्टर को शून्य नहीं कर पाया।"

— माइकल ईस्टर

Answer 1

GolfScript, 88 वर्ण

~[[]]10,:T{{1$+}+%}/\{\0+`-!}+,\{0`+\`&!}+,\{\,=}+,\{\{+}*=}+,.,n@{1T>''*T@-{`/' '*}/n}/

GolfScript में सीधे-सीधे कार्यान्वयन। STDIN या स्टैक से इनपुट लेता है।

यहां कोड का परीक्षण किया जा सकता है ।

कुछ टिप्पणियों के साथ कोड:

### evaluate the input string
~                     

### build all possible combinations of 0...9
[[]]              # start with set of empty combination
10,:T             #
{                 # for 0..9
  {1$+}+%         #   copy each item of set and append current digit to this copy
}/                # end for

### only keep combination which the digits given as last argument (minus 0)
\{                # start of filter block
  \0+`            #   add zero to combination and make string out of it
  -!              #   subtract from last argument -> check argument contains any
                  #     excess characters
}+,               # end of filter block


### remove any combination which contains either 0 or any digit from 2nd last argument
\{                # start of filter block
  0`+             #   take argument and append 0
  \`              #   stringify combination
  &!              #   check if no characters are common
}+,               # end of filter block

### filter for correct length
\{                # start of filter block
  \,              #   calc length of combination
  =               #   check if equal to second argument
}+,               # end of filter block

### filter for correct sum
\{                # start of filter block
  \{+}*           #   sum all digits of combination
  =               #   compare with first argument
}+,               # end of filter block

### output
.,                # determine size of set
n                 # append newline
@{                # for each combination in set
  1T>''*          #   generate "123456789"
  T@-             #   generate anti-set of current combination  
  {`/' '*}/       #   replace (in the string) each digit within the 
                  #   anti-combination with a space characters
  n               #   append newline
}/                # end for

Answer 2

जावास्क्रिप्ट (E6) 172 180 275 296

1 स्ट्रिंग तर्क के साथ (परीक्षण योग्य) फ़ंक्शन और अनुरोधित आउटपुट लौटाता है। अलर्ट (), एक ही बाइट काउंट के साथ एक वास्तविक आउटपुट परिवर्तन वापसी के लिए, लेकिन सावधान रहें, अलर्ट फ़ॉन्ट मोनोस्पेस नहीं है।

F=i=>{
  [t,d,f,m]=i.split(' ');
  for(l=0,r='',k=512;--k;!z&!h&!o&&(++l,r+=n))
    for(z=n='\n',h=d,o=t,b=i=1;i<=9;b+=b)
      z-=~(b&k?(--h,o-=i,n+=i,f):(n+=' ',m)).search(i++);
  return l+r
}

फायरफॉक्स या फायरबग कंसोल में टेस्ट करें

console.log(['19 3 0 0','19 3 57 9','19 3 57 4','20 2 0 0'].map(x=>'\n'+x+'\n' +F(x)).join('\n'))

परीक्षण उत्पादन:

19 3 0 0
5
 2     89
  3   7 9
   4 6  9
   4  78 
    56 8 

19 3 57 9
2
 2     89
   4 6  9

19 3 57 4
1
   4 6  9

20 2 0 0
0

Ungolfed

F=i=>{
  [target, digits, forbidden, mandatory]=i.split(' ')

  result = '', nsol=0
  for (mask = 0b1000000000; --mask > 0;)
  {
    cdigits = digits
    ctarget = target
    bit = 1
    numbers = ''
    for (digit = 9; digit > 0; bit += bit, digit--)
    {

      if (bit & mask)
      {
        if (forbidden.search(digit)>=0) break;
        cdigits--;
        ctarget -= digit;
        numbers = digit + numbers;
      }
      else
      {
        if (mandatory.search(digit)>=0) break;
        numbers = ' '+numbers;
      }
    }
    if (ctarget==0 && cdigits == 0)
    {
        result += '\n'+numbers
        nsol++
    }
  }
  return nsol + result
}

Answer 3

गणितज्ञ, 239 बाइट्स

(मैं मानता हूं कि मैंने इस पर काम करना शुरू कर दिया, जबकि यह अभी भी सैंडबॉक्स में था।)

{t,n,a,b}=FromDigits/@StringSplit@i;Riffle[c=Cases[Union/@IntegerPartitions[t,n,Complement[r=Range@9,(d=IntegerDigits)@a]],k_/;(l=Length)@k==n&&(b==0||l[k⋂d@b]>0)];{(s=ToString)@l@c}~Join~((m=#;If[m~MemberQ~#,s@#," "]&/@r)&/@c),"\n"]<>""

Ungolfed

{t, n, a, b} = FromDigits /@ StringSplit@i;
Riffle[
  c = Cases[
    Union /@ IntegerPartitions[
      t, n, Complement[r = Range@9, (d = IntegerDigits)@a
       ]
      ],
    k_ /; (l = Length)@k == 
       n && (b == 0 || l[k ⋂ d@b] > 0)
    ];
  {(s = ToString)@l@c}~
   Join~((m = #; If[m~MemberQ~#, s@#, " "] & /@ r) & /@ c),
  "\n"] <> ""

यह इनपुट स्ट्रिंग को स्टोर किए जाने की उम्मीद करता है i।

यह काफी सीधा है। सबसे पहले, इनपुट पार्सिंग। फिर मैं IntegerPartitionsयह पता लगाने के लिए उपयोग करता हूं कि मैं पहले नंबर को अनुमत संख्याओं में कैसे विभाजित कर सकता हूं। फिर मैं सभी विभाजनों को फ़िल्टर करता हूं जो डुप्लिकेट का उपयोग करते हैं या आवश्यक संख्याओं को शामिल नहीं करते हैं। और फिर प्रत्येक समाधान के लिए मैं से एक सूची बनाने के 1लिए 9और रिक्त स्थान में अपने स्ट्रिंग प्रतिनिधित्व में वर्तमान संख्या और दूसरों को परिवर्तित। और फिर मैंने सब कुछ समेट लिया।

Answer 4

ग्रूवी - 494 वर्ण

बड़ा, बिना उत्तर वाला उत्तर, लेकिन यह "पावर सेट" उत्पन्न करने के लिए Google अमरूद का उपयोग करता है।

golfed:

@Grab(group='com.google.guava', module='guava', version='17.0')
m=(args.join(" ")=~/(\d+) (\d+) (\d+) (\d+)/)[0]
i={it as int}
n=i(m[1])
r=i(m[2])
j=[]
m[3].each{if(i(it))j<<i(it)}
q=[]
m[4].each{if(i(it))q<<i(it)}
d=1..9 as Set<Integer>
t=[]
com.google.common.collect.Sets.powerSet(d).each{x->
if(x.sum()==n&&x.size()==r&&x.disjoint(j)&&x.containsAll(q)) {
s="";for(i in 0..8){if(x.contains(i+1)){s+=(i+1) as String}else{s+=" "}};t<<s}
}
p={println it}
p t.size()
t.sort().reverse().each{p it}

नमूना चलता है:

$ groovy K.groovy 19 3 0 0 
5
 2     89
  3   7 9
   4 6  9
   4  78 
    56 8 
$ groovy K.groovy 19 3 5 0 
4
 2     89
  3   7 9
   4 6  9
   4  78 
$ groovy K.groovy 19 3 5 9
3
 2     89
  3   7 9
   4 6  9
$ groovy K.groovy 20 2 0 0 
0

Ungolfed:

@Grab(group='com.google.guava', module='guava', version='17.0')

m=(args.join(" ")=~/(\d+) (\d+) (\d+) (\d+)/)[0]
i={it as int}
n=i(m[1])
r=i(m[2])

j=[]
m[3].each{if(i(it))j<<i(it)}
q=[]
m[4].each{if(i(it))q<<i(it)}

d=1..9 as Set<Integer>
t=[]

com.google.common.collect.Sets.powerSet(d).each{ x ->
    if(x.sum()==n && x.size()==r && x.disjoint(j) && x.containsAll(q)) {
        s=""
        for(i in 0..8) {
            if(x.contains(i+1)){s+=(i+1) as String}else{s+=" "}
        }
        t<<s
    }
}

p={println it}
p t.size()
t.sort().reverse().each{p it}