26

Sorprendentemente, non penso che abbiamo una domanda di code-golf per determinare se un numero è semiprime .

Un semiprime è un numero naturale che è il prodotto di due numeri primi (non necessariamente distinti).

Abbastanza semplice, ma un concetto notevolmente importante.

Dato un numero intero positivo, determinare se si tratta di un semiprime. Il tuo output può essere in qualsiasi forma purché fornisca lo stesso output per qualsiasi valore di verità o falsità. Puoi anche supporre che il tuo input sia abbastanza piccolo da non causare problemi di overflow o prestazioni.

Casi test:

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

Questo è code-golf , quindi si applicano le regole standard!

code-golf sequence

— Lord Farquaad
fonte

4

@WheatWizard C'è una leggera differenza nel fatto che si richiedono 3 numeri primi (non una grande differenza per quasi tutte le lingue) ed è solo per numeri primi distinti (abbastanza diversi per alcune lingue). Posso discuterne con te in chat se desideri continuare una discussione più dettagliata.

— HyperNeutrino,

2

@WheatWizard Sollevi un buon punto, ma allo stesso modo, abbiamo già un sacco di molti tipi di domande e sebbene, a differenza di ciò che esprimi, la maggior parte di esse aggiunge un contributo significativo alla loro area, questa domanda ha abbastanza una differenza che credo che meriti una domanda / post separati.

— HyperNeutrino,

2

@hyperneutrino guardando le risposte su entrambe le sfide, sembra che la differenza sia un singolo numero nel codice sorgente, 2 vs 3. Difficilmente la definirei una grande differenza.

— Wheat Wizard

2

@WheatWizard C'è anche "diverso" vs "non diverso" ...

— HyperNeutrino

3

@LordFarquaad Solo perché è un duplicato non significa che sia un male. Nella mia mente essere un duplicato è una buona cosa, significa che stai chiedendo una cosa che la comunità trova abbastanza interessante da aver già chiesto.

— Wheat Wizard

19

Brachylog , 2 byte

Fondamentalmente un porto dalla risposta di Fatalize alla sfida del numero di Sphenic.

ḋĊ

Provalo online!

Come?

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

— Jonathan Allan
fonte

1

La lingua giusta per il lavoro in effetti: P

— HyperNeutrino

2

@Uriel Ċè in realtà un elenco integrato di due variabili; essendo un linguaggio dichiarativo, l'output è, per impostazione predefinita, un test di soddisfazione (ad esempio, ḋda solo sarebbe output true.per numeri interi non negativi).

— Jonathan Allan,

Come sono questi 2 byte?

— Harold,

1

@harold Ho appena aggiornato per creare "byte" nel collegamento dell'intestazione alla tabella codici di Brachylog. Una discarica esadecimale sarebbe c6 eb.

— Jonathan Allan,

16

Buccia , 4 byte

_{Guarda ma niente Unicode!}

=2Lp

Provalo online!

Come?

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

— Jonathan Allan
fonte

8

Mathematica, 16 byte

PrimeOmega@#==2&

PrimeOmega conta il numero di fattori primi, contando la molteplicità.

— ngenisis
fonte

1

Dang, c'è un builtin?

— JungHwan Min

1

@JungHwanMin Se solo ci fosseSemiprimeQ

— ngenisis

Bello. Non sapevo diPrimeOmega

— DavidC

7

Pyth , 4 byte

q2lP

Suite di test .

Come?

q2lPQ     - Q is implicit input.

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

— Mr. Xcoder
fonte

