(แรงบันดาลใจแบบสุ่มโดย/mathpro//q/339890 )
(ที่เกี่ยวข้อง: 1 , 2 )

รับรายการอินพุตของจำนวนเฉพาะที่แตกต่างกัน (เช่น, [2, 5, 7]), และจำนวนเต็มnส่งออกจำนวนเต็มบวกทั้งหมดที่เล็กกว่าอย่างเคร่งครัดnที่มีเฉพาะช่วงเวลาเหล่านั้นเป็นตัวหาร สำหรับการป้อนข้อมูล[2, 5, 7]และที่นี้หมายถึงการส่งออกของn=15[2, 4, 5, 7, 8, 10, 14]

ตัวอย่างเพิ่มเติม

[list] n | output

[2, 5, 7] 15 | [2, 4, 5, 7, 8, 10, 14]
[2, 5, 7] 14 | [2, 4, 5, 7, 8, 10]
[2] 3 | [2]
[2] 9 | [2, 4, 8]
[103, 101, 97] 10000 | [97, 101, 103, 9409, 9797, 9991]
[97, 101, 103] 104 | [97, 101, 103]

กฎและคำชี้แจง

• รายการอินพุตมีการรับประกันว่าไม่ว่างเปล่า แต่อาจเป็นเพียงองค์ประกอบเดียว
• คุณสามารถสมมติว่ารายการอินพุตถูกจัดเรียงล่วงหน้าในวิธีที่สะดวกที่สุด
• n จะใหญ่กว่าองค์ประกอบที่ใหญ่ที่สุดในรายการอินพุตเสมอ
• ตั้งแต่เช่น2**0 = 1คุณสามารถเลือกที่จะรวม1ไว้ในรายการเอาท์พุทของคุณ
• อินพุตและเอาต์พุตสามารถกำหนดได้โดยวิธีการที่สะดวก
• คุณสามารถพิมพ์ผลลัพธ์ไปที่ STDOUT หรือส่งคืนเป็นผลลัพธ์ของฟังก์ชัน
• ยอมรับได้ทั้งโปรแกรมหรือฟังก์ชั่น
• หากเป็นไปได้คุณสามารถสมมติว่าจำนวนเต็มเข้า / ส่งออกเหมาะสมกับintช่วงดั้งเดิมของภาษาของคุณ
• ช่องโหว่มาตรฐานเป็นสิ่งต้องห้าม
• นี่คือรหัส - กอล์ฟเพื่อให้ใช้กฎการเล่นกอล์ฟตามปกติทั้งหมดและรหัสที่สั้นที่สุด (เป็นไบต์) ชนะ

Stax , 6 ไบต์

Ç─☼?▬µ

เรียกใช้และแก้ไขปัญหาได้ที่ staxlang.xyz!

คลายการแพค (7 ไบต์) และคำอธิบาย:

vf:Fn-!
vf         Filter range [1..n-1]:
  :F         Distinct prime factors
    n-       Remove all in provided list
      !      Is empty?

05AB1E , 6 ไบต์

<LʒfåP

ใช้จำนวนเต็มเป็นอินพุตแรกแสดงรายการเป็นวินาที รวมถึงตัวเลือก1ในการส่งออก

ลองมันออนไลน์หรือตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย:

<       # Decrease the (implicit) input by 1
 L      # Create a list in the range [1,input-1]
  ʒ     # Filter it by:
   f    #  Get all prime factors of the current number (without duplicates)
    å   #  Check for each if its in the (implicit) input-list
     P  #  And check if this is truthy for all
        # (after the filter, the result is output implicitly)

ทางเลือก6 ไบต์สองทางที่จัดทำโดย@Grimy :

GNfåP–

ลองออนไลน์

G       # Loop `N` in the range [1, (implicit) input):
 Nf     #  Get all prime factors of `N` (without duplicates)
   å    #  Check for each if its in the (implicit) input-list
    P   #  And check if this is truthy for all
     –  #  If it is, output the current `N` with trailing newline

อันนี้ช้ามาก ( [2,5,7], 15กรณีทดสอบหมดเวลาไปแล้ว) แต่ไม่เหมือนกับสองแนวทางอื่น ๆ :

sиPÑʒ›

ไม่เหมือนกับอีกสองโปรแกรมด้านบนมันใช้รายการเป็นอินพุตแรกและจำนวนเต็มเป็นวินาที มันรวมถึงตัวเลือก1ในการส่งออกเช่นกันแม้ว่า

ลองออนไลน์

s       # Swap so the stack is now [list-input, integer-input]
 и      # Repeat the list (flattened) the integer amount of times
        #  i.e. [2,5] and 10 → [2,5,2,5,2,5,2,5,2,5,2,5,2,5,2,5,2,5,2,5]
  P     # Take the product of this list
        #  → 10000000000
   Ñ    # Get all divisors of this integer
        # (the bottleneck for larger integers in this approach)
        #  → [1,2,4,5,8,10,16,20,25,32,40,50,64,80,100,125,128,160,200,250,256,320,400,500,512,625,640,800,1000,1024,1250,1280,1600,2000,2500,2560,3125,3200,4000,5000,5120,6250,6400,8000,10000,12500,12800,15625,16000,20000,25000,25600,31250,32000,40000,50000,62500,64000,78125,80000,100000,125000,128000,156250,160000,200000,250000,312500,320000,390625,400000,500000,625000,640000,781250,800000,1000000,1250000,1562500,1600000,1953125,2000000,2500000,3125000,3200000,3906250,4000000,5000000,6250000,7812500,8000000,9765625,10000000,12500000,15625000,16000000,19531250,20000000,25000000,31250000,39062500,40000000,50000000,62500000,78125000,80000000,100000000,125000000,156250000,200000000,250000000,312500000,400000000,500000000,625000000,1000000000,1250000000,2000000000,2500000000,5000000000,10000000000]
    ʒ   # Filter these divisors:
     ›  #  And only keep those where the (implicit) input-integer is larger than the divisor
        #  → [1,2,4,5,8]
        # (after the filter, the result is output implicitly)

JavaScript (ES6),  64 ... 52  50 ไบต์

จะเข้าเป็น(n)(primes)ที่ช่วงเวลาที่เป็นชุด เอาท์พุทโดยการปรับเปลี่ยนการตั้งค่า

n=>g=(s,q=1)=>{for(p of s)(p*=q)<n&&g(s.add(p),p)}

ลองออนไลน์!

แสดงความคิดเห็น

n =>              // n = maximum value
g = (             // g is a recursive function taking:
  s,              //   s = set of primes
  q = 1           //   q = current product, initialized to 1
) => {            //
  for(p of s)     // for each value p in s:
    (p *= q)      //   multiply p by q
    < n &&        //   if the result is less than n:
      g(          //     do a recursive call:
        s.add(p), //       with p added to the set
        p         //       with q = p
      )           //     end of recursive call
}                 //

Python 3 , 68 65 ไบต์

f=lambda s,n,c=1:n//c*s and f(s,n,s[0]*c)+f(s[1:],n,c)or[c][:c<n]

ลองออนไลน์!

-3 ไบต์ต้องขอบคุณ @xnor

ฟังก์ชั่นใช้ลำดับเฉพาะและจำนวนเต็ม n เป็นอินพุต ผลลัพธ์คือรายการที่มี 1

Ungolfed:

def f(s, n, c=1):
    if not c < n:
       return []
    elif not s:
       return [c]
    else:
       return f(s,n,s[0]*c) + f(s[1:],n,c)

ลองออนไลน์!

Haskell , 51 ไบต์

xpmapM((<$>[0..n]).(^))p$1,x,x^2,\ldots,x^n$$n$product

np$(\#p)^n$

p#n=[k|k<-product<$>mapM((<$>[0..n]).(^))p,k<n,k>1]

ลองออนไลน์!

Haskell , 39 ไบต์

l%n=[k|k<-[2..n-1],mod(product l^k)k<1]

ลองออนไลน์!

ตรวจสอบว่าkคือหารเท่านั้นโดยเฉพาะในlโดยเห็นว่าผลิตภัณฑ์ของนำไปที่พลังงานสูงคือหารด้วยlk

Python 2 , 65 ไบต์

lambda l,n:[k for k in range(2,n)if reduce(int.__mul__,l)**n%k<1]

ลองออนไลน์!

ตรวจสอบว่าkคือหารเท่านั้นโดยเฉพาะในlโดยเห็นว่าผลิตภัณฑ์ของนำไปที่พลังงานสูงคือหารด้วยlk

หากlสามารถนำมาเป็นรายชื่อของสตริงeval("*".join(l)) บันทึก 3 ไบต์กว่าreduce(int.__mul__,l)และสามารถนำมาใช้ในหลาม 3 reduceซึ่งขาด

Python 3 , 64 ไบต์

def f(l,n,P=1):
 for x in l:P*=x
 n-=1;P**n%n or print(n);f(l,n)

ลองออนไลน์!

ฟังก์ชั่นที่พิมพ์ในลำดับย้อนกลับและยุติด้วยข้อผิดพลาด

โซลูชันแบบเรียกซ้ำด้านล่างจะสั้นลงหากnรวมอยู่ในรายการ ฉันลองคำนวณผลิตภัณฑ์ซ้ำด้วยซ้ำlแต่นั่นก็นานกว่า

62 ไบต์ (ไม่ทำงาน)

f=lambda l,n:n*[f]and[n][reduce(int.__mul__,l)**n%n:]+f(l,n-1)

ลองออนไลน์!

Gaiaขนาด 10 ไบต์

…@e⟪ḍ‡⁻!⟫⁇

ลองออนไลน์!

ฉันไม่เคยใช้‡กับ monad มาก่อนมันค่อนข้างมีประโยชน์สำหรับการจัดการกองซ้อน

…		| push [0..n-1]
@e		| push list of primes
  ⟪    ⟫⁇	| filter [0..n-1] for where the following predicate is true:
   ḍ‡		| the list of prime factors
     ⁻		| minus the list of primes
      !		| is empty

J , 24 ไบต์

(]#~0=1#.(-."1~q:))2}.i.

ลองออนไลน์!

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

ṖÆffƑ¥Ƈ

ลองออนไลน์!

ลิงก์ dyadic ที่ใช้ขอบเขตบนสุดพิเศษเป็นอาร์กิวเมนต์ซ้ายและรายการของช่วงเวลาที่เหมาะสม ส่งคืนรายการที่ประกอบด้วย 1 รวมถึงตัวเลขที่ประกอบด้วยเฉพาะช่วงเวลาที่ให้มาเท่านั้น

ทางเลือก 7 น่าจะเป็น ṖÆfḟ¥Ðḟ

Python 2 , 98 ไบต์

lambda a,n:[i for i in R(2,n)if{p for p in R(2,i+1)if(i%p<1)*all(j%p for j in R(2,p))}<=a]
R=range

ลองออนไลน์!

Japt -f , 11 8 ไบต์

k
è@e!øV

ลองมัน

Japtap -f , 7 ไบต์

©k e!øV

ลองมัน

ทับทิม -rprime 61 ไบต์

->n,l{(2..n).select{|i|i.prime_division.all?{|b,|[b]-l==[]}}}

ลองออนไลน์!

เรติน่า 0.8.2 , 64 ไบต์

\d+
$*
\G1
$.`,$`;
+`,(1+)(\1)*(?=;.* \1\b)
,1$#2$*
!`\d+(?=,1;)

ลองออนไลน์! รายการรวมถึงกรณีทดสอบขนาดเล็ก ( 10000หมดเวลาเนื่องจากสตริงยาวทั้งหมด) ใช้อินพุตตามลำดับn f1 f2 f3...(ปัจจัยไม่จำเป็นต้องเป็นไพรม์ แต่ต้องเป็น coprime) 1การส่งออกรวม คำอธิบาย:

\d+
$*

แปลงเป็นเอก

\G1
$.`,$`;

สร้างรายการจาก 0 ถึงn-1ทั้งทศนิยมและไม่เป็นรายการ

+`,(1+)(\1)*(?=;.* \1\b)
,1$#2$*

แบ่ง unary ซ้ำ ๆ กันด้วยปัจจัยที่มีอยู่

!`\d+(?=,1;)

1เอาท์พุทตัวเลขทศนิยมที่จำนวนเอกได้ลดลง

Pyth , 10 ไบต์

f!-PThQtUe

ลองออนไลน์!

ใช้อินพุตเป็น [[primes...], n]

        Ue  # range(0, Q[-1])  (Q is the input, implicit)
       t    #                [1:] -> range(1, Q[-1]), tUe == PSe
f           # filter that on the condition: lambda T:
   PT       # prime_divisors(T)
  -  hQ     #                   - Q[0]
 !          # logical negation (![] == True)

Perl 6 , 27 ไบต์

{grep [*](@^a)**$^b%%*,^$b}

ลองออนไลน์!

พอร์ตของโซลูชัน Haskell ของ xnor นอกจากนี้ยังมีเอาต์พุต 1

ถ่าน , 22 20 ไบต์

ＩΦ…²η⬤…·²ι∨﹪ιλ⊙θ¬﹪λν

ลองออนไลน์!การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด ช้าเกินไปสำหรับกรณีทดสอบที่ใหญ่กว่า คำอธิบาย:

 Φ                      Filter on
  …                     Range from
   ²                    Literal `2` to
    η                   Input limit
     ⬤                  Where all values
      …·                Inclusive range from
        ²               Literal `2` to
         ι              Filter value
          ∨             Either
             λ          Inner value
           ﹪            Is not a divisor of
            ι           Filter value
              ⊙         Or any of
               θ        Input primes
                   ν    Current prime
                ¬﹪      Is a divisor of
                  λ     Inner value
Ｉ                       Cast to string for implicit print

คำตอบ 22 ไบต์ที่เร็วกว่าก่อนหน้า:

⊞υ¹ＦυＦ×ιθＦ›‹κη№υκ⊞υκＩυ

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด เอาท์พุทรวมถึง1การส่งออกรวมคำอธิบาย:

⊞υ¹

ดัน 1ไปที่รายการว่างที่กำหนดไว้ล่วงหน้า

Ｆυ

วนรอบรายการรวมถึงรายการใด ๆ ที่ส่งไประหว่างการวนซ้ำ

Ｆ×ιθ

ทวีคูณรายการปัจจุบันโดยแต่ละไพรม์และวนลูปมากกว่าผลิตภัณฑ์

Ｆ›‹κη№υκ

ตรวจสอบว่าผลิตภัณฑ์เป็นค่าใหม่

⊞υκ

หากเป็นเช่นนั้นให้กดไปที่รายการ

Ｉυ

พิมพ์รายการ

C (เสียงดังกราว) , 115 ไบต์

#define f(n,l,z){int j,i,k,x[n]={};for(i=x[1]=1;i<n;printf(x[i]+"\0%d ",i++))for(j=z;j--;k<n?x[k]=x[i]:0)k=i*l[j];}

ลองออนไลน์!

วิธีแก้ปัญหาของ Eratosthenes

(รวม 1 ในผลลัพธ์)

ขอบคุณคำแนะนำ @ceilingcat: printf (x [i] + "\ 0% d", i ++) แทน x [i] && printf ("% d", i), i ++ ฉันคิดว่ามันจะเลื่อนตัวชี้ของตัวอักษร แต่ไม่ได้ ไม่พบเอกสารใด ๆ หากใครสามารถให้ข้อมูลเชิงลึกกับฉันมันจะยินดี