26

हैरानी की बात है, मुझे नहीं लगता कि एक संख्या के सेमीप्राइम होने का निर्धारण करने के लिए हमारे पास एक कोड-गोल्फ प्रश्न है ।

एक अर्धवृत्त एक प्राकृतिक संख्या है जो दो (जरूरी नहीं कि विशिष्ट) अभाज्य संख्याओं का उत्पाद है।

सरल पर्याप्त है, लेकिन एक उल्लेखनीय महत्वपूर्ण अवधारणा है।

एक सकारात्मक पूर्णांक को देखते हुए, निर्धारित करें कि क्या यह एक अर्धवृत्त है। आपका आउटपुट किसी भी रूप में हो सकता है जब तक कि यह किसी भी सत्य या गलत मूल्य के लिए समान आउटपुट नहीं देता है। आप यह भी मान सकते हैं कि आपका इनपुट काफी छोटा है कि प्रदर्शन या अतिप्रवाह कोई समस्या नहीं है।

परीक्षण के मामलों:

input -> output
1     -> false
2     -> false
3     -> false
4     -> true
6     -> true
8     -> false
30    -> false   (5 * 3 * 2), note it must be EXACTLY 2 (non-distinct) primes
49    -> true    (7 * 7)      still technically 2 primes
95    -> true
25195908475657893494027183240048398571429282126204032027777137836043662020707595556264018525880784406918290641249515082189298559149176184502808489120072844992687392807287776735971418347270261896375014971824691165077613379859095700097330459748808428401797429100642458691817195118746121515172654632282216869987549182422433637259085141865462043576798423387184774447920739934236584823824281198163815010674810451660377306056201619676256133844143603833904414952634432190114657544454178424020924616515723350778707749817125772467962926386356373289912154831438167899885040445364023527381951378636564391212010397122822120720357
      -> true, and go call someone, you just cracked RSA-2048

यह कोड-गोल्फ है , इसलिए मानक नियम लागू होते हैं!

code-golf sequence

— भगवान फरक्काड
स्रोत

4

@HeatWizard इसमें थोड़ा अंतर है कि कोई 3 primes (लगभग सभी भाषाओं के लिए एक बड़ा अंतर नहीं) के लिए पूछता है और यह केवल अलग-अलग primes के लिए है (कुछ भाषाओं के लिए बिल्कुल अलग)। यदि आप अधिक विस्तृत चर्चा जारी रखना चाहते हैं तो मैं आपसे चैट में इस पर चर्चा कर सकता हूं।

— हाइपरन्यूट्रीनो

2

@WheatWizard आप एक अच्छा बिंदु उठाते हैं, लेकिन इसी तरह, हमारे पास पहले से ही कई प्रकार के प्रश्नों का एक समूह है, और हालांकि, आप जो व्यक्त करते हैं, उसके विपरीत, उनमें से अधिकांश अपने क्षेत्र में महत्वपूर्ण योगदान देते हैं, इस सवाल में काफी अंतर है मुझे विश्वास है कि यह एक अलग प्रश्न / पोस्ट का वारंट करता है।

— HyperNeutrino

2

@hyperneutrino दोनों चुनौतियों पर जवाब देख रहा है, ऐसा लगता है कि अंतर स्रोत कोड में एक ही संख्या है, 2 बनाम 3. मैं शायद ही उस बड़े अंतर को कॉल करूंगा।

— गेहूं जादूगर

2

@HeatWizard "विशिष्ट" बनाम "भिन्न नहीं" भी है ...

— HyperNeutrino

3

@LordFarquaad सिर्फ इसलिए कि इसकी डुप्लिकेट का मतलब यह नहीं है कि यह खराब है। मेरे दिमाग में डुप्लिकेट होना एक अच्छी बात है, इसका मतलब है कि आप एक ऐसी चीज पूछ रहे हैं जो समुदाय को काफी दिलचस्प लगती है, जिसके बारे में पहले से ही पूछा जा चुका है।

— गेहूं जादूगर

19

ब्रेकीलॉग , 2 बाइट्स

मूल रूप से Sphenic संख्या चुनौती के लिए Fatalize के उत्तर से एक बंदरगाह ।

ḋĊ

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

कैसे?

ḋĊ - implicitly takes input
ḋ  - prime factorisation (with duplicates included)
 Ċ - is a couple

— जोनाथन एलन
स्रोत

1

वास्तव में नौकरी के लिए सही भाषा: पी

— हाइपरन्यूट्रीनो

2