Accidenti, builtins più brevi! :(

— HyperNeutrino il

7

Python 3 , 54 byte

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

Provalo online!

^{Il verson precedente aveva alcuni problemi di arrotondamento sui numeri cubo di grandi dimensioni ( 125, 343, ecc)}
Questo calcola la quantità di divisori (non solo numeri primi), se ha 1o 2si restituisce True.
L'unica eccezione è quando un numero ha più di due fattori primi ma solo due divisori. In questo caso è un cubo perfetto di un numero primo (i suoi divisori sono la radice del cubo e la radice del cubo al quadrato). x**3==ncoprirà questo caso, aggiungendone uno alla voce radice del cubo si spinge la somma fino a un conteggio di 3 e si interrompe il falso positivo. ^{grazie Jonathan Allan per aver scritto con questa bellissima spiegazione}

— asta
fonte

Questa affermazione 8 è semiprime

— xnor

n**(1/3)%1>0<sum...dovrebbe funzionare.

— Dennis,

1

@xnor l'ha risolto.

— Rod

Ha apportato una piccola modifica (ad esempio, 6 cubi ha molti più divisori)

— Jonathan Allan,

6

Rubino , 56 48 byte

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

Provalo online!

Come funziona:

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

Grazie Value Ink per l'idea che ha risparmiato 8 byte.

— GB
fonte

Perché non solo ciniziare da 0 e contare, invece di renderlo un array a cui aggiungere tutti i fattori? In questo modo si elimina la necessità di utilizzare sizealla fine

— Value Ink

Hai ragione, è perché ho scritto la funzione di fattorizzazione per un'altra sfida e l'ho riutilizzata qui.

— GB

5

Mathematica, 31 29 byte

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

— JungHwan Min
fonte

4

Neim , 4 byte

𝐏𝐥δ𝔼

Provalo online!

— Okx
fonte

Puoi spiegare come sono 4 byte? ... Sono totalmente confuso.

— Mr. Xcoder,

Lol Ho appena avuto questo

— HyperNeutrino il

@ Mr.Xcoder Neim ha una tabella codici personalizzata

— JungHwan Min

@ Mr.Xcoder Utilizzando la tabella codici Neim, questo è 𝐏, 𝐥, δ, e 𝔼come singolo byte.

— HyperNeutrino,

@HyperNeutrino Ho appena offuscato un po 'il 2, e ora questa è l'unica risposta senza 2 :)

— Okx,

4

Python 2 , 67 byte

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]

Provalo online!

-10 byte grazie a @JonathanAllan!

Il merito dell'algoritmo di fattorizzazione Prime va a Dennis (nella versione iniziale)

— Mr. Xcoder
fonte

Hai usato il codice dalla risposta di Dennis ? In tal caso, dovresti dare credito.

— totalmente umano il

1

@totallyhuman Oh sì, scusa. L'ho usato in 2 risposte diverse oggi e gli ho dato credito in una di esse, ma ho dimenticato di farlo ancora una volta. Grazie per averlo individuato!

— Mr. Xcoder,

1

67 byte

— Jonathan Allan il

@JonathanAllan Wow, grazie mille!

— Mr. Xcoder,

55 byte

— Halvard Hummel

4

JavaScript (ES6), 47 byte

Restituisce un valore booleano.

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

dimostrazione

Mostra snippet di codice

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`, `
)

Espandi frammento

— Arnauld
fonte

4

Mathematica 32 byte

Grazie a ngenesis per 1 byte salvato

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

— DavidC
fonte

1

Salvare un byte utilizzando ;;invece di All.

— ngenisi,

3

Gelatina , 5 byte

ÆfL=2

Provalo online!

Spiegazione

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

— HyperNeutrino
fonte

3

In realtà , 4 byte

ol2=

Provalo online!

— Mr. Xcoder
fonte

3

05AB1E, 4 byte

Òg2Q

Provalo online!

Come?

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

— Uriel
fonte

3

MATL, 5 byte

Yfn2=

Provalo online!

Spiegazione

Yf - Fattori primari.
n - Lunghezza
2= - È uguale a 2?

— Mr. Xcoder
fonte

3

Dyalog APL, 18 byte

⎕CY'dfns'
2=≢3pco⎕

Provalo online!

Come?

⎕CY'dfns' - importazione pco

3pco⎕- eseguito pcosu input con argomento sinistro 3 (fattori primi)

2=≢ - lunghezza = 2?

— Uriel
fonte

3

Gaia , 4 byte

ḍl2=

4 byte sembra essere una lunghezza comune, mi chiedo perché ...: P

Provalo online!

Spiegazione

ḍ     Prime factors
 l    Length
  2=  Equals 2?

— Gatto di affari
fonte

4 byte sembra essere una lunghezza comune, mi chiedo perché ... - Probabilmente perché tutte le risposte sono fattori primi, lunghezza, è uguale a 2?

— Mr. Xcoder

@MrXcoder Sì, esattamente

— Business Cat

4 dei quali sono miei BTW> _>

