합계와 같거나 그 반대 인 제품


22

등가의 재미있는 쌍은 1 + 5 = 2 · 31 · 5 = 2 + 3 입니다. 이와 같은 많은 것들이 있으며, 다른 하나는 1 + 1 + 8 = 1 · 2 · 5 이고 1 · 1 · 8 = 1 + 2 + 5 입니다. 의 일반 정보 제품에서 n은 양의 정수 (A)의 합과 같다 n은 반대의 양의 정수, 그리고 그 반대입니다.

이 도전에서는 순열을 제외하고 입력 n> 1에 대해 양의 정수 조합을 모두 생성해야합니다 . 적절한 형식으로 출력 할 수 있습니다. 예를 들어, n = 3에 대해 가능한 모든 솔루션 은 다음과 같습니다.

(2, 2, 2) (1, 1, 6)
(1, 2, 3) (1, 2, 3)
(1, 3, 3) (1, 1, 7)
(1, 2, 5) (1, 1, 8)

2GB RAM 에서 1 분 만에 최고 n 에 대해 가장 많은 조합을 생성 할 수있는 프로그램 인 64 비트 Intel Ubuntu 랩탑이 승리합니다. 귀하의 답변이 2GB 이상의 RAM을 사용하거나 무료 소프트웨어로 테스트 할 수없는 언어로 작성된 경우 귀하의 답변에 점수를 매기 지 않습니다. 지금부터 2 주 후에 답변을 테스트하고 승자를 선택합니다. 나중에 비경쟁 답변을 게시 할 수 있습니다.

모든 n에 대한 전체 솔루션 세트가 무엇인지 알 수 없으므로 불완전한 솔루션을 생성하는 답변을 게시 할 수 있습니다. 그러나 다른 답변이 (더 많은) 완전한 솔루션을 생성하면 최대 n 이 작 더라도 답변이 승리합니다.


명확히하기 위해, 승자를 결정하는 점수 매기기 과정은 다음과 같습니다.

  1. 나는 n = 2, n = 3 등으로 프로그램을 테스트 할 것입니다 ... 모든 출력을 저장하고 프로그램이 1 분 이상 또는 2GB 이상의 RAM을 사용하면 중지합니다. 주어진 입력 n에 대해 프로그램이 실행될 때마다 1 분 이상 걸리면 종료됩니다.

  2. n = 2에 대한 모든 프로그램의 모든 결과를 살펴 봅니다. 프로그램이 다른 솔루션보다 덜 유효한 솔루션을 생성하면 해당 프로그램이 제거됩니다.

  3. n = 3, n = 4 등에 대해 2 단계를 반복하십시오. 마지막 프로그램 순위가 승리합니다.


1
그렇다면 Windows 전용 언어로 대답이 없습니까?
코너 오브라이언

3
개인적으로 점수 기준을 싫어합니다. 컴퓨터 테스트 결과가 나올 때까지 솔루션이 작동하는지 여부와 임계 값을 설정할 위치를 알 수 없습니다. 간단한 코드 골프 가 더 나은 질문 이라고 생각합니다 .
musicman523

2
하드 코딩이 허용되지 않는다고 가정합니다. 그러나 그 제한은 관찰 할 수없는 수준에 가깝습니다
Luis Mendo

1
@ user202729 나는, 어떤 프로그램이 더 많은 솔루션을 생성하는지 확인하기 위해 각 n 에 대해 각 프로그램을 시도해야합니다 .
orlp

2
"지금부터 2 주 시간"은 3 일 전입니다.
GB

답변:


4

C (gcc) , n = 50000000, 6499 결과 59 초

거의 전적으로 1로 구성된 테라 바이트 이상의 출력을 피하기 위해 (예를 들어) 49999995 1의 시퀀스는로 약칭됩니다 1x49999995.

#include <stdio.h>
#include <stdlib.h>

static int n, *a1, k1 = 0, *a2, k2 = 0, s1, p1, *factor;

static void out() {
  if (s1 == p1) {
    for (int i = 0; i < k1 && i < k2; i++) {
      if (a1[i] < a2[i])
        return;
      else if (a1[i] > a2[i])
        break;
    }
  }

  for (int i = 0; i < k1; i++)
    printf("%d ", a1[i]);
  printf("1x%d | ", n - k1);
  for (int i = 0; i < k2; i++)
    printf("%d ", a2[i]);
  printf("1x%d\n", n - k2);
}

static void gen2(int p, int s, int m);