@ यूरिल Ċवास्तव में दो चर की एक अंतर्निहित सूची है; एक घोषणात्मक भाषा होने के नाते आउटपुट डिफ़ॉल्ट रूप से, संतुष्टि के लिए एक परीक्षण है (उदाहरण के ḋलिए अपने आप में true.गैर-नकारात्मक पूर्णांक के लिए आउटपुट )।

— जोनाथन एलन

यह 2 बाइट्स कैसे है?

— हेरोल्ड

1

@harold I ने सिर्फ Brachylog के कोड-पेज के हेडर लिंक में "बाइट्स" बनाने के लिए अपडेट किया। एक हेक्स डंप होगा c6 eb।

— जोनाथन एलन

16

भूसी , 4 बाइट्स

_{देखो ना युनिकोड!}

=2Lp

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

कैसे?

=2Lp - a one input function
   p - prime factorisation (with duplicates included)
  L  - length
=2   - equals 2?

— जोनाथन एलन
स्रोत

8

गणितज्ञ, 16 बाइट्स

PrimeOmega@#==2&

PrimeOmega प्रमुख कारकों की संख्या को गिना जाता है, बहुलता की गिनती करता है।

— ngenisis
स्रोत

1

डांग, एक बिलिन है?

— जंगवान मिन

1

@JungHwanMin यदि केवल वहाँ थाSemiprimeQ

— ngenisis

अच्छा लगा। मुझे पता नहीं थाPrimeOmega

— DavidC

7

अजगर , 4 बाइट्स

q2lP

टेस्ट सूट ।

कैसे?

q2lPQ     - Q is implicit input.

q2        - Is equal to 2?
    lPQ   - The length of the prime factors of the input.

— श्री एक्सकोडर
स्रोत

यह, छोटे बिल्डरों! :(

— हाइपरनेट्रो

7

पायथन 3 , 54 बाइट्स

lambda n:0<sum((n%x<1)+(x**3==n)for x in range(2,n))<3

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

^{पिछले verson बड़े घन संख्या (पर कुछ गोलाई समस्याएं थीं 125, 343, आदि)}
यह divisors की राशि (केवल अभाज्य संख्या नहीं) है, अगर यह है की गणना करता है 1या 2यह रिटर्न True।
एकमात्र अपवाद तब होता है जब एक संख्या में दो से अधिक प्रमुख कारक होते हैं लेकिन केवल दो भाजक होते हैं। इस मामले में यह प्राइम का एक परफेक्ट क्यूब है (इसके डिवाइडर इसके क्यूब रूट और इसके क्यूब रूट स्क्वेर्ड हैं)। x**3==nइस मामले को कवर करेगा, क्यूब रूट एंट्री में एक को जोड़ने से योग 3 की गिनती तक पहुंच जाता है और गलत-पॉजिटिव बंद हो जाता है। ^{इस खूबसूरत व्याख्या के साथ लिखने के लिए धन्यवाद जोनाथन एलन}

— छड़ी
स्रोत

यह दावा 8 अर्ध

— कालिक है

n**(1/3)%1>0<sum...कार्य करना चाहिए।

— डेनिस

1

@xnor ने इसे ठीक किया।

— रॉड

एक छोटा-सा संपादन किया गया (जैसे 6 घन के कई और भाजक हैं)

— जोनाथन एलन

6

रूबी , 56 48 बाइट्स

->x{r=c=2;0while x%r<1?(x/=r;c-=1):x>=r+=1;c==0}

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

यह काम किस प्रकार करता है:

->x{                    # Lambda function
    r=c=2;              # Starting from r=2, c=2
    0 while             # Repeat (0 counts as a nop)
        x%r<1? (        # If x mod r == 0
            x/=r:       # Divide x by r
            c-=1        # decrease c
        ):              # else
            x>=r+=1     # increase r, terminate if r>x 
    );
    c==0                # True if we found 2 factors
}

इस विचार के लिए धन्यवाद मूल्य स्याही जिसने 8 बाइट्स को बचाया।

— जीबी
स्रोत

क्यों न केवल c0 पर शुरू करें और इसे गिनें, बजाय इसके कि आप सभी कारकों को जोड़ते हुए एक सरणी बनाएं? इस तरह से आप sizeअंत में उपयोग करने की आवश्यकता को बाहर निकालते हैं

— वैल्यू इंक

आप सही कह रहे हैं, यह इसलिए है क्योंकि मैंने एक और चुनौती के लिए फैक्टराइजेशन फंक्शन लिखा है और मैंने इसे यहाँ पुनः प्रयोग किया है।

— जीबी

5

गणितज्ञ, 31 29 बाइट्स

