ชุดค่าผสม Kakuro

เนื่องจากฉันไม่สามารถทำเลขในใจได้ฉันจึงมักจะต่อสู้กับปริศนาKakuroซึ่งต้องให้ผู้เสียหายซ้ำหลาย ๆ ตัวเลขที่อยู่ในช่วง 1 ถึง 9 (รวม) รวมกับตัวเลขอื่นในช่วง 1 ถึง 45 เมื่อคุณรู้ มีตัวเลขมากมาย ตัวอย่างเช่นหากคุณต้องการทราบวิธีรับ 23 จาก 3 หมายเลขคำตอบเดียวคือ 6 + 8 + 9 (นี่เป็นแนวคิดเดียวกับ Killer Sudoku หากคุณคุ้นเคย)

บางครั้งคุณจะมีข้อมูลอื่นเช่นหมายเลข 1 ไม่สามารถแสดงได้ดังนั้นเพื่อให้ได้ 8 ใน 2 หมายเลขคุณสามารถใช้ 2 + 6 และ 3 + 5 เท่านั้น (คุณไม่สามารถใช้ 4 + 4 เพราะพวกเขา ไม่ชัดเจน) หรืออาจเป็นได้ว่าคุณได้พบ 3 ในการแก้ปัญหาแล้วดังนั้นบางอย่างเช่น 19 ใน 3 หมายเลขต้องเป็น 3 + 7 + 9

งานของคุณคือการเขียนโปรแกรมที่แสดงวิธีการแก้ปัญหาที่เป็นไปได้ทั้งหมดเพื่อปัญหาที่กำหนดตามลำดับที่เข้มงวดในรูปแบบที่เข้มงวด

อินพุต

วิธีการแก้ปัญหาของคุณสามารถรับอินพุตเป็นสตริง ASCII เดี่ยวทั้งผ่าน stdin อาร์กิวเมนต์บรรทัดคำสั่งอาร์กิวเมนต์ของฟังก์ชันค่าที่เหลืออยู่บนสแต็กหรือสิ่งใดก็ตามที่คุณใช้ในภาษาลึกลับที่คุณชื่นชอบ สตริงอยู่ในรูปแบบ

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

ฉันตั้งใจแยกส่วนของอินพุตของความสนุกของคำถามนี้ นี่คือรหัสกอล์ฟอาจเป็นทางออกที่สั้นที่สุดที่จะชนะ

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

JavaScript (E6) 172 180 275 296

เป็นฟังก์ชั่น (ทดสอบได้) ที่มีอาร์กิวเมนต์ 1 สตริงและส่งคืนเอาต์พุตที่ร้องขอ หากต้องการให้ผลลัพธ์ที่แท้จริงกลับมาพร้อมกับการแจ้งเตือน () นับไบต์เดียวกัน แต่ระวังตัวอักษรการแจ้งเตือนไม่ใช่แบบ monospace

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 หรือ FireBug

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
}

Mathematica, 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และแปลงตัวเลขปัจจุบันเป็นการแทนสตริงและอื่น ๆ เป็นช่องว่าง จากนั้นฉันต่อทุกอย่างเข้าด้วยกัน

Groovy - 494 ตัวอักษร

คำตอบที่ใหญ่และไม่น่าสนใจ แต่ใช้ Google Guava เพื่อสร้าง "ชุดพลังงาน"

แข็งแรงเล่นกอล์ฟ:

@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}