static void gen3(int p, int s, int m, int x, int q) {
  int r = s - n + k2 + 2;
  int d = factor[q];
  do {
    if (x * d <= m)
      x *= d;
    q /= d;
  } while (q % d == 0);
  do {
    if (q == 1) {
      a2[k2++] = x;
      gen2(p / x, s - x, x);
      k2--;
    } else {
      gen3(p, s, m, x, q);
    }
    if (x % d != 0)
      break;
    x /= d;
  } while (p / (x * q) >= r - x * q);
}

static void gen2(int p, int s, int m) {
  int n2 = n - k2;
  if (p == 1) {
    if (s == n2)
      out();
  } else if (n2 >= 1 && m > 1) {
    int r = s - n2 + 1;
    if (r < 2 || p < r)
      return;
    if (m > r)
      m = r;
    if (factor[p] <= m)
      gen3(p, s, m, 1, p);
  }
}

static void gen1(int p, int s, int m) {
  int n1 = n - k1;
  p1 = p;
  s1 = s + n1;
  gen2(s1, p1, s + n1 + 1 - n);
  if (n1 != 0) {
    int *p1 = &a1[k1++];
    for (int x = 2; x <= m && p * x <= s + x + n1 - 1; x++) {
      *p1 = x;
      gen1(p * x, s + x, x);
    }
    k1--;
  }
}

int main(int argc, char **argv) {
  if (argc < 2)
    return 1;
  n = atoi(argv[1]);
  if (n < 2)
    return 1;
  a1 = malloc(n * sizeof(int));
  a2 = malloc(n * sizeof(int));
  factor = calloc(4 * n - 1, sizeof(int));
  for (int p = 2; p < 4 * n - 1; p++)
    if (factor[p] == 0) {
      factor[p] = p;
      for (int i = p; i <= (4 * n - 2) / p; i++)
        factor[p * i] = p;
    } else if (factor[p] < factor[p / factor[p]]) {
      factor[p] = factor[p / factor[p]];
    }
  gen1(1, 0, 3 * n - 1);
  return 0;
}

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


3

Mathematica, 12 개의 솔루션으로 n = 293

OP는 도전 과제를 변경하고 입력을 요청합니다.
다음은 n을 입력으로 사용하는 새로운 코드입니다.
n = 293의 경우 12 개의 솔루션을 얻습니다.

