কাকুরো কম্বিনেশনস

Question

কাকুরো কম্বিনেশনস

যেহেতু আমি মানসিক পাটিগণিত করতে পারি না, তাই আমি প্রায়শই কাকুরো ধাঁধাটির সাথে লড়াই করি , যার জন্য ভুক্তভোগীর জন্য বার বার কাজ করা প্রয়োজন যা 1 থেকে 9 পরিসরের মধ্যে পৃথক সংখ্যাগুলি 1 সহ 45 এর মধ্যে অন্য সংখ্যার সমষ্টি, যখন আপনি জানেন কীভাবে অনেক সংখ্যা আছে। উদাহরণস্বরূপ, আপনি যদি 3 নম্বর থেকে 23 কীভাবে পেতে চান তা জানতে চাইলে কেবল উত্তরটি 6 + 8 + 9. হয় (আপনি যদি এর সাথে পরিচিত হন তবে এটি হত্যাকারী সুডোকু হিসাবে একই ধারণা)।

কখনও কখনও আপনি যেমন যে সংখ্যা আরও 1 টি তথ্য, থাকবে না পারেন, মাত্র 2 সংখ্যায় 8 অর্জনে উপস্থিত থাকা, এইভাবে, আপনি শুধুমাত্র 2+ 6 এবং 3 +5 ব্যবহার করতে পারেন (আপনি 4 +4 ব্যবহার করতে পারবেন না, কারণ তারা স্বতন্ত্র নয়)। বিকল্পভাবে, এটি হতে পারে যে আপনি ইতিমধ্যে সমাধানটিতে একটি 3 পেয়েছেন, এবং তাই 3 সংখ্যায় 19 এর মতো কিছু অবশ্যই 3 + 7 + 9 হওয়া উচিত।

আপনার কাজ হ'ল একটি প্রোগ্রাম লিখুন যা একটি নির্দিষ্ট আদেশে, কঠোর বিন্যাসে, কঠোর বিন্যাসে, প্রদত্ত সমস্যার সমস্ত সম্ভাব্য সমাধানের তালিকা করে।

ইনপুট

আপনার সমাধানটি স্ট্যান্ডিন, একটি কমান্ড লাইন আর্গুমেন্ট, কোনও ক্রিয়াকলাপের জন্য একটি যুক্তি, স্ট্যাকের উপর একটি মূল্য রেখে যাওয়া বা আপনার পছন্দসই রহস্যময় ভাষাতে যে পাগলামি ব্যবহার করে তা একক ASCII স্ট্রিং হিসাবে ইনপুটগুলি গ্রহণ করতে পারে । স্ট্রিং ফর্ম হয়

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

গল্ফস্ক্রিপ্ট, 88 টি অক্ষর

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

গল্ফস্ক্রিপ্টে একটি সরাসরি-ফরওয়ার্ড বাস্তবায়ন। 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
}

টেস্ট ইন Firefox বা ফায়ারবাগ কনসোলটি

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 অক্ষর

বৃহত্তর, অপ্রয়োজনীয় উত্তর, তবে এটি "পাওয়ার সেট" তৈরি করতে গুগল পেয়ারা ব্যবহার করে।

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}