카쿠로 조합

내가 정신 산술을 할 수 없기 때문에, 나는 종종 Kakuro Puzzle을 사용하여 어려움을 겪습니다. 많은 숫자가 있습니다. 예를 들어, 3 개의 숫자에서 23을 얻는 방법을 알고 싶다면 6 + 8 + 9입니다. (이것은 익숙한 Killer Sudoku와 동일합니다).

때로는 숫자 1 이 존재할 수 없다는 것과 같은 다른 정보가있을 수 있습니다. 따라서 단지 2 숫자로 8을 달성하려면 2 + 6과 3 + 5 만 사용할 수 있습니다 (4 + 4는 사용할 수 없으므로 구별되지 않음). 또는 솔루션에서 3을 이미 찾았을 수 있으므로 3에서 19와 같은 숫자는 3 + 7 + 9 여야합니다.

주어진 문제에 대한 가능한 모든 솔루션을 엄격한 순서로 엄격한 레이아웃으로 나열하는 프로그램을 작성해야합니다.

입력

솔루션은 stdin, 명령 행 인수, 함수에 대한 인수, 스택에 남아있는 값 또는 좋아하는 밀교 언어가 사용하는 모든 광기를 통해 단일 ASCII 문자열 로 입력을 수신 할 수 있습니다. 문자열은 형태입니다

number_to_achieve number_of_numbers_required list_of_rejected_numbers list_of_required_numbers

처음 2 개의 인수는 각각 1-45 및 1-9 범위의 음수가 아닌 0이 아닌 정수인 10 진수입니다 (소수점을 사용할 경우 입력이 유효하지 않습니다). 두 목록은 숫자를 구분없이 묶은 숫자입니다. 반복없이 특정 순서가 없거나 빈 목록 인 경우 '0' 목록 간에는 공유 숫자를 사용할 수 없습니다 (0 제외). 분리 문자는 단일 공백입니다.

산출

출력은 가능한 솔루션 수를 포함하는 라인으로 시작해야합니다. 프로그램은 점점 증가하는 각 숫자로 정렬 된 줄 바꿈으로 구분 된 솔루션을 인쇄해야합니다. 여기서 각 숫자는 1에서 9까지의 숫자를 나열한 경우의 위치에 배치됩니다. 아래 예제를 사용하면 더 명확하게 알 수 있습니다.

잘못된 입력이 제공되면 프로그램이 수행하는 작업에 신경 쓰지 않지만 부트 섹터는 0이 아닙니다.

예

이 예제에서는 입력

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

자바 스크립트 (E6) 172180277596

1 개의 문자열 인수가 있고 요청 된 출력을 반환하는 (테스트 가능한) 함수입니다. 동일한 바이트 수인 alert ()을 사용하여 실제 출력 변경을 반환하지만 경고 글꼴은 고정 폭이 아닙니다.

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

언 골프

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
}

수학, 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"]<>""

언 골프

{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공백에 자신의 문자열 표현으로 본 숫자와 다른 사람을 변환합니다. 그리고 나는 모든 것을 연결합니다.

그루비-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

언 골프 드 :

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