If[#<5,Union[Sort/@Select[Tuples[{1,2,3,4,5,6,7,8,9},{#}],Tr@#==Times@@#&]],For[a=1,a<3,a++,For[b=a,b<3,b++,For[c=b,c<5,c++,For[d=c,d<10,d++,For[e=d,e<300,e++,If[Tr[s=Join[Table[1,#-5],{a,b,c,d,e}]]==Times@@s,Print[s]]]]]]]]&


입력

[엔]

온라인으로 무료로 제공되는 소프트웨어 인 Wolfram Sandbox 에서이 알고리즘을 테스트 할 수 있습니다 . 링크를 따라 코드를 붙여넣고 (ctrl + v) 코드 끝에 입력을 붙여 넣으십시오.
shift + enter를 눌러 실행하십시오.
몇 초 안에 내 솔루션을 모두 얻을 수 있습니다

여기에 또한 온라인으로보십시오!C ++ (gcc)에서
(내 코드를 무료 언어로 지원하고 번역하는 @ThePirateBay 덕분에 많은 감사)

이 프로그램은 {a, b, c} {a, b, c} 형식의 솔루션 만 생성합니다.
a + b + c = a * b * c

계산하는 데 1 초가 걸립니다

12 가지 솔루션은 다음과 같습니다.

{1,1 ..., 1,1,1,2,293} {1,1 ..., 1,1,1,2,293}
{1,1 ..., 1,1,1,3,147} {1 , 1 ..., 1,1,1,3,147}
{1,1 ..., 1,1,1,5,74} {1,1 ..., 1,1,1,5,74}
{1,1 ..., 1,1,2,2,98} {1,1 ..., 1,1,2,2,98}
{1,1 ..., 1,1,2, 3,59} {1,1 ..., 1,1,2,3,59}
{1,1 ..., 1,1,2,5,33} {1,1 ..., 1, 1,2,5,33}
{1,1 ..., 1,1,2,7,23} {1,1 ..., 1,1,2,7,23}
{1,1 .. ., 1,1,2,8,20} {1,1 ..., 1,1,2,8,20}
{1,1 ..., 1,1,3,3,37} {1 , 1 ..., 1,1,3,3,37}
{1,1 ..., 1,1,3,4,27} {1,1 ..., 1,1,3,4, 27}
{1,1 ..., 1,1,3,7,15} {1,1 ..., 1,1,3,7,15}
{1,1 ..., 1,2, 2,6,13} {1,1 ..., 1,2,2,6,13}


1
"귀하의 답변 [...]이 무료 소프트웨어로 테스트 할 수없는 언어로 작성된 경우 귀하의 답변에 점수를 매기 지 않습니다."
Leaky Nun

4
@GB "불완전한 솔루션을 생성하는 답변을 게시 할 수 있습니다"
user202729

1
내 프로그램은 "한 분에서 가장 높은 N에 대한 대부분의 조합을 ..generates".IT는 hardcoded.It은 1 분에 첫 12 "쉬운"해결책을 발견하지 않습니다
J42161217

1
n 이 입력이어야 한다는 것이 더 명확 할 수 있습니다 . 나는 그것을 명확히했다. 프로그램이 입력 n을 취하는 것으로 보이지 않습니다 .
orlp

2
@orlp 수정! 내 프로그램은 n을 입력으로 사용합니다. n = 293의 경우 12 개의 해를 구합니다. 모든 것이 작동하기 때문에 공감하십시오.
J42161217

2

Python 2 , n = 175, 28 결과 59s

감소 계수 2를 사용하여 조금 느리게 만들었지 만 n = 83으로 시작하는 더 많은 솔루션을 얻습니다.

한 번의 실행으로 TIO에서 n까지 92까지의 결과를 얻습니다.

def submats(n, r):
    if n == r:
        return [[]]
    elif r > 6:
        base = 1
    else:
        base = 2
    mx = max(base, int(n*2**(1-r)))

    mats = []
    subs = submats(n, r+1)
    for m in subs:
        if m:
            mn = m[-1]
        else:
            mn = 1
        for i in range(mn, mx + 1):
            if i * mn < 3*n:
                mats += [m + [i]]
    return mats

def mats(n):
    subs = []
    for sub in submats(n, 0):
        sum = 0
        prod = 1
        for m in sub:
            sum += m
            prod *= m
        if prod > n and prod < n*3:
            subs += [[sub, sum, prod]]
    return subs

def sols(n):
    mat = mats(n)
    sol = [
        [[1]*(n-1)+[3*n-1],[1]*(n-2)+[2,2*n-1]],
    ]
    if n > 2:
        sol += [[[1]*(n-1)+[2*n+1],[1]*(n-2)+[3,n]]]
    for first in mat:
        for second in mat:
            if first[2] == second[1] and first[1] == second[2] and [second[0], first[0]] not in sol:
                sol += [[first[0], second[0]]];
    return sol

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


1
"5 개 요소 [1..2]를 유지하고 3n을 제한합니다 ..."내 알고리즘이 마음에 들었습니다. ;-)
J42161217

이미 Ruby 버전에서 비슷한 작업을 수행했으며 이제는 그 제한을 제거하려고합니다.
GB

주어진 n에 대해 알고리즘에 몇 개의 솔루션이 하드 코딩되어 있습니까?
J42161217

실제로 하드 코딩되지 않음 : 바로 가기를 사용하여 2 개의 표준 솔루션을 생성 할 수 있으며 (동일한 조합 인 경우 n = 2 제외),이를 건너 뛰어 범위를 3n 대신 2n으로 제한 할 수 있습니다. 이것이 하드 코딩 된 것으로 간주되면 변경하겠습니다.
GB

1
61에 대한 내 결과는 28이 될 것입니다. 27
이었던

1

루비 , n = 12는 6 개의 솔루션을 얻습니다.

적어도 TIO에서는 1에서 11까지의 일반적인 결과

->n{
  arr=[*1..n*3].product(*(0..n-2).map{|x|
    [*1..[n/3**x,2].max]|[1]
  }).select{|a|
    a.count(1) >= n-4
  }.map(&:sort).uniq
  arr.product(arr).map(&:sort).uniq.select{|r|
    r[0].reduce(&:+) == r[1].reduce(&:*) &&
    r[0].reduce(&:*) == r[1].reduce(&:+)
  }
}

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

내 랩톱에서 n = 13에 대해 1 분 내에 10 개의 결과를 얻습니다.


1

Mathematica, 11 개의 솔루션으로 n = 19

이것은 OP의 새로운 기준에 따른 나의 새로운 답변입니다.

