배경

가상의 골 페니 스탄 국가의 공식 통화는 foo 이며, 3 개의 동전, 7 개의 동전 및 8 개의 동전이 유통되고 있습니다. 이 동전을 사용하여 4 foos와 같은 특정 금액을 지불하는 것이 불가능하다는 것을 알 수 있습니다. 그럼에도 불구하고, 충분히 많은 양이 형성 될 수있다. 당신의 임무는 동전 (이 경우 5 foos)으로 형성 할 수없는 가장 큰 금액을 찾는 것 입니다. 이 동전 문제는 .

입력

귀하의 입력은 양의 정수 목록 이며 순환 동전의 가치를 나타냅니다. 그것에 대해 두 가지가 보장됩니다.L = [n1, n2, ..., nk]

• 요소의 GCD L는 1입니다.
• L 숫자 1을 포함하지 않습니다.

그것은 분류되지 않았거나 중복을 포함 할 수 있습니다 (특별 판 동전을 생각하십시오).

산출

의 GCD L가 1이므로, 충분히 큰 정수 m는 모두 요소의 음이 아닌 선형 조합으로 표현 될 수 있습니다. 다시 말해, 우리는

 m = a1*n1 + a2*n2 + ... + ak*nk 

일부 정수의 경우 . 출력은 이 형식으로 표현할 수없는 가장 큰 정수입니다 . 힌트로, 이는 출력이 항상 미만인 것으로 알려져 있다면, 및 최대와 최소의 요소이다 ( 참조 ).ai ≥ 0(n1 - 1)*(nk - 1)n1nkL

규칙

전체 프로그램이나 함수를 작성할 수 있습니다. 바이트 수가 가장 적고 표준 허점이 허용되지 않습니다. 귀하의 언어가이를 위해 내장 된 조작을 사용하는 경우이를 사용할 수 없습니다. 답변을 게시하기 전에 테스트 사례를 평가할 수 있다는 점을 제외하고 시간 또는 메모리 효율성에 대한 요구 사항은 없습니다.

이 챌린지를 게시 한 후 @vihan 사용자는 Stack Overflow가 정확히 중복 됨을 지적했습니다 . 이 메타 토론을 바탕으로 으로이 도전은 중복으로 삭제되지 않습니다. 그러나 SO 버전의 답변을 기반으로 한 모든 답변은 원본을 인용하고 커뮤니티 위키 상태를 부여받으며 원래 작성자가 답변을 게시하려면 삭제해야합니다.

테스트 사례

[3, 7, 8] -> 5
[25, 10, 16] -> 79
[11, 12, 13, 14, 13, 14] -> 43
[101, 10] -> 899
[101, 10, 899] -> 889
[101, 10, 11] -> 89
[30, 105, 70, 42] -> 383
[2, 51, 6] -> 49

Pyth, 23 바이트

ef!fqTs.b*NYQY^UTlQS*FQ

모든 코인의 곱까지 모든 값을 확인하기 때문에 매우 느립니다. 거의 동일한 버전이지만 1) 동전 세트를 서로 나눌 수없는 동전으로 줄이고 2) 최대 (max(coins) - 1) * (min(coins) - 1)(47 바이트)의 값만 확인합니다 .

=Qu?.A<LiHdG+GHGQYef!fqTs.b*NYQY^UTlQS*thSQteSQ

설명

                   S            range 1 to
                    *FQ         product of input
 f                             filter by
               UT                range 0 to T 
              ^  lQ              cartesian power by number of coins
   f                            filter by
      s.b*NYQY                   sum of coin values * amounts
    qT                           equals desired number T
  !                             nothing matching that filter
e                             take last (highest) element

펄, 60 54 51 바이트

50 바이트 코드 + 1 바이트 명령 줄

$.*=$_,$r.=1x$_."|"}{$_=$.while(1x$.--)=~/^($r)+$/

골프를 계속하고 나중에 설명을 게시합니다. 기본 접근 방식은 정규식 엔진이 문자열 일치로 열심히 일하도록하는 것입니다. 예를 들어, 다음과 비슷한 정규식을 구성합니다.^(.{3})*(.{7})*(.{8})*$ 일치 하지 않을 때까지 입력의 곱 n에서 n내려 오는 길이의 문자열과 하고 일치 .

인수의 수가 증가함에 따라 이것은 기하 급수적으로 느려질 것입니다.

사용법 : 인수는 STDIN (새 줄로 구분)에서 읽습니다. 예를 들면 다음과 같습니다.

printf "101\n10" | perl -p entry.pl

R , 84 78 바이트

임의의 coprimes 항목의 경우 $a_1, a_2,\ldots$, 의 Frobenius '량 으로 주어진다

a=scan();max((1:(b<-min(a)*max(a)))[-colSums(combn(outer(a,0:b),sum(!!a)))])

온라인으로 사용해보십시오!

항상 극단적 인 것보다 작기 때문에 $a_i$'에스. 그런 다음 해당 범위 내에서 가능한 모든 조합 (및 그 이상)을 결합해야합니다. `apply (..., 2, sum) '대신 outer"*"가없는 제안을 해준 Cole Beck에게 감사합니다 colSums.

더 빠르지 만 더 긴 (2 바이트) 버전은 다음을 고려합니다 max(a).

a=scan();max((1:(min(a)*(b<-max(a))))[-apply(combn(outer(a,0:b,"*"),sum(!!a)),2,sum)])

대부분의 경우에 실행 로그를 너무 걸리거나 너무 많은 공간 약간 짧은 버전 (78 바이트) 온라인 체험이 있다

a=scan();max((1:(b<-prod(a)))[-apply(combn(outer(a,0:b,"*"),sum(!!a)),2,sum)])

Python2, 188 187 바이트

def g(L):
 M=max(L);i=r=0;s=[0]*M;l=[1]+s[1:]
 while 1:
    if any(all((l+l)[o:o+min(L)])for o in range(M)):return~-s[r]*M+r
    if any(l[(i-a)%M]for a in L):l[i]=1
    else:r=i
    s[i]+=1;i=(i+1)%M

두 번째 들여 쓰기는 SO에서 4 개의 공백으로 렌더링되며 탭이어야합니다.

실제로 bruteforce가 아닌 '빠른'솔루션은 여기에 설명 된대로 'Wilf 's Method'를 사용 합니다 .

자바 ES6, 120 개 130 126 128 127 125 문자

f=a=>`${r=[1|a.sort((a,b)=>a-b)]}`.repeat(a[0]*a[a.length-1]).replace(/./g,(x,q)=>r[q]|a.map(x=>r[q+x]|=r[q])).lastIndexOf(0)

대체 126 자 버전 :

f=a=>{r=[1];a.sort((a,b)=>a-b);for(q=0;q<a[0]*a[a.length-1];++q)r[q]?a.map(x=>r[q+x]=1):r[q]=0;return r.join``.lastIndexOf(0)}

테스트:

"[3, 7, 8] -> 5\n\
[25, 10, 16] -> 79\n\
[11, 12, 13, 14, 13, 14] -> 43\n\
[101, 10] -> 899\n\
[101, 10, 899] -> 889\n\
[101, 10, 11] -> 89\n\
[30, 105, 70, 42] -> 383\n\
[2, 51, 6] -> 49".replace(/(\[.*?\]) -> (\d+)/g, function (m, t, r) {
  return f(JSON.parse(t)) == r
})