— Mr. Xcoder

4 è anche il primo semiprime. Spaventoso!

— Neil,

3

Python con SymPy 1.1.1 , 57 44 byte

-13 byte grazie ad alephalpha (usare 1.1.1 primeomega)

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

Provalo online!

— Jonathan Allan
fonte

lambda n:primeomega(n)==2

— alephalpha,

Ah, questo mi ricorda di aggiornare dalla 1.0, grazie!

— Jonathan Allan,

3

R , 67 byte

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

Provalo online!

— Perdente Suora
fonte

2

Rubino , 35 + 8 = 43 byte

Utilizza la -rprimebandiera per sbloccare la prime_divisionfunzione.

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

Provalo online!

— Value Ink
fonte

2

Java 8, 69 61 byte

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

-8 byte grazie a @Nevay .

Provalo qui.

— Kevin Cruijssen
fonte

1

È possibile rimuovere l'istruzione else (che potrebbe essere else++r;) per salvare 8 byte n->{int r=1,c=2;for(;r++<n;)for(;n%r<1;n/=r)c--;return c==0;}.

— Nevay,

1

Python 2 , 75 65 byte

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

Provalo online!

Tutto il merito per la risposta di xnor per il codice di fattorizzazione in prime originale.

— totallyhuman
fonte

1

C #, 112 byte

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));}

Con la formattazione applicata:

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));
}

E come programma di test:

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 ();
        }
    }
}

Che ha l'output:

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
fonte

1

Pari / GP , 17 byte

n->bigomega(n)==2

Provalo online!

— alephalpha
fonte

1

Retina , 45 byte

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

Provalo online! Il link include casi di test. Spiegazione:

.+
$*

Converti in unario.

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

Prova a trovare due fattori.

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

Assicurati che entrambi i fattori siano primi.

Accertarsi che siano stati trovati due fattori.

— Neil
fonte

1

Python 2, 90 byte

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

faccetta un numero intero nmaggiore o uguale a1 , restituisce booleani.

Provalo online!

Casi test:

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

1

J , 6 byte

5 byte funzioneranno come una tantum:

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

Credo di averne bisogno di sei quando definisco la funzione:

   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

— danese
fonte

1

Pyke , 5 byte

Pl02q

Provalo qui!

— Mr. Xcoder
fonte

1

Japt , 6 5 byte

k Ê¥2

Provalo online

Spiegazione

Fa praticamente la stessa cosa della maggior parte delle altre risposte: kottiene la matrice di fattori primi, ne Êprende la lunghezza e ¥verifica l'uguaglianza 2.

— ispido
fonte

÷k o)jfunziona anche, purtroppo ha la stessa lunghezza :-(

— ETHproductions

0

Perl 6 , 43 byte

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

Provalo online!

fè il fattore più piccolo maggiore di 1 dell'argomento di input $_, oppure Nilif $_è 1. Il valore di ritorno della funzione è true se fè true (ovvero, nonNil ) E l'argomento input diviso per il fattore è prime.

Se $_stesso è primo, allora fsarà uguale a $_, ed $_ / fè 1, che non è primo, quindi anche la formula funziona in quel caso.

— Sean
fonte

È un semiprime?

Brachylog , 2 byte

Come?

Buccia , 4 byte

Come?

Mathematica, 16 byte

Pyth , 4 byte

Come?

Python 3 , 54 byte

Rubino , 56 48 byte

Come funziona:

Mathematica, 31 29 byte

Neim , 4 byte

Python 2 , 67 byte

JavaScript (ES6), 47 byte

dimostrazione

Mathematica 32 byte

Gelatina , 5 byte

Spiegazione

In realtà , 4 byte

05AB1E, 4 byte

MATL, 5 byte

Spiegazione

Dyalog APL, 18 byte

Gaia , 4 byte

Spiegazione

Python con SymPy 1.1.1 , 57 44 byte

R , 67 byte

Rubino , 35 + 8 = 43 byte

Java 8, 69 61 byte

Python 2 , 75 65 byte

C #, 112 byte

Pari / GP , 17 byte

Retina , 45 byte

Python 2, 90 byte

J , 6 byte

Pyke , 5 byte

Japt , 6 5 byte

Spiegazione

Perl 6 , 43 byte