(SOL = {};
For[a = 1, a < 3, a++, 
For[b = a, b < 3, b++, 
For[c = b, c < 5, c++, 
 For[d = c, d < 6, d++, 
  For[e = d, e < 3#, e++, 
   For[k = 1, k < 3, k++, 
    For[l = k, l < 3, l++, 
     For[m = l, m < 5, m++, 
      For[n = m, n < 6, n++, For[o = n, o < 3#, o++,
        s = Join[Table[1, # - 5], {a, b, c, d, e}];
        t = Join[Table[1, # - 5], {k, l, m, n, o}];            
        If[Tr[s[[-# ;;]]] == Times @@ t[[-# ;;]] && 
          Tr[t[[-# ;;]]] == Times @@ s[[-# ;;]], 
         AppendTo[SOL,{s[[-#;;]],t[[-#;;]]}]]]]]]]]]]]];
Union[SortBy[#,Last]&/@SOL])&

마지막에 입력 [n]을 주면 프로그램이 솔루션을 표시합니다

내 결과는 다음과 같습니다 (이전 랩톱 64 비트 2.4GHz)

n-> 솔루션
2-> 2
3-> 4
4-> 3
5-> 5
6-> 4
7-> 6
8-> 5
9-> 7
10-> 7
11-> 8
12-> 6 (in 17 초)
13-> 10 (20 초)
14-> 7 (25 초)
15-> 7 (29 초)
16-> 9 (34 초)
17-> 10 (39 초)
18- > 9 (45 초)
19-> 11 (51 초)
20-> 7 (58 초)


1

Haskell, 많은 솔루션 빠른

import System.Environment

pr n v = prh n v v

prh 1 v l = [ [v] | v<=l ]
prh n 1 _ = [ take n $ repeat 1 ]
prh _ _ 1 = []
prh n v l = [ d:r | d <-[2..l], v `mod` d == 0, r <- prh (n-1) (v`div`d) d ]

wo n v = [ (c,k) | c <- pr n v, let s = sum c, s>=v,
                   k <- pr n s, sum k == v, s>v || c>=k ]

f n = concatMap (wo n) [n+1..3*n]

main = do [ inp ] <- getArgs
          let results = zip [1..] $ f (read inp)
          mapM_ (\(n,s) -> putStrLn $ (show n) ++ ": " ++ (show s)) results

f솔루션을 계산하고, main함수는 명령 줄에서 입력을 받고 일부 형식과 계산을 추가합니다.


다음 ghc -O3 -o prodsum prodsum.hs과 같이 컴파일 하고 명령 행 인수로 실행하십시오../prodsum 6
Christian Sievers

0

하스켈 , n = 10, 2 개의 솔루션


import           Data.List

removeDups = foldl' (\seen x -> if x `elem` seen then seen else x : seen) []
removeDups' = foldl' (\seen x -> if x `elem` seen then seen else x : seen) []

f n= removeDups $ map sort filterSums
  where maxNumber = 4
        func x y = if (((fst x) == (fst.snd$y)) && ((fst y) == (fst.snd$x)))
                     then [(snd.snd$x),(snd.snd$y)]
                     else [[],[]]
        pOf = removeDups' $ (map sort (mapM (const [1..maxNumber]) [1..n]))
        sumOf = map (\x->((sum x),((product x), x))) pOf
        filterSums = filter (\x-> not$(x == [[],[]])) (funcsumOfsumOf)

이것은 쓰레기처럼 작동하지만 적어도 수정하여 실제로 지금 도전 과제를 해결하고 있습니다!

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


n = 2 인 경우 [ "[3,3] [2,3]", "[2,2] [2,2]", "[1,3] [2,2]", "[1, 2] [1,3] ","[1,1] [1,2] "] 잘못된 것
J42161217

모든 솔루션이 실제로 잘못된 것 같습니다
GB

@Jenny_mathy 어떻게 잘못 되었나요? 3 + 3은 6이고 2 * 3은 6입니다. 질문을 오해합니까?
maple_shaft

당신은 "그 반대"를 놓치고있다
J42161217

@Jenny_mathy 멍청한 실수 야! 나는 그것을 고쳤다. 지금 작동해야한다.
maple_shaft 2

0

공리, n = 83 (59 초)

-- copy the below text in the file name "thisfile.input" 
-- and give something as the command below in the Axiom window:
-- )read C:\Users\thisuser\thisdirectory\thisfile

)cl all
)time on

-- controlla che l'array a e' formato da elementi  a.i<=a.(i+1)
tv(a:List PI):Boolean==(for i in 1..#a-1 repeat if a.i> a.(i+1) then return false;true)

-- funzione incremento: incrementa a, con #a=n=b/3,sotto la regola di "reduce(+,a)+#a-1>=reduce(*,a)"
-- e che n<reduce(*,a)<3*n ed reduce(+,a)<3*n 
inc3(a:List PI):INT==
   i:=1; n:=#a; b:=3*n
   repeat
      if i>n  then return 0
      x:=reduce(*,a)
      if x>=b then a.i:=1
      else
          y:=reduce(+,a)
          if y>b then a.i=1
          else if y+n-1>=x then
                      x:=x quo a.i
                      a.i:=a.i+1
                      x:=x*a.i
                      if tv(a) then break
                      else a.i:=1
          else a.i:=1
      i:=i+1
   if x<=n then return inc3(a) -- x<=n non va
   x

-- ritorna una lista di liste di 4 divisori di n
-- tali che il loro prodotto e' n
g4(n:PI):List List PI==
  a:=divisors(n)
  r:List List PI:=[]
  for i in 1..#a repeat
     for j in i..#a repeat
        x:=a.i*a.j
        if x*a.j>n then break
        for k in j..#a repeat
            y:=x*a.k
            if y*a.k>n then break
            for h in k..#a repeat
                z:=y*a.h
                if z=n  then r:=cons([a.h,a.k,a.j,a.i],r)
                if z>=n then break 
  r

-- ritorna una lista di liste di 3 divisori di n
-- tali che il loro prodotto e' n
g(n:PI):List List PI==
  a:=divisors(n)
  r:List List PI:=[]
  for i in 1..#a repeat
     for j in i..#a repeat
        x:=a.i*a.j
        if x*a.j>n then break
        for k in j..#a repeat
            y:=x*a.k
            if y=n  then r:=cons([a.k,a.j,a.i],r)
            if y>=n then break
  r

-- cerca che [a,b] nn si trovi gia' in r
searchr(r:List List List PI,a:List PI,b:List PI):Boolean==
  aa:=sort(a); bb:=sort(b)
  for i in 1..#r repeat
      x:=sort(r.i.1);y:=sort(r.i.2)
      if x=aa and y=bb then return false
      if x=bb and y=aa then return false
  true

-- input n:PI
-- ritorna r, tale che se [a,b] in r
-- allora #a=#b=n
--        ed reduce(+,a)=reduce(*,b) ed reduce(+,b)=reduce(*,a)
f(n:PI):List List List PI==
  n>100000 or n<=1 =>[]
  a:List PI:=[]; b:List PI:=[]; r:List List List PI:=[]
  for i in 1..n repeat(a:=cons(1,a);b:=cons(1,b))
  if n~=72 and n<86 then  m:=min(3,n)
  else                    m:=min(4,n) 
  q:=reduce(*,a) 
  repeat
    w:=reduce(+,a)
    if n~=72 and n<86 then x:= g(w)
    else                   x:=g4(w)
    if q=w then r:=cons([copy a, copy a],r)
    for i in 1..#x repeat
           for j in 1..m repeat
                  b.j:=(x.i).j
           -- per costruzione abbiamo che reduce(+,a)= prodotto dei b.i=reduce(*,b)
           -- manca solo di controllare che reduce(+,b)=reduce(*,a)=q
           if reduce(+,b)=q and searchr(r,a,b) then r:=cons([copy a, copy b],r)
    q:=inc3(a)
    if q=0 then break
  r

결과 :

 for i in 2..83 repeat output [i, # f(i)]
   [2,2][3,4][4,3][5,5][6,4][7,6][8,5][9,7][10,7][11,8][12,6][13,10][14,7][15,7]
   [16,10][17,10][18,9][19,12][20,7][21,13][22,9][23,14][24,7][25,13][26,11]
   [27,10][28,11][29,15][30,9][31,16][32,11][33,17][34,9][35,9][36,13][37,19]
   [38,11][39,14][40,12][41,17][42,11][43,20][44,12][45,16][46,14][47,14][48,13]
   [49,16][50,14][51,17][52,11][53,20][54,15][55,17]
   [56,14][57,20][58,17][59,16][60,15][61,28][62,15][63,16][64,17][65,18]
   [66,14][67,23][68,20][69,19][70,13][71,18][72,15][73,30][74,15][75,17][76,18]
   [77,25][78,16][79,27][80,9][81,23][82,17][83,26]


 f 3
    [[[1,2,5],[8,1,1]],[[1,3,3],[7,1,1]],[[1,2,3],[1,2,3]],[[2,2,2],[6,1,1]]]
                                     Type: List List List PositiveInteger
                                   Time: 0.07 (IN) + 0.05 (OT) = 0.12 sec

Axiom에서 위의 텍스트를 실행하는 방법은 파일의 모든 텍스트를 파일에 복사하고 이름을 사용하여 파일을 저장합니다. Name.input, Axiom 창에서 ") read absolutepath / Name"을 사용하십시오.
결과 : (# f (i)는 배열 f (i)의 길이, 즉 솔루션 수를 찾습니다)

당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.