เมื่อไม่นานมานี้มีความท้าทายมากมายเกี่ยวกับการแยกตัวประกอบเฉพาะกลุ่ม / ตัวประกอบที่สำคัญมากดังนั้นฉันคิดว่ามันน่าสนใจที่จะไปทางอื่น

ได้รับ:

• จำนวนเต็มบวกnและ
• รายการที่ไม่ว่างของจำนวนเต็มบวก f

เขียนโปรแกรมเต็มหรือฟังก์ชั่นเพื่อหาสิ่งที่เล็กที่สุดจำนวนเต็มiเช่นนั้นi >= nและเป็นผลิตภัณฑ์ของค่าลบเป็นจำนวนเต็มอำนาจขององค์ประกอบในif

ตัวอย่าง:

• 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จะมีองค์ประกอบอย่างน้อยหนึ่งองค์ประกอบและองค์ประกอบทั้งหมดของfจะมากกว่า 1
• คุณอาจเลือกที่fจะเรียงลำดับในการลด / เพิ่มขึ้นหากคุณต้องการ (แต่โปรดระบุ)
• คุณอาจเลือกที่จะใช้องค์ประกอบจำนวนหนึ่งfหากคุณต้องการ
• อนุญาตเอาต์พุตเป็นสตริง
• นี่คือcode-golfดังนั้นคำตอบที่สั้นที่สุดเป็นไบต์ในแต่ละภาษาที่ชนะ!
• ใช้กฎ I / O ที่เป็นค่าเริ่มต้นและห้ามมีช่องโหว่มาตรฐาน
• คำอธิบายได้รับการสนับสนุน

Husk , 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 (Mathematica) , 68 65 62 61 bytes

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, อันดับที่สองคือจำนวนของปัจจัย, และ frctors ทั้งหมดติดตาม

ความท้าทายเกี่ยวกับทฤษฎีตัวเลขอื่น ๆ เมื่อเร็ว ๆ นี้ทั้งหมดถูกพับเก็บไว้เพื่อสร้างตัวอินแฟนซี (อย่างน้อยที่สุดพวกเขาใช้FactorInteger) ดังนั้นฉันคิดว่าฉันจะลองสิ่งที่ใช้เครื่องมือพื้นฐานเท่านั้น วิธีการแก้ปัญหานี้โดยทั่วไปบอกว่าการเขียนnเป็นผลิตภัณฑ์ของปัจจัยเราอาจใช้ปัจจัยแรกf1(และเรียกคืนn/f1จากนั้นคูณด้วยf1) หรือไม่ (และเรียกคืนในรายการปัจจัยที่สั้นกว่า) จากนั้นใช้เวลาขั้นต่ำ

เรียกซ้ำตัวเอง bottoms ออกเมื่อเป้าหมายคือน้อยกว่า 1 หรือเมื่อจำนวนของปัจจัยเป็น 0 ซึ่งเราตรวจสอบกับ#^#2<=1ในครั้งเดียวแล้วสร้าง 1 ในกรณีแรกและในภายหลังด้วยInfinity1~Max~-Log@#2

ฟังก์ชั่นให้คำเตือนมากมาย (แต่ก็ยังใช้งานได้) เว้นแต่คุณจะใช้มันQuietเพราะในที่สุดมันก็เกิดขึ้นซ้ำ ๆ กับกรณีที่#3ไม่มีอยู่ทำให้สาขาที่สองที่ไม่ได้ใช้Ifเศร้า

-3 ไบต์: รับจำนวนปัจจัยเป็นอินพุต

-3 ไบต์ขอบคุณที่ @ngenisis: ∞การใช้

-1 ไบต์และไม่มี∞ความกำกวม: การ#^#2ตรวจสอบ

Python 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เป็นเพียงเสื้อคลุมในการควบคุมการทำซ้ำที่

Python ขนาด 55 ไบต์

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

ลองออนไลน์!

คัดลอกสคริปต์ท้ายกระดาษของRodเพื่อการทดสอบอย่างไร้ยางอาย

เยลลี่ขนาด 13 ไบต์

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

ลิงก์ dyadic จะรับรายการ, fด้านซ้ายและหมายเลข, nด้านขวาซึ่งให้ค่าตัวเลข

