도전

N28 이상의 양의 정수 가 주어지면 N각 숫자 1를 7정확히 한 번만 사용하여 합산되는 숫자 목록을 출력하십시오 . 프로그램이나 기능으로 줄 수 있습니다.

반복하지 않고 각 숫자를 한 번만 사용하는 한 숫자는 저절로 표시되거나 연결될 수 있습니다. 예를 들어, and [12, 34, 56, 7]는 유효 하지만 or 는 유효 하지 않습니다 . 숫자가 나열된 순서는 중요하지 않습니다.[1, 27, 6, 4, 35][1234, 567][123, 34567][3, 2, 1476]

경우 N1-7으로 할 수 없다 반환하거나 출력 아무것도.

기타 정보

• 이것은 코드 골프이므로 목요일 10 월 15 일 목요일까지 가장 짧은 바이트 코드가 이깁니다.

• 의견에 질문을하십시오.

• 내가 도전에 명시하지 않은 것은 당신에게 달려 있습니다.

• 표준 허점은 허용되지 않습니다.

예

이로 인해 혼란이 사라질 수 있습니다.

입력

28

산출

[1, 2, 3, 4, 5, 6, 7]

입력

100

산출

[56, 7, 4, 31, 2]

입력

1234567

산출

[1234567]

입력

29

산출

아무것도, 29 유효하지 않습니다.

입력

1891

산출

[1234, 657]

입력

370

산출

[15, 342, 7, 6]

필요한 경우 더 많이 만들 것입니다.

다음 은 FryAmTheEggman이 제공 한이 7 개의 숫자로 생성 된 가능한 모든 숫자의 pastebin입니다.

Pyth, 18 14 바이트

hfqSjkTjkS7./Q

2 바이트를 골라 내고 2 개 더 길을 포장 한 @isaacg에게 감사드립니다.

출력을 생성하지 않으면 코드가 작동하지 않아 출력이 생성되지 않습니다.

이것은 환자가 충분히 작은 경우 작은 입력에, 충분한 시간과 메모리가 주어지면 더 큰 입력에 작동합니다.

의도 한대로 코드, 당신은을 대체 할 수있는 제대로 작동하는지 확인하려면 7에 3대한 3까지 숫자 1의 합계 . 테스트 스위트를 보려면 여기 를 클릭 하십시오 .

예제 실행

$ time pyth/pyth.py -c 'hfqSjkTjkS7./Q' <<< 28
(1, 2, 3, 4, 5, 6, 7)

real    4m34.634s
user    4m34.751s
sys     0m0.101s
$ time pyth/pyth.py -c 'hfqSjkTjkS7./Q' <<< 29 2>/dev/null

real    9m5.819s
user    9m6.069s
sys     0m0.093s

