최근 프라임 / 프라임 인수 분해 관련 문제가 많이 있었으므로 다른 방식으로 진행하는 것이 재미있을 것이라고 생각했습니다.

주어진:

• 양의 정수 n, 및
• 비어 있지 않은 양의 정수 목록 f

전체 프로그램 또는 정수 작은을 찾을 수있는 기능을 작성 i하도록 i >= n하고 i있는 요소의 음이 아닌 정수 능력의 산물입니다 f.

예 :

• 가정 해 봅시다 n = 11, f = [2, 3, 5].

  처음 몇 가지 제품은 다음과 같습니다.

  1   = 2^0 * 3^0 * 5^0
  2   = 2^1 * 3^0 * 5^0
  3   = 2^0 * 3^1 * 5^0
  5   = 2^0 * 3^0 * 5^1
  4   = 2^2 * 3^0 * 5^0
  6   = 2^1 * 3^1 * 5^0
  10  = 2^1 * 3^0 * 5^1
  9   = 2^0 * 3^2 * 5^0
  15  = 2^0 * 3^1 * 5^1
  25  = 2^0 * 3^0 * 5^2
  8   = 2^3 * 3^0 * 5^0
  12  = 2^2 * 3^1 * 5^0 => smallest greater than (or equal to) 11, so we output it.
  20  = 2^2 * 3^0 * 5^1
  18  = 2^1 * 3^2 * 5^0
  30  = 2^1 * 3^1 * 5^1
  50  = 2^1 * 3^0 * 5^2
  27  = 2^0 * 3^3 * 5^0
  45  = 2^0 * 3^2 * 5^1
  75  = 2^0 * 3^1 * 5^2
  125 = 2^0 * 3^0 * 5^3
  

• 가정 해 봅시다 n=14, f=[9, 10, 7].

  다시, 처음 몇 가지 제품 :

  1 = 7^0 * 9^0 * 10^0
  7 = 7^1 * 9^0 * 10^0
  9 = 7^0 * 9^1 * 10^0
  10 = 7^0 * 9^0 * 10^1
  49 = 7^2 * 9^0 * 10^0  => smallest greater than (or equal to) 14, so we output it.
  63 = 7^1 * 9^1 * 10^0
  70 = 7^1 * 9^0 * 10^1
  81 = 7^0 * 9^2 * 10^0
  90 = 7^0 * 9^1 * 10^1
  100 = 7^0 * 9^0 * 10^2
  

테스트 사례 :

n, f -> output
10, [2, 3, 5]              -> 10
17, [3, 7]                 -> 21
61, [3,5,2,7]              -> 63
23, [2]                    -> 32
23, [3]                    -> 27
23, [2, 3]                 -> 24
31, [3]                    -> 81
93, [2,2,3]                -> 96
91, [2,4,6]                -> 96
1,  [2,3,5,7,11,13,17,19]  -> 1
151, [20,9,11]             -> 180
11616, [23,32]             -> 12167
11616, [23,32,2,3]         -> 11664 = 2^4 * 3^6
5050, [3,6,10,15,21,28,36,45,55,66,78,91,105,120,136,153,171,190,210] -> 5103 = 3^6 * 7
12532159, [57, 34, 12, 21] -> 14183424 = 12^5 * 57

규칙

• 당신은 그 가정 할 수 f적어도 하나 개의 요소가 포함되며, 모든 요소는 f1보다 커야합니다.
• 원하는 경우 f감소 / 증가 순서로 정렬되어 있다고 가정 할 수도 있습니다 (그러나 지정하십시오).
• 원하는 f경우 요소 수를 선택적으로 가질 수 있습니다 .
• 문자열로 출력 할 수 있습니다.
• 이것은 code-golf 이므로 각 언어에서 가장 짧은 바이트 단위의 대답이 이깁니다!
• 기본 I / O 규칙이 적용되며 표준 허점이 금지됩니다.
• 설명이 권장됩니다.

