कुछ प्राइम पीयरेज

Question

(यादृच्छिक रूप से /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श्रेणी में फिट कर सकते हैं
• मानक खामियों को मना किया जाता है
• यह कोड-गोल्फ है इसलिए सभी सामान्य गोल्फिंग नियम लागू होते हैं, और सबसे छोटा कोड (बाइट्स में) जीतता है

Comments

हम किसी भी क्रम में उत्पादन कर सकते हैं?

— xnor

@ xnor हाँ, किसी भी क्रम में आउटपुट ठीक है।

— AdmBorkBork

क्षमा करें .. बस पूरी तरह से सुनिश्चित होने के लिए: "जिसमें केवल डिवाइडर के रूप में वे ही प्राइम होते हैं" का अर्थ है "जिसमें प्राइम डिविजर्स के रूप में कम से कम एक प्राइम होता है"?

— अज़ेक्टको

आपको 1आउटपुट में अनुमति के लिए परिवर्तन के मौजूदा समाधान की जानकारी देनी चाहिए ।

— झबरा

@AZTECCO राइट। लेकिन, उदाहरण के लिए, यदि आपकी सूची है [2, 3, 7]तो आप उपयोग नहीं कर सकते 5।

— AdmBorkBork

Answer 1

स्टैक्स , 6 बाइट्स

Ç─☼?▬µ

भागो और इसे staxlang.xyz पर डीबग करें!

अनपैक्ड (7 बाइट्स) और स्पष्टीकरण:

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

Answer 2

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)

Comments

वैकल्पिक 7 sиPѦʒ›:। मैंने सोचा कि मैं एक 6 था, लेकिन वहाँ का उपयोग कर चारों ओर एक तरीका हो प्रतीत नहीं होता है s/ I/¹

— ग्रिमी

@ अच्छा विकल्प, लेकिन यह निश्चित रूप से निष्पादित करने के लिए एक लंबा समय लगता है, हालांकि। पहले परीक्षण मामले के लिए इसे सभी विभाजकों को खोजना होगा 4747561509943000000000000000। ;)

— केविन क्रूज़सेन

ऊर्ध्वाधर उत्पादन के लिए:GNfåP–

— ग्रैमी

Answer 3

जावास्क्रिप्ट (ईएस 6),  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
}                 //

Answer 4

पायथन 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)

इसे ऑनलाइन आज़माएं!

Comments

आपके पास कुछ साफ-सुथरे शॉर्ट-कोडिंग कोड हैं। ऐसा लगता है कि आप पहली दो स्थितियों को जोड़ सकते हैं c*s<n*s। संपादित करें: n//c*sछोटा है।

— xnor

@xnor सुधार के लिए धन्यवाद। आपका दृष्टिकोण काफी अच्छा है।

— जोएल

Answer 5

हास्केल , 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]

इसे ऑनलाइन आज़माएं!

Answer 6

हास्केल , 39 बाइट्स

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

इसे ऑनलाइन आज़माएं!

जाँच करता है कि kक्या केवल अपराधों द्वारा विभाज्य lहै यह देखने के लिए कि क्या lकिसी उच्च शक्ति के लिए लिया गया उत्पाद विभाज्य है k।

Answer 7

पायथन 2 , 65 बाइट्स

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

इसे ऑनलाइन आज़माएं!

जाँच करता है कि kक्या केवल अपराधों द्वारा विभाज्य lहै यह देखने के लिए कि क्या lकिसी उच्च शक्ति के लिए लिया गया उत्पाद विभाज्य है k।

यदि lस्ट्रिंग की एक सूची के रूप में लिया जा सकता है eval("*".join(l)) 3 बाइट्स की बचत होती है अधिक reduce(int.__mul__,l)और अजगर 3 जो अभाव है में इस्तेमाल किया जा सकता reduce।

पायथन 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)

इसे ऑनलाइन आज़माएं!

Answer 8

गैया , 10 बाइट्स

…@e⟪ḍ‡⁻!⟫⁇

इसे ऑनलाइन आज़माएं!

मैंने पहले कभी ‡एक सनक के साथ उपयोग नहीं किया है , यह स्टैक हेरफेर के लिए काफी मददगार है।

…		| 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

Answer 9

जे , 24 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 10

जेली , 7 बाइट्स