작동 원리

           ./Q    Compute all integer partitions of the input.
 f                Filter the integer partitions:
    jkT             Join the integers with empty separator.
   S                Sort the characters of the resulting string.
      jkS7          Join [1, ..., 7] with empty separator.
  q                 Check both results for equality.
                  Keep the partition of `q' returned True.
h                 Retrieve the first element of the filtered list.
                  For a non-empty list, this retrieves the solution.
                  For the empty list, it causes an error and produces no output.

파이썬 3, 109

def f(n,s=set('1234567'),l='0,'):[f(n,s-{x},l+x+c)for c in(',','')for x in s]or n-sum(eval(l))or~print(l[2:])

숫자를 받아서 튜플을 출력하는 함수 123,4567, . 예, 이것은 유효한 튜플입니다.

아이디어는 같은 가능한 모든 문자열을 생성하는 것입니다 43,126,7,5,숫자가 그 1통해 7연속없는 두 개의 쉼표로 쉼표로 구분합니다. 이 표현식을 튜플로 평가하고 그 합은과 같고 n인쇄하여 오류로 종료하십시오.

이러한 모든 문자열을 만들기 위해 세트를 추적합니다. s 사용할 문자 를 쉼표로 각 문자를 적용하여 숫자를 입력을 끝내거나 제거하지 않고 미래 숫자를 연결합니다.

단락은 확인하는 데 사용되는 s목록-빌려 비어 있기 때문에 비어, 그것은 n==sum(eval(l)),이 경우 우리는 인쇄 l복용에 의해 오류와 함께 종료 ~의None 반환 된 값 합니다 (Sp3000 덕분에).

Python 3.5에서는 s={*'1234567'}Sp3000 덕분 에 두 개의 문자를 작성하여 저장할 수 있다고 생각합니다 .

숯을 먹는 작은 성가심이 있습니다. 하나는 쉼표가없는 l것처럼 보이는 경우 1234567단일 숫자로 구문 분석되고 호출 sum하면 오류가 발생한다는 것입니다. 이것은 l요소 로 시작 하여 0인쇄 할 때 제거 하는 핵으로 처리됩니다 . 이 비용은 6 자입니다.

파이썬 3에서는이 튜플을 알몸으로 만들 수 없으므로 c쉼표와 빈 문자열을 반복 하는 것은 성가신 for c in(',','')일입니다. 나는 어떤 문자가있을 싶습니다 ?할 수 무시됩니다 ',?'4 개 문자 적은 있지만, 이러한 문자있을 것 같지 않습니다.

오래된 방법 :

파이썬 2, 117

def f(n,s={1,2,3,4,5,6,7},l=[],p=0):
 if{n,p}|s=={0}:print l;1/0
 if p:f(n-p,s,l+[p])
 for x in s:f(n,s-{x},l,p*10+x)

숫자를 가져 와서 목록을 인쇄하는 함수를 정의합니다.

아이디어는 재귀를 사용하여 모든 분기를 시도하는 것입니다. 변수 트랙은

• n필요한 나머지 금액
• 자릿수 s사용할 나머지
• 리스트 l지금까지 만들어진 숫자
• 현재 부분적으로 형성된 숫자 p

때 n==0와 s비어, 인쇄l 및 오류로 종료합니다.

현재 부분적으로 형성된 숫자 인 경우 p 가 0이 아닌 경우 목록에 추가하고 나머지 합계에서 제거하십시오.

x에서 사용할 수있는 각 숫자에 대해 숫자 를 s추가 p하고 제거해 보십시오 s.

피 이스, 23

#iRThfqQsiR10Ts./M.pS7q

온라인에서 너무 느린 순진한 무차별 공격이 내 컴퓨터에서 1 분 정도 걸립니다. 결과 필터링 된 조합 목록에 액세스하면와 같은 불가능한 숫자에 대한 오류가 발생하는 pyth golf의 일반적인 "예외까지 영원히 반복"패턴을 사용합니다 29.

pythonic list와 같은 출력

1891
[1234, 657]
100
[1, 2, 34, 56, 7]
370
[12, 345, 6, 7]

이 방법으로 만들 수있는 모든 10136 숫자 의 붙여 넣기 는 다음과 같습니다 .

파이썬 2.7, 178 172 169 바이트

n=input()
for i in range(8**7):
 for j in len(set('%o0'%i))/8*range(128):
    s=''
    for c in'%o'%i:s+='+'[:j%2*len(s)]+c;j/=2
    if eval(s)==n:print map(int,s.split('+'));1/0

마지막 세 줄은 탭으로 들여 쓰기가되어 있지만이 편집기에서 그렇게하는 방법을 알 수는 없습니다.

편집 : Sp3000을 사용하여 하나의 중첩 레이어를 평평하게했습니다.

자바 스크립트 (ES6), 165 196

편집 약간 단축되었습니다. 를 사용 eval하면 더 짧을 수는 있지만 빠르기를 좋아합니다.

야만적 인 힘, Pith 버전보다 수치가 길지만 빠릅니다. EcmaScript 6 호환 브라우저에서 아래 스 니펫을 테스트하십시오.

f=z=>{for(r=i=1e6;r&&++i<8e6;)for(m=/(.).*\1|[089]/.test(w=i+'')?0:64;r&&m--;t.split`+`.map(v=>r-=v,r=z))for(t=w[j=0],l=1;d=w[++j];l+=l)t+=l&m?'+'+d:d;return r?'':t}

function test() { O.innerHTML=f(+I.value) }

test()

// Less golfed

f=z=>{
  for(r=i=1e6; r&&++i<8e6;)
    for(m=/(.).*\1|[089]/.test(w=i+'')?0:64; r&&m--; t.split`+`.map(v=>r-=v,r=z))
      for(t=w[j=0],l=1;d=w[++j];l+=l)
        t+=l&m?'+'+d:d;
  return r?'':t
}

<input id=I value=28><button onclick=test()>-></button><span id=O></span>

파이썬 2 270 268 바이트

from itertools import*;P=permutations
x,d,f=range(1,8),[],input()
r=sum([[int(''.join(str(n)for n in i))for i in list(P(x,j))]for j in x],[])
z=1
while z:
 t=sum([[list(j)for j in P(r,z)]for i in x],[])
 v=filter(lambda i:sum(i)==f,t)
 if v:print v[0];break
 else:z+=1

아직도 골프를하고 있습니다.

일치하는 것을 찾을 때까지 반복됩니다.

하스켈 (145 바이트)

main=getLine>>=print.head.f[1..7].read
f[]0=[[]]
f b s=[n:j|(n,g)<-m b,j<-f g$s-n]
m b=[(d+10*z,g)|d<-b,(z,g)<-(0,filter(/=d)b):m(filter(/=d)b)]

재귀를 사용합니다.

언 골프 (337 바이트) :

delete d = filter (/= d)
main = getLine >>= print . (`form` [1..7]) . read

form s [] | s == 0    = [[]]
form s ds | s <= 0    = []
form s ds | otherwise = [n:ns | (n, ds') <- makeNumbers ds, ns <- form (s-n) ds']

makeNumbers [] = []
makeNumbers ds  = [(d + 10 * n',ds') | d <- ds, (n',ds') <- (0,delete d ds):makeNumbers (delete d ds)]

스칼라, 195 바이트

이것은 가장 효율적이지 않으며 29 분 동안 출력을 얻는 데 15 분이 걸렸지 만 작동합니다.

def g(s: Seq[Int]): Iterator[Seq[Int]]=s.combinations(2).map(c=>g(c.mkString.toInt +: s.filterNot(c.contains))).flatten ++ Seq(s)
def f(i: Int)=(1 to 7).permutations.map(g).flatten.find(_.sum==i)

여기 약간의 출력이 있습니다

scala> f(100)
res2: Option[Seq[Int]] = Some(Vector(46, 35, 12, 7))

scala> f(1891)
res3: Option[Seq[Int]] = Some(Vector(567, 1324))

scala> f(370)
res4: Option[Seq[Int]] = Some(Vector(345, 12, 6, 7))

scala> f(29)
res5: Option[Seq[Int]] = None

루비, 105 바이트

무차별 대입! 1에서 7654321 사이의 정수 중 0에서 7 사이의 모든 길이의 하위 집합을 확인하고이 중 하나가 기준과 일치하는지 확인합니다. 아마도 이것이 종료되기를 원하지 않을 것입니다.

->n{8.times{|i|[*1..7654321].permutation(i){|x|return x if
x.join.chars.sort==[*?1..?7]&&eval(x*?+)==n}}}

알고리즘을 실행하고 확인하려면 7654321답에있는 가장 큰 숫자 로 바꾸어 검색 공간을 좁힐 수 있습니다. 예를 들어 n = 100은 56, n = 1891은 1234입니다. 후자의 시범 운영은 다음과 같습니다.

$ ruby -e "p ->n{8.times{|i|[*1..1234].permutation(i){|x|return x if x.join.chars.sort==[*?1..?7]&&eval(x*?+)==n}}}[gets.to_i]" <<< 1891
[657, 1234]