ลองออนไลน์! Golfily ไม่มีประสิทธิภาพ - จะหมดเวลาสำหรับปัจจัยการผลิตที่มีความสูง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

ลองออนไลน์! ลิงก์ไม่รวมกรณีทดสอบที่ช้าที่สุด แต่ก็ยังช้าอยู่เล็กน้อยดังนั้นอย่าพยายามใช้เซิร์ฟเวอร์ของ @ Dennis

Pyth - 10 ไบต์

หน่วยความจำหมดเร็วมาก

f}T*My*QTE

ลองมันออนไลน์ได้ที่นี่

คำตอบที่สมเหตุสมผลสำหรับ 16 ไบต์: fsm.A}RQ*Md./PTE

Mathematica, 85 ไบต์

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

อินพุต

[{รายการ f}, n, จำนวนองค์ประกอบของ f]
[{57, 34, 12, 21}, 12532159, 4]

Japt , 10 ไบต์

_k e!øV}aU

ทดสอบออนไลน์!

ไม่ทำงานในกรณีทดสอบล่าสุดเนื่องจากข้อ จำกัด การวนซ้ำที่ออกแบบมาเพื่อป้องกันไม่ให้ล่ามทำงานตลอดไป (ไม่ได้ช่วยอะไรมากที่นี่เนื่องจากมันทำให้เบราว์เซอร์ของฉันค้างเป็นเวลาหนึ่งชั่วโมง ... )

คำอธิบาย

_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)} )การใช้งานจริงและการใช้หน่วยความจำทำให้สิ่งนี้เป็นโซลูชันทางทฤษฎี

ลองออนไลน์!

Haskell , 46 ไบต์

นี่คือพอร์ตของKSab คำตอบของงูหลามที่ดีเยี่ยม ขอขอบคุณที่ Laikoni เพื่อขอความช่วยเหลือในการแก้จุดบกพร่องและการเล่นกอล์ฟคำตอบนี้ในเนต PPCG Haskell, ของ Monads และผู้ชาย ยินดีต้อนรับคำแนะนำการเล่นกอล์ฟ! ลองออนไลน์!

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

Mathematica, 73 ไบต์

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

หลักพอร์ตของร็อด 's หลามคำตอบ กำหนดสองผู้ประกอบการไบนารีและ± ผลตอบแทนถ้าเป็นผลิตภัณฑ์ขององค์ประกอบและอื่น ๆ·n±fTruenfFalsen·fให้จำนวนเต็มที่น้อยที่สุดiให้เลขที่เล็กที่สุดหากใครบางคนสามารถหาวิธีที่จะกำจัดการทดสอบการหารฉันสามารถบันทึก 10 ไบต์โดยใช้การเข้ารหัส ISO 8859-1

คำอธิบาย

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 สัปดาห์แล้วดังนั้นฉันคิดว่าในที่สุดฉันก็จะโพสต์โซลูชันของฉันเอง นี่เป็นวิธีการที่ดุร้าย

อย่างไรก็ตามมี buildin:

R , 5 ไบต์

nextn

ลองออนไลน์!

จากเอกสาร R:

nextnผลตอบแทนที่เลขที่เล็กที่สุดมากกว่าหรือเท่ากับซึ่งสามารถรับได้เป็นผลิตภัณฑ์ของอำนาจของค่าที่มีอยู่ในn มีวัตถุประสงค์เพื่อใช้ในการค้นหาความยาวที่เหมาะสมเพื่อให้อาร์กิวเมนต์เป็นศูนย์เพื่อให้การแปลงคำนวณอย่างรวดเร็ว ค่าเริ่มต้นสำหรับทำให้มั่นใจในสิ่งนี้factorsnextnfftfactors

การทดสอบบางอย่างพบข้อผิดพลาดในการใช้งานอย่างไรก็ตามเป็นลิงก์ 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;
}

สิ่งนี้สามารถแก้ไขได้โดยการป้อนข้อมูลในลำดับที่ลดลง

JavaScript (ES6), 53 50 ไบต์

บันทึกแล้ว 3 ไบต์ขอบคุณ @DanielIndie

(n)(a)จะเข้าในไวยากรณ์ currying

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