ṖÆffƑ¥Ƈ

इसे ऑनलाइन आज़माएं!

अपने ऊपरी हिस्से के रूप में अनन्य ऊपरी बाउंड और उसके दाईं ओर primes की सूची लेने वाला एक डियाडिक लिंक। एक सूची लौटाता है जिसमें 1 और साथ ही संख्या केवल आपूर्ति किए गए अपराधों से बनी होती है।

एक वैकल्पिक 7 होगा ṖÆfḟ¥Ðḟ

Answer 11

पायथन 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

इसे ऑनलाइन आज़माएं!

Answer 12

जाप -f , 11 8 बाइट्स

k
è@e!øV

कोशिश करो

Answer 13

जाप -f , 7 बाइट्स

©k e!øV

कोशिश करो

Comments

इसमें 1आउटपुट शामिल है, जो इसे नहीं करना चाहिए। मैं के साथ शुरू k e!øVभी मेरे समाधान के लिए लेकिन फिल्टर करने के लिए 2 अतिरिक्त बाइट्स की जरूरत 0और 1।

— झबरा

Since, e.g., 2**0 = 1, you can optionally include 1 in your output list

— अज्ञानता

यह मूल कल्पना का हिस्सा नहीं था ।

— झबरा

Answer 14

रूबी -rprime , 61 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 15

रेटिना 0.8.2 , 64 बाइट्स

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

इसे ऑनलाइन आज़माएं! सूची में छोटे परीक्षण मामले ( 10000सभी लंबे तारों के कारण बार-बार) शामिल हैं। आदेश में इनपुट लेता है n f1 f2 f3...(कारकों को प्रधान होने की आवश्यकता नहीं है लेकिन उन्हें कॉपीराइम करने की आवश्यकता है)। आउटपुट शामिल हैं 1। स्पष्टीकरण:

\d+
$*

यूनीरी में बदलें।

\G1
$.`,$`;

n-1दशमलव और यूरीरी दोनों में 0 से एक सूची बनाएँ।

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

किसी भी उपलब्ध कारकों द्वारा बार-बार एकात्मक को विभाजित करते हैं।

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

उन दशमलव संख्याओं को आउटपुट करें जहां यूनरी संख्या घटा दी गई है 1।

Answer 16

अजगर , 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)

Answer 17

पर्ल 6 , 27 बाइट्स

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

इसे ऑनलाइन आज़माएं!

पोर्ट ऑफ ज़्नोर के हास्केल समाधान। इसके अलावा आउटपुट 1।

Answer 18

चारकोल , 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पूर्वनिर्धारित रिक्त सूची में करें।

Ｆυ

सूची में लूप, लूप के दौरान इसे धकेल दिए गए किसी भी आइटम सहित।

Ｆ×ιθ

प्रत्येक आइटम द्वारा वर्तमान आइटम को गुणा करें और उत्पादों पर लूप करें।

Ｆ›‹κη№υκ

जांचें कि क्या उत्पाद एक नया मूल्य है।

⊞υκ

यदि ऐसा है तो इसे सूची में धकेल दें।

Ｉυ

सूची प्रिंट करें।

Answer 19

सी (क्लैंग) , 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];}

इसे ऑनलाइन आज़माएं!

एराटोस्थनीज आधारित समाधान की एक छलनी।

(आउटपुट में शामिल)

@Ceilingcat सुझाव के लिए धन्यवाद: Printf (x [i] + "\ 0% d", i ++) के बजाय x [i] और& printf ("% d", i), i ++ मुझे लगता है कि यह शाब्दिक के सूचक को बदल देता है लेकिन didn कोई दस्तावेज नहीं मिला, अगर कोई मुझे कुछ जानकारी दे सकता है तो उसका स्वागत किया जाएगा।

Comments

धन्यवाद लेकिन .. यह कैसे काम करता है?

— AZTECCO

अगर है x[i]==1तो तार है "%d "। अगर है x[i]==0तो तार है ""। सी स्ट्रिंग को शून्य समाप्त कर दिया जाता है, इसलिए एक स्पष्ट अशक्त चरित्र स्ट्रिंग को समाप्त कर देता है। यह हैक भी संबंधित क्लैंग में कुछ अपरिभाषित व्यवहार का दुरुपयोग करता है i++।

— सीलिंग