껍질 , 8 바이트

ḟṠ€ȯmΠṖṘ

매우 느립니다. 온라인으로 사용해보십시오!

설명

ḟṠ€ȯmΠṖṘ  Implicit inputs, say L=[3,4] and n=5.
ḟ         Find the lowest integer k≥n that satisfies:
       Ṙ   Replicate L by k: [3,3,3,3,3,4,4,4,4,4]
      Ṗ    Powerset: [[],[3],[4],..,[3,3,3,3,3,4,4,4,4,4]]
    mΠ     Product of each: [1,3,4,..,248832]
 Ṡ€ȯ       k is in this list.

Wolfram Language (Mathematica) , 68 65 62 61 바이트

If[#^#2<=1,1~Max~-Log@#2,Min[#0[#,#2-1,##4],#0[#/#3,##2]#3]]&

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

작동 원리

입력을 [n,k,f1,f2,f3,...,fk](예 :)로 취합니다. [11,3,2,3,5]첫 번째 값은 대상 n이고 두 번째 값은 요인 수이며 모든 프랙 터가 따릅니다.

다른 숫자 이론 문제는 최근에 모두 고급 내장 (최소한 사용 FactorInteger)으로 접혀서 기본 도구 만 사용하는 것을 시도 할 것이라고 생각했습니다. 이 솔루션은 기본적으로 n요인의 곱 으로 쓰 려면 첫 번째 요인을 사용 한다고 말합니다.f1 (을 반복 n/f1한 다음을 곱함 f1) 사용하지 않거나 (더 짧은 요인 목록을 사용하여) 분을 취합니다.

대상이 1보다 작거나 요인 수가 0 인 경우 재귀가 시작됩니다.이 수는 #^#2<=1한 번에 확인 하고 첫 번째 경우 1을 생성합니다.Infinity 하고 후자1~Max~-Log@#2 합니다.

이 함수는로 실행하지 않는 한 전체 경고를 제공하지만 여전히 존재하지 않는 Quiet경우로 되풀이되어 #3사용하지 않는 두 번째 분기를 If슬프게 만듭니다.

-3 바이트 : 요소 수를 입력으로 사용합니다.

@ngenisis 덕분에 -3 바이트 : using ∞ .

-1 바이트, ∞모호함 없음 : #^#2점검.

파이썬 2 , 91 88 84 바이트

f=lambda n,l:n<2or any(n%x<1and f(n/x,l)for x in l)
g=lambda n,l:n*f(n,l)or g(n+1,l)

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

함수 f있는지 검사 재귀 n요소의 제곱의 곱이며 l, g반복을 제어하기 위해 단지 래퍼

파이썬, 55 바이트

f=lambda n,l,x=1:min(f(n,l,x*e)for e in l)if x<n else x

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

테스트를 위해 로드 의 바닥 글 스크립트를 수치스럽게 복사

젤리 , 13 바이트

L⁹ṗ’⁸*P€ḟ⁹Ḷ¤Ṃ

f왼쪽에있는 목록과을 (를) 취하는 2 개의 링크n 숫자를 산출 오른쪽에.

온라인으로 사용해보십시오! 비효율적 인 골프-더 높은 입력의 시간 초과n 거나 더 긴f .

어떻게?

우리는 개별적 (엄격히 긍정적 인) 요인의 힘이 결코 초과 할 필요가 없다는 것을 알고 있습니다 n-1
. 따라서 가능한 모든 방법을 검사하십시오!

L⁹ṗ’⁸*P€ḟ⁹Ḷ¤Ṃ - Link: list, f; number, n
 ⁹            - chain's right argument, n
L             - length of f
  ṗ           - Cartesian power  ...e.g.: len(f)=2; n=3 -> [[1,1],[1,2],[1,3],[2,1],[2,2],[2,3],[3,1],[3,2],[3,3]]
   ’          - decrement (vectorises)
    ⁸         - chain's left argument, f
     *        - exponentiate (vectorises) - that is [f1^a, f2^b, ...] for each [a, b, ...] in the list formed from the Cartesian power
      P€      - product for €ach - that is f1^a * f2^b * ... for each [a, b, ...] in the list formed from the Cartesian power
           ¤  - nilad followed by link(s) as a nilad:
         ⁹    -   chain's right argument, n
          Ḷ   -   lowered range -> [0,1,2,3,...,n-1]
        ḟ     - filter discard - that is remove values less than n
            Ṃ - minimum

레티 나 , 76 바이트

\d+
$*
1+;
$&$&
{+`;(1+)(\1)*(?=;.*\b\1\b)
;1$#2$*1
}`(1+);11+;
1$1;1$1;
\G1

온라인으로 사용해보십시오! Link는 가장 느린 테스트 사례를 제외하지만 여전히 약간 느리므로 @Dennis의 서버를 망치지 마십시오.

Pyth-10 바이트

메모리가 매우 빨리 소모됩니다.

f}T*My*QTE

여기에서 온라인으로 사용해보십시오 .

16 바이트에 대한 합리적인 답변 : fsm.A}RQ*Md./PTE