Tr[Last/@FactorInteger@#]==2&

— जंगहवान मिन
स्रोत

4

नीम , 4 बाइट्स

𝐏𝐥δ𝔼

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

— Okx
स्रोत

क्या आप बता सकते हैं कि यह 4 बाइट्स कैसे हैं? ... मैं पूरी तरह से भ्रमित हूं।

— श्री एक्सकोडर

Lol मैं सिर्फ था यह

— HyperNeutrino

@ Mr.Xcoder नीम का एक कस्टम कोड-पेज है

— जुंगह्वान मिन

@ Mr.Xcoder Neim कोड पृष्ठ पर उपयोग करना, यह वह जगह है 𝐏, 𝐥, δ, और 𝔼एकल बाइट के रूप में।

— HyperNeutrino

@ हाइपरयुट्रीनो मैंने अभी 2 को थोड़ा छोटा किया है, और अब यह 2 के बिना एकमात्र उत्तर है :)

— ओएक्सएक्स

4

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

lambda k:f(k)==2
f=lambda n,k=2:n/k and(f(n,k+1),1+f(n/k,k))[n%k<1]

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

-10 बाइट्स @JonathanAllan को धन्यवाद!

प्राइम फैक्टराइजेशन एल्गोरिदम का श्रेय डेनिस (प्रारंभिक संस्करण में) को जाता है

— श्री एक्सकोडर
स्रोत

क्या आपने डेनिस के उत्तर से कोड का उपयोग किया था ? यदि हां, तो आपको क्रेडिट देना चाहिए।

— बशर्ते

1

@totallyhuman ओह यस, सॉरी। मैंने आज 2 अलग-अलग उत्तरों में इसका उपयोग किया और मैंने उनमें से एक में उसे श्रेय दिया, लेकिन मैं यहां एक बार फिर ऐसा करना भूल गया। कि जगह के लिए धन्यवाद!

— श्री एक्सकोडर

1

67 बाइट्स

— जोनाथन एलन

@JonathanAllan वाह, बहुत बहुत धन्यवाद!

— श्री Xcoder

55 बाइट्स

— हैल्वर्ड शेम्स

4

जावास्क्रिप्ट (ईएस 6), 47 बाइट्स

एक बूलियन देता है।

n=>(k=1)==(d=n=>++k<n?n%k?d(n):d(n/k--)+1:0)(n)

डेमो

कोड स्निपेट दिखाएं

let f =

n=>(k=1)==(d=n=>++k<n?n%k?d(n):d(n/k--)+1:0)(n)

console.log(
  [...Array(200).keys()].filter(f).join`, `
)

स्निपेट का विस्तार करें

— Arnauld
स्रोत

4

गणितज्ञ 32 बाइट्स

1 बाइट बचाया के लिए उत्पत्ति के लिए धन्यवाद

