Prime delicate
Ispirato da Trova il primo fragile più grande .
Rimuovendo almeno 1 cifra da un numero intero positivo, possiamo ottenere un diverso numero intero non negativo. Nota che questo è diverso dalla Removefunzione nella domanda collegata. Diciamo che un numero primo è delicato se tutti gli interi generati in questo modo non sono primi. Ad esempio, \$60649\$ genera i seguenti numeri interi:
0, 4, 6, 9, 49, 60, 64, 66, 69, 604, 606, 609, 649, 664, 669, 6049, 6064, 6069, 6649
Nessuno di questi numeri interi è primo, quindi \$60649\$è un primo delicato. Nota che tutti gli zeri iniziali vengono rimossi e che il requisito è "non primo", quindi \$0\$e \$1\$entrambi si qualificano, il che significa che, ad esempio, \$11\$ è un primo delicato.
Analogamente alla regola della sequenza standard , devi eseguire una delle seguenti attività:
- Dato un numero intero positivo \$n\$, restituisce due valori * distinti e coerenti a seconda che \$n\$ è un primo delicato o no
- Dato un numero intero positivo \$n\$, visualizza il \$n\$esimo delicato primo
- Dato un numero intero positivo \$n\$, visualizza il primo \$n\$ numeri primi delicati
- Emette infinitamente l'elenco dei primi delicati
* : Puoi scegliere di produrre invece due serie di valori, dove i valori nella serie corrispondono alla definizione della tua lingua di vero e falso. Ad esempio, una risposta Python può produrre un elenco vuoto per falso / vero e un elenco non vuoto altrimenti.
Puoi scegliere quali attività desideri svolgere.
È possibile immettere e visualizzare in qualsiasi modo standard e, poiché si tratta di code-golf , il codice più breve in byte vince
Per riferimento, i primi 20 primi delicati sono:
2, 3, 5, 7, 11, 19, 41, 61, 89, 409, 449, 499, 881, 991, 6469, 6949, 9001, 9049, 9649, 9949
Un altro paio a cui prestare attenzione:
821 - False (Removing the 8 and the 1 gives 2 which is prime)
Offro una taglia di +100 per una risposta che implementa uno degli I / O di sequenza standard piuttosto che il metodo del problema decisionale , che:
- è più breve di un'implementazione ingenua di un problema decisionale (includi una versione del genere come prova se non è già stata pubblicata)
- o che non si basa sul controllo se i valori sono numeri primi delicati o meno quando si generano valori (ad esempio, può usare il fatto che possono verificarsi solo cifre specifiche, o qualcos'altro che non è semplicemente un "loop su numeri, trovare numeri primi delicati" )
Questo è un po 'soggettivo rispetto a ciò che conta come "controllo di numeri primi delicati", quindi userò il mio miglior giudizio quando si tratta di assegnare la taglia.
Risposte
05AB1E , 4 byte
Codice
Utilizza la codifica 05AB1E . Controlla se il numero specificato è un numero primo delicato o meno.
æpJΘ
Provalo online! o Controlla tutti i numeri compresi tra 1 e 9949 .
Spiegazione
æ # Get the powerset of the number.
p # Check for each element whether it is a prime.
J # Join these numbers into one big number.
Θ # Check whether this joined number is equal to 1.
APL (Dyalog Extended) , 16 14 byte
</1⍭⍎⍕(⊢,,¨)\⍞
Provalo online!
-2 byte ( ∊⍎¨¨ → ⍎⍕) grazie a @ngn.
Programma completo che prende un singolo numero da stdin e stampa 1 (vero) o 0 (falso).
Il trucco qui è come genera tutte le sottosequenze non vuote:
(⊢,,¨)/ strfornisce tutte le sottosequenze distrcui include l'ultimo carattere.
(⊢,,¨)/ '1234'
→ '1' (⊢,,¨) '2' (⊢,,¨) '3' (⊢,,¨) '4'
→ '1' (⊢,,¨) '2' (⊢,,¨) '4' '34'
→ '1' (⊢,,¨) '4' '34' '24' '234'
→ '4' '34' '24' '234' '14' '134' '124' '1234'
(⊢,,¨)\ strsi applica(⊢,,¨)/a ciascun prefisso distr, fornendo tutte le sottosequenze non vuote come un elenco di elenchi di stringhe.
(⊢,,¨)\ '1234'
→ '1' ('2' '12') ('3' '23' '13' '123') ('4' '34' '24' '234' '14' '134' '124' '1234')
Spiegazione dell'intero codice:
</1⍭⍎⍕(⊢,,¨)\⍞
⍞ ⍝ Take n from stdin as a string
( )\ ⍝ For each prefix, reduce from right by
,¨ ⍝ prepend the previous char to each string
⊢, ⍝ and append to the previous list of strings
⍎⍕ ⍝ Convert nested strings to a single string,
⍝ and then eval it to get a simple integer vector
1⍭ ⍝ Test each number for primality
</ ⍝ Test if the only truth is the last one
Brachylog , 7 6 byte
ṗ⊇ᵘṗˢȮ
Provalo online!
ṗ⊇ᵘṗˢȮ the implicit input
ṗ is a prime
⊇ᵘ and from every unique subset
ṗˢ select the primes
Ȯ and this should be a list with one element (the prime input itself)
Gelatina , 7 byte
DŒPḌẒḄ’
Un collegamento monadico che accetta un numero intero positivo che restituisce zero (falso) se è un numero primo delicato, o un numero intero diverso da zero (vero) in caso contrario.
Provalo online! Oppure guarda i primi venti .
Come?
DŒPḌẒḄ’ - Link: n e.g. 824 409
D - decimal digits [8,2,4] [4,0,9]
ŒP - power-set [[],[8]...,[8,2,4]] [[],[4],...,[4,0,9]]
Ḍ - undecimal [0,8,2,4,82,84,24,824] [0,4,0,9,40,49,9,409]
Ẓ - is prime? [0,0,1,0,0,0,0,0] [0,0,0,0,0,0,0,1]
Ḅ - from binary 32 1
’ - decrement 31 0
Japt , 7 byte
¥à f_°j
Provalo o prova[0,1000)
¥à f_°j :Implicit input of integer string
¥ :Is equal to
à :Combinations
f :Filter
_ :By passing each through a function
° :Postfix increment, to cast to an integer
j :Is prime?
J , 25 23 byte
-2 grazie a Jonah!
Restituisce un elenco contenente 1 che è vero o 0 altrimenti.
1</@p:(#~2#:@i.@^#)&.":
Provalo online!
Come funziona
1</@p:(#~2#:@i.@^#)&.":
&.": convert the number to a string
( 2 ^#) 2 ^ length
#:@i.@ enumerated and to base 2
#~ select from the string based on the bit mask
&.": convert from strings to numbers
1 p: primes -> 1, non-primes -> 0
so in the delicate prime case, we have
(2^L) - 1 zeros and one 1 for the input itself
</@ reduce from left to right with less-than
(so last position is 1, everything else 0)
Pyth , 14 8 byte
qjfP_sTy
Provalo online!
Spiegazione
qjfP_sTy
f # filter
y # all subsets of input
P_sT # with a primality test
j # join result of filter on newlines
q # check if it equals input
Retina 0.8.2 , 53 byte
^
;
+%`;(.)
$1;$'¶$`; .+ $*
%A`^.?$|^(..+)\1+$
^1+¶+$
Provalo online! Il collegamento include casi di test. Spiegazione:
^
;
+%`;(.)
$1;$'¶$`;
Genera tutte le sottosequenze dell'input.
.+
$*
Converti quindi in unario.
%A`^.?$|^(..+)\1+$
Elimina quelli che non sono primi, ma non eliminare le nuove righe. (Funziona anche una sostituzione su più righe, ma è più difficile formattare una spiegazione.)
^1+¶+$
Verificare che l'input originale fosse primo ma nessuna delle sottosequenze appropriate lo era.
Scala , 173 170 byte
n=>(s"$n".indices.toSet.subsets.filter{x=>1<x.size&x.size<s"$n".size}.map(_.toSeq.sorted.map(""+n).mkString.toInt).toSet+n).filter{x=>x>1&2.to(x/2).forall(x%_>0)}==Set(n)
Provalo online!
R , 163 154 byte
function(x,n=nchar(x),s=sum)(a=apply(!expand.grid(rep(list(0:1),n)),1,function(v)(y=s((x%/%10^(n:1-1)%%10)[v]*10^(s(v):1-1)))&s(!y%%1:y)==2))[1]&!s(a[-1])
Provalo online!
Verifica la presenza di numeri primi tra i numeri formati rimuovendo tutte le combinazioni di cifre da x. La prima combinazione è la rimozione di nessuna cifra: questo deve essere VERO e tutti gli altri test principali devono essere FALSO.
Commentato:
is_delicate_prime=
function(x, # x = number to test
n=nchar(x), # n = number of digits of x
s=sum) # s = alias to sum() function
(a= # a = matrix of all prime-tests:
apply( # apply the function v to each of...
!expand.grid(rep(list(0:1),n)), # all combinations of n of TRUE/FALSE...
1, # row-by-row...
function(v) # defining the output of v as:
(y=s((x%/%10^(n:1-1)%%10) # the digits of x...
[v] # (considering only the elements chosen by v)...
*10^(s(v):1-1))) # multiplied by 10^((v-1)..0)...
&s(!y%%1:y)==2)) # tested for primality AND non-zero
[1] # Finally, output TRUE if a[1] is TRUE...
&!s(a[-1]) # and the sum of all other elements of a are FALSE
Wolfram Language (Mathematica) , 54 byte
Select[FromDigits/@Subsets@@RealDigits@#,PrimeQ]=={#}&
Provalo online!
JavaScript (ES6), 98 95 byte
Aspetta ncome una stringa. Restituisce un valore booleano.
n=>[...n].reduce((a,x)=>[...a,...a.map(y=>(g=k=>y%--k?g(k):(p+=q=y>1&k<2,y))(y+=x))],[p=0])|q/p
Provalo online!
Come?
Calcoliamo il gruppo di potenza delle cifre di nin modo tale che l'ordine venga conservato e esso nstesso venga calcolato per ultimo. Il risultato è vero se l'unico numero primo tra gli interi risultanti è l'ultimo.
Python 2 , 139 \$\cdots\$ 145 142 byte
Aggiunti 36 byte per correggere un bug gentilmente segnalato da pxeger .
Salvati 5 byte grazie a pxeger !!!
lambda n,R=range:all((g<2or any(g%i<1for i in R(2,g)))-(`g`==n)for g in{int(''.join(n[j]for j in R(len(n))if i>>j&1))for i in R(1,2**len(n))})
Provalo online!
Inserisce un numero intero come stringa e restituisce Truese è un numero primo delicato o Falsealtro.
Pitone 3.8 (pre-release) , 146 144 byte
-2 byte rimuovendo le parentesi ridondanti
Stavo anche lavorando a una risposta molto simile appena prima che Noodle9 pubblicasse la loro, e ho combinato le idee da quella per ottenere questo ( votalo! ). Quello ora è abbastanza diverso perché inizialmente ne avevano uno rotto, quindi ho pensato di pubblicare il mio.
lambda s,R=range:(l:=len(s))*all((g!=int(s))^(g>1)&all(g%k for k in R(2,g))for g in{int(''.join(s[j]for j in R(l)if i>>j&1))for i in R(1,2**l)})
Provalo online!
Spiegazione:
lambda s,R=range:(l:=len(s))*all((g!=int(s))^(g>1)&all(g%k for k in R(2,g))for g in{int(''.join(s[j]for j in R(l)if i>>j&1))for i in R(1,2**l)})
lambda s : function
,R=range alias `range` built-in to `R`
{ s[j]for j in R(l)if i>>j&1 for i in R(1,2**l)} compute the power-set (excluding the empty set)
int(''.join( )) convert each list of digits to an integer
all( for g in ) check the integers for primality
all(g%k for k in R(2,g)) check for factors in the number
(g>1)& makes sure 0 and 1 aren't treated as prime
(g!=int(s))^ ensure the number itself is prime
(l:=len(s))* store the length in `l`
SageMath , 139 byte
def f(n):s=str(n);l=len(s);return p(n)*all(~-p(g)for g in{int(''.join(s[j]for j in R(l)if i>>j&1))for i in R(1,2**l-1)})
R=range;p=is_prime
Provalo online!
Port della mia risposta Python.
Python 3 ,
Utilizzando itertools e una ricetta per il golf powerset.
lambda s,R=range:all(p(int(''.join(t)),R)for t in sum(([*combinations(s,k)]for k in R(1,len(s))),[]))>p(int(s),R)
from itertools import*
p=lambda n,R:any(n%i<1for i in R(2,n))or 2>n
Provalo online!
Prevede l'input come stringa.
La funzione prestituisce Truese il suo input non è primo e Falsese è primo; la funzione main restituisce (forall t, p(t)) > p(s)dove tprende tutti i "sottovalori" di s. L'unico modo per i booleani di soddisfare questa disuguaglianza è True > False, il che significa che tutti tsono non prime e snon sono non prime.
Dichiarazione di non responsabilità: c'erano già due risposte Python quando ho pubblicato questa.