수학, 85 바이트

Min@Select[Flatten[1##&@@(s^#)&/@Tuples[0~Range~⌈Log[Min[s=#],d=#2]⌉,#3]],#>=d&]&

입력

[{list f}, n, f의 요소 수]
[{57, 34, 12, 21}, 12532159, 4]

apt , 10 바이트

_k e!øV}aU

온라인으로 테스트하십시오!

인터프리터가 영원히 실행되지 않도록 설계된 반복 제한으로 인해 마지막 테스트 사례에서 작동하지 않습니다 (1 시간 동안 브라우저를 멈 췄기 때문에 여기에서는별로 도움이되지 않았습니다 ...)

설명

_k e!øV}aU    Implicit: U = input integer, V = array of factors
_      }aU    Starting at U, find the next integer Z where
 k              the factors of Z
   e            are such that every factor
    !øV         is contained in V (e!øV -> eX{VøX}, where VøX means "V contains X").
              Implicit: output result of last expression

젤리 , 9 바이트

xŒPP€ḟḶ}Ṃ

O (2 ^{n • 길이 (f)} ) 런타임 및 메모리 사용량은이를 이론적 인 솔루션으로 만듭니다.

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

하스켈 , 46 바이트

이것은 KSab의 훌륭한 Python 답변의 포트입니다 . PPCG Haskell 대화방, Of Monads and Men 에서이 답변을 디버깅하고 골프를 치는 데 도움을 준 Laikoni에게 감사드립니다 . 골프 제안을 환영합니다! 온라인으로 사용해보십시오!