Tr@FactorInteger[#][[;;,2]]==2&

— DavidC
स्रोत

1

के ;;बजाय का उपयोग करके एक बाइट बचाओ All।

— 21

3

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

ÆfL=2

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

व्याख्या

ÆfL=2  Main link
Æf     Prime factors
  L    Length
   =   Equals
    2  2

— HyperNeutrino
स्रोत

3

दरअसल , 4 बाइट्स

ol2=

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

— श्री एक्सकोडर
स्रोत

3

05AB1E, 4 बाइट्स

Òg2Q

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

कैसे?

Ò       prime factors list (with duplicates)
 g      length
   Q    equal to
  2     2

— Uriel
स्रोत

3

MATL, 5 बाइट्स

Yfn2=

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

व्याख्या

Yf - प्रधान कारण।
n - लंबाई।
2= - 2 के बराबर है?

— श्री एक्सकोडर
स्रोत

3

दिल्लोग एपीएल, 18 बाइट्स

⎕CY'dfns'
2=≢3pco⎕

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

कैसे?

⎕CY'dfns' - आयात pco

3pco⎕- pcoबाएं तर्क 3 (प्रमुख कारक) के साथ इनपुट पर चलाएं

2=≢ - लंबाई = 2?

— Uriel
स्रोत

3

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

ḍl2=

4 बाइट्स एक आम लंबाई लगती है, मुझे आश्चर्य है कि क्यों ...: पी

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

व्याख्या

ḍ     Prime factors
 l    Length
  2=  Equals 2?

— बिजनेस कैट
स्रोत

4 बाइट्स एक सामान्य लंबाई लगती है, मुझे आश्चर्य होता है कि क्यों ... - शायद इसलिए क्योंकि सभी उत्तर प्रमुख कारक हैं, लंबाई, 2 के बराबर है?

— श्री एक्सकोडर

@MrXcoder Yep, बिल्कुल

— बिजनेस कैट

जिनमें से 4 मेरा BTW> _>

— मिस्टर एक्सकोडर

४ भी प्रथम अधिपति है। डरावना!

— नील

3

सिम्पी के साथ अजगर 1.1.1 , 57 44 बाइट्स

-13 बाइट्स एलेफाल्फा के लिए धन्यवाद (1.1.1 का उपयोग करें primeomega)

from sympy import*
lambda n:primeomega(n)==2

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

— जोनाथन एलन
स्रोत

lambda n:primeomega(n)==2

— alephalpha

आह कि मुझे 1.0 से उन्नयन की याद दिलाता है, धन्यवाद!

— जोनाथन एलन

3

आर , 67 बाइट्स

c=0;n=scan();for(p in(1:n)[-1:-2]-1)while(n%%p<1){c=c+1;n=n/p};c==2

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

— लीक नन
स्रोत

2

रूबी , 35 + 8 = 43 बाइट्स

फ़ंक्शन -rprimeको अनलॉक करने के लिए ध्वज का उपयोग करता है prime_division।

->n{n.prime_division.sum(&:pop)==2}

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

— मूल्य स्याही
स्रोत

2

जावा 8, 69 61 बाइट्स

n->{int r=1,c=2;for(;r++<n;)for(;n%r<1;n/=r)c--;return c==0;}

-8 बाइट्स @Nevay को धन्यवाद ।

इसे यहाँ आज़माएँ।

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

1

आप else++r;8 बाइट्स को बचाने के लिए दूसरा स्टेटमेंट (जो हो सकता है ) निकाल सकते हैं n->{int r=1,c=2;for(;r++<n;)for(;n%r<1;n/=r)c--;return c==0;}।

— नेवई

1

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

lambda n:g(n)==2
g=lambda n,i=2:n/i and[g(n,i+1),1+g(n/i)][n%i<1]

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

मूल प्रधान गुणन कोड के लिए xnor के जवाब का सारा श्रेय ।

— totallyhuman
स्रोत

1

सी #, 112 बाइट्स

n=>{var r=Enumerable.Range(2,n);var l=r.Where(i=>r.All(x=>r.All(y=>y*x!=i)));return l.Any(x=>l.Any(y=>y*x==n));}

प्रारूपण लागू होने के साथ:

n =>
{
    var r = Enumerable.Range (2, n);
    var l = r.Where (i => r.All (x => r.All (y => y * x != i)));
    return l.Any (x => l.Any (y => y * x == n));
}

और परीक्षण कार्यक्रम के रूप में:

using System;
using System.Linq;


namespace S
{
    class P
    {
        static void Main ()
        {
            var f = new Func<int, bool> (
                n =>
                {
                    var r = Enumerable.Range (2, n);
                    var l = r.Where (i => r.All (x => r.All (y => y * x != i)));
                    return l.Any (x => l.Any (y => y * x == n));
                }
            );

            for (var i = 0; i < 100; i++)
                Console.WriteLine ($"{i} -> {f (i)}");
            Console.ReadLine ();
        }
    }
}

जिसका आउटपुट है:

0 -> False
1 -> False
2 -> False
3 -> False
4 -> True
5 -> False
6 -> True
7 -> False
8 -> False
9 -> True
10 -> True
11 -> False
12 -> False
13 -> False
14 -> True
15 -> True
16 -> False
17 -> False
18 -> False
19 -> False
20 -> False
21 -> True
22 -> True
23 -> False
24 -> False
25 -> True
26 -> True
27 -> False
28 -> False
29 -> False
30 -> False
31 -> False
32 -> False
33 -> True
34 -> True
35 -> True
36 -> False
37 -> False
38 -> True
39 -> True
40 -> False
41 -> False
42 -> False
43 -> False
44 -> False
45 -> False
46 -> True
47 -> False
48 -> False
49 -> True
50 -> False
51 -> True
52 -> False
53 -> False
54 -> False
55 -> True
56 -> False
57 -> True
58 -> True
59 -> False
60 -> False
61 -> False
62 -> True
63 -> False
64 -> False
65 -> True
66 -> False
67 -> False
68 -> False
69 -> True
70 -> False
71 -> False
72 -> False
73 -> False
74 -> True
75 -> False
76 -> False
77 -> True
78 -> False
79 -> False
80 -> False
81 -> False
82 -> True
83 -> False
84 -> False
85 -> True
86 -> True
87 -> True
88 -> False
89 -> False
90 -> False
91 -> True
92 -> False
93 -> True
94 -> True
95 -> True
96 -> False
97 -> False
98 -> False
99 -> False

— MetaColon
स्रोत

1

परी / जीपी , 17 बाइट्स

n->bigomega(n)==2

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

— alephalpha
स्रोत

1

रेटिना , 45 बाइट्स

.+
$*
^(11+)(\1)+$
$1;1$#2$*
A`\b(11+)\1+\b
;

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। स्पष्टीकरण:

.+
$*

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

^(11+)(\1)+$
$1;1$#2$*

दो कारकों को खोजने की कोशिश करें।

A`\b(11+)\1+\b

सुनिश्चित करें कि दोनों कारक प्रमुख हैं।

सुनिश्चित करें कि दो कारक पाए गए।

— नील
स्रोत

1

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

def g(x,i=2):
 while x%i:i+=1
 return i
def f(n,l=0):
 while 1%n:l+=1;n/=g(n)
 return l==2

fएक पूर्णांक nसे अधिक या उसके बराबर 1, रिटर्न बूलियन लेता है ।

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

परीक्षण के मामलों:

>>> f(1)
False
>>> f(2)
False
>>> f(3)
False
>>> f(4)
True
>>> f(6)
True
>>> f(8)
False
>>> f(30)
False
>>> f(49)
True
>>> f(95)
True

— nog642
स्रोत

1

जे , 6 बाइट्स

5 बाइट्स एक-बंद के रूप में काम करेंगे:

   2=#q: 8
0
   2=#q: 9
1

मेरा मानना है कि जब मुझे फ़ंक्शन परिभाषित होता है तो मुझे छह की आवश्यकता होती है:

   semiprime =. 2=#@q:
   (,. semiprime) 1 + i. 20
 1 0
 2 0
 3 0
 4 1
 5 0
 6 1
 7 0
 8 0
 9 1
10 1
11 0
12 0
13 0
14 1
15 1
16 0
17 0
18 0
19 0
20 0

— डेन
स्रोत

1

पाइके , 5 बाइट्स

Pl02q

यहाँ कोशिश करो!

— श्री एक्सकोडर
स्रोत

1

जाप , 6 5 बाइट्स

k Ê¥2

इसे ऑनलाइन टेस्ट करें

व्याख्या

अधिकांश अन्य उत्तरों के समान ही बहुत कुछ करता है: kप्रमुख कारकों की सरणी प्राप्त करता है , Êइसकी लंबाई और ¥समानता के लिए जांच करता है 2।

— झबरा
स्रोत

÷k o)jयह भी काम करता है, दुर्भाग्य से यह एक ही लंबाई है :-(

— ETHproductions

0

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

{my \f=first $_%%*,2..$_;?f&&is-prime $_/f}

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

fइनपुट तर्क के 1 से अधिक सबसे छोटा कारक है $_, या Nilयदि $_1 है। फ़ंक्शन का रिटर्न मान fसही है ( यदि नहीं, तो Nil) और कारक द्वारा विभाजित इनपुट तर्क प्रमुख है।

यदि $_स्वयं अभाज्य है, तो 1 के fबराबर होगा $_, और $_ / f1 है, जो अभाज्य नहीं है, इसलिए सूत्र उस स्थिति में भी काम करता है।

— शॉन
स्रोत

क्या यह एक अर्धविराम है?

ब्रेकीलॉग , 2 बाइट्स

कैसे?

भूसी , 4 बाइट्स

कैसे?

गणितज्ञ, 16 बाइट्स

अजगर , 4 बाइट्स

कैसे?

पायथन 3 , 54 बाइट्स

रूबी , 56 48 बाइट्स

यह काम किस प्रकार करता है:

गणितज्ञ, 31 29 बाइट्स

नीम , 4 बाइट्स

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

जावास्क्रिप्ट (ईएस 6), 47 बाइट्स

डेमो

गणितज्ञ 32 बाइट्स

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

व्याख्या

दरअसल , 4 बाइट्स

05AB1E, 4 बाइट्स

MATL, 5 बाइट्स

व्याख्या

दिल्लोग एपीएल, 18 बाइट्स

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

व्याख्या

सिम्पी के साथ अजगर 1.1.1 , 57 44 बाइट्स

आर , 67 बाइट्स

रूबी , 35 + 8 = 43 बाइट्स

जावा 8, 69 61 बाइट्स

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

सी #, 112 बाइट्स

परी / जीपी , 17 बाइट्स

रेटिना , 45 बाइट्स

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

जे , 6 बाइट्स

पाइके , 5 बाइट्स

जाप , 6 5 बाइट्स

व्याख्या

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