(#1)
(l#x)n|x<n=minimum[(l#(x*e))n|e<-l]|1>0=x

수학, 73 바이트

1±_=1>0;n_±f_:=Or@@(#∣n&&n/#±f&/@f);n_·f_:=NestWhile[#+1&,n,!#±f&]

본질적으로 Rod 의 Python 응답 포트입니다 . 두 개의 이항 연산자 ±와를 정의합니다 ·. 의 요소 와 그렇지 않은 요소의 n±f곱인 True경우를 반환 합니다 . 가장 작은 정수를 제공합니다 . 누군가가 분할 성 테스트를 제거하는 방법을 알아낼 수 있다면 ISO 8859-1 인코딩을 사용하여 10 바이트를 절약 할 수 있습니다.nfFalsen·fi

설명

1±_=1>0;                         (* If the first argument is 1, ± gives True. *)
n_±f_:=Or@@(#∣n&&n/#±f&/@f);     (* Recursively defines ±. *)
                                 (* For each element of f, check to see if it divides n. *)
                                 (* For each element # that does, check if n/# is a product of elements of f. *)
n_·f_:=NestWhile[#+1&,n,!#±f&]   (* Starting with n, keep incrementing until we find an i that satisfies i±f. *)

R , 52 바이트

function(n,f)min((y=(x=outer(f,0:n,"^"))%o%x)[y>=n])

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

3 주가 지났으므로 마침내 내 솔루션을 게시 할 것이라고 생각했습니다. 이것은 무차별 대입 방식입니다.

그러나 내장 기능이 있습니다.

R , 5 바이트

nextn

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

R 문서에서 :

nextn에 n포함 된 값의 거듭 제곱으로 얻을 수있는 가장 크거나 같은 가장 작은 정수를 반환합니다 factors. nextn는 fft변환이 빠르게 계산되도록 인수를 영 (0)으로 채울 수있는 적절한 길이를 찾는 데 사용됩니다 . 의 기본값 factors은이 를 보장합니다.

그러나 일부 테스트에서는 위의 TIO 링크에서 볼 수 있듯이 구현시 버그가 발견되었습니다.

nextn(91,c(2,6))96을 반환하지만 대신 128을 반환해야합니다. 이것은 분명히 factors서로 상대적으로 소수가 아닌 경우에만 발생합니다 . 실제로, C 코드의 기본 은 nextn욕심 에 도달 factor할 때까지 탐욕스럽게 각각을 나눕니다 1.

static Rboolean ok_n(int n, int *f, int nf)
{
    int i;
    for (i = 0; i < nf; i++) {
    while(n % f[i] == 0) {
        if ((n = n / f[i]) == 1)
        return TRUE;
    }
    }
    return n == 1;
}


static int nextn0(int n, int *f, int nf)
{
    while(!ok_n(n, f, nf))
    n++;
    return n;
}

이는 입력을 내림차순으로 입력하여 해결할 수 있습니다.

자바 스크립트 (ES6), 53 50 바이트

@DanielIndie 덕분에 3 바이트 절약

카레 구문으로 입력을 (n)(a)받습니다.

n=>m=a=>(g=k=>k<n?a.map(x=>g(k*x)):k>m?0:m=k)(1)|m

테스트 사례

let f =

n=>m=a=>(g=k=>k<n?a.map(x=>g(k*x)):k>m?0:m=k)(1)|m

console.log(f(10)([2,3,5]))                // -> 10
console.log(f(17)([3,7]))                  // -> 21
console.log(f(61)([3,5,2,7]))              // -> 63
console.log(f(23)([2]))                    // -> 32
console.log(f(23)([3]))                    // -> 27
console.log(f(23)([2, 3]))                 // -> 24
console.log(f(31)([3]))                    // -> 81
console.log(f(93)([2,2,3]))                // -> 96
console.log(f(91)([2,4,6]))                // -> 96
console.log(f(1,)([2,3,5,7,11,13,17,19]))  // -> 1
console.log(f(151)([20,9,11]))             // -> 180
console.log(f(11616)([23,32]))             // -> 12167
console.log(f(11616)([23,32,2,3]))         // -> 11664 = 2^4 * 3^6
console.log(f(5050)([3,6,10,15,21,28,36,45,55,66,78,91,105,120,136,153,171,190,210])) // -> 5103 = 3^6 * 7
console.log(f(12532159)([57,34,12,21]))    // -> 14183424 = 12^5 * 57

어떻게?

n => a => (                 // given n and a
  g = k =>                  // g = recursive function taking k
    k < n ?                 // if k is less than n:
      a.map(x => g(k * x))  //   recursive calls to g with x * k for each x in a
    :                       // else:
      k > m ?               //   if k is greater than m and m is not set to NaN:
        0                   //     ignore this result
      :                     //   else:
        m = k               //     update m to k
  )(                        // initial call to g with:
    1,                      //   k = 1
    m = +a                  //   m = either NaN or the single integer contained in a
  ) | m                     // return m