Prime délicate
Inspiré par Find the plus grand fragile prime .
En supprimant au moins 1 chiffre d'un entier positif, nous pouvons obtenir un entier non négatif différent. Notez que ceci est différent de la Removefonction de la question liée. Nous disons qu'un nombre premier est délicat si tous les entiers générés de cette manière ne sont pas premiers. Par exemple, \$60649\$ génère les entiers suivants:
0, 4, 6, 9, 49, 60, 64, 66, 69, 604, 606, 609, 649, 664, 669, 6049, 6064, 6069, 6649
Aucun de ces nombres entiers n'est premier, donc \$60649\$est une prime délicate. Notez que tous les zéros non significatifs sont supprimés et que la condition requise est "not prime", donc \$0\$et \$1\$les deux sont qualifiés, ce qui signifie que, par exemple, \$11\$ est une prime délicate.
Comme pour la règle de séquence standard , vous devez effectuer l'une des tâches suivantes:
- Étant donné un entier positif \$n\$, génère deux valeurs distinctes et cohérentes * selon que \$n\$ est un prime délicat ou pas
- Étant donné un entier positif \$n\$, affichez le \$n\$e délicat prime
- Étant donné un entier positif \$n\$, affiche le premier \$n\$ nombres premiers délicats
- Sortie à l'infini de la liste des nombres premiers délicats
* : Vous pouvez choisir de sortir deux ensembles de valeurs à la place, où les valeurs de l'ensemble correspondent à la définition de vérité et de faux dans votre langue. Par exemple, une réponse Python peut générer une liste vide pour faux / véridique et une liste non vide dans le cas contraire.
Vous pouvez choisir laquelle des tâches que vous souhaitez effectuer.
Vous pouvez entrer et sortir de n'importe quelle manière standard , et, comme il s'agit de code-golf , le code le plus court en octets gagne
Pour référence, les 20 premiers nombres premiers délicats sont:
2, 3, 5, 7, 11, 19, 41, 61, 89, 409, 449, 499, 881, 991, 6469, 6949, 9001, 9049, 9649, 9949
Quelques autres à surveiller:
821 - False (Removing the 8 and the 1 gives 2 which is prime)
Je vais offrir une prime de +100 pour une réponse qui implémente l'une des E / S de séquence standard plutôt que la méthode du problème de décision , soit:
- est plus courte qu'une implémentation naïve d'un problème de décision (veuillez inclure une telle version comme preuve si elle n'a pas déjà été publiée)
- ou qui ne repose pas sur la vérification si les valeurs sont des nombres premiers délicats ou non lors de la génération de valeurs (par exemple, peut utiliser le fait que seuls des chiffres spécifiques peuvent apparaître, ou quelque chose d'autre qui ne consiste pas simplement à faire une "boucle sur les nombres, à trouver des nombres premiers délicats" )
C'est un peu subjectif quant à ce qui compte comme "vérifier les nombres premiers délicats", donc j'utiliserai mon meilleur jugement quand il s'agit d'attribuer la prime.
Réponses
05AB1E , 4 octets
Code
Utilise le codage 05AB1E . Vérifie si le nombre donné est un nombre premier délicat ou non.
æpJΘ
Essayez-le en ligne! ou Vérifiez tous les nombres entre 1 et 9949 .
Explication
æ # 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 octets
</1⍭⍎⍕(⊢,,¨)\⍞
-2 octets ( ∊⍎¨¨ → ⍎⍕) grâce à @ngn.
Programme complet qui prend un seul nombre de stdin et affiche 1 (vrai) ou 0 (faux).
L'astuce ici est de savoir comment il génère toutes les sous-séquences non vides:
(⊢,,¨)/ strdonne toutes les sous-séquencesstrdont le dernier caractère.
(⊢,,¨)/ '1234'
→ '1' (⊢,,¨) '2' (⊢,,¨) '3' (⊢,,¨) '4'
→ '1' (⊢,,¨) '2' (⊢,,¨) '4' '34'
→ '1' (⊢,,¨) '4' '34' '24' '234'
→ '4' '34' '24' '234' '14' '134' '124' '1234'
(⊢,,¨)\ strs'applique(⊢,,¨)/à chaque préfixe destr, donnant toutes les sous-séquences non vides sous forme de liste de listes de chaînes.
(⊢,,¨)\ '1234'
→ '1' ('2' '12') ('3' '23' '13' '123') ('4' '34' '24' '234' '14' '134' '124' '1234')
Explication du code entier:
</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 octets
ṗ⊇ᵘṗˢȮ
ṗ⊇ᵘṗˢȮ 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)
Gelée , 7 octets
DŒPḌẒḄ’
Un lien monadique acceptant un entier positif qui renvoie zéro (falsey) si c'est un premier délicat, ou un entier non nul (vrai) sinon.
Essayez-le en ligne! Ou voyez les vingt premiers .
Comment?
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
J , 25 23 octets
-2 merci à Jonah!
Renvoie une liste contenant 1 étant vrai ou 0 dans le cas contraire.
1</@p:(#~2#:@i.@^#)&.":
Comment ça fonctionne
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 octets
qjfP_sTy
Explication
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 octets
^
;
+%`;(.)
$1;$'¶$`;
.+
$*
%A`^.?$|^(..+)\1+$
^1+¶+$
Essayez-le en ligne! Le lien comprend des cas de test. Explication:
^
;
+%`;(.)
$1;$'¶$`;
Générez toutes les sous-séquences de l'entrée.
.+
$*
Convertissez alors en unaire.
%A`^.?$|^(..+)\1+$
Supprimez ceux qui ne sont pas premiers, mais ne supprimez pas les nouvelles lignes. (Un remplacement multiligne fonctionne également, mais il est plus difficile de formater une explication.)
^1+¶+$
Vérifiez que l'entrée d'origine était principale mais qu'aucune des sous-séquences appropriées ne l'était.
Scala , 173 170 octets
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)
R , 163 154 octets
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])
Vérifie les nombres premiers parmi les nombres formés en supprimant toutes les combinaisons de chiffres de x. La première combinaison est la suppression de l' absence de chiffres: cela doit être VRAI, et tous les autres tests premiers doivent être FAUX.
Commenté:
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 octets
Select[FromDigits/@Subsets@@RealDigits@#,PrimeQ]=={#}&
JavaScript (ES6), 98 95 octets
Attend ncomme une chaîne. Renvoie une valeur booléenne.
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
Comment?
Nous calculons l'ensemble de puissance des chiffres de nde telle manière que l'ordre soit conservé et que nlui-même soit calculé en dernier. Le résultat est vrai si le seul premier parmi les entiers résultants est le dernier.
Python 2 , 139 \$\cdots\$ 145 142 octets
Ajout de 36 octets pour corriger un bug gentiment signalé par pxeger .
Sauvé 5 octets grâce à 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))})
Entre un entier sous forme de chaîne et renvoie Trues'il s'agit d'un premier délicat ou Falseautre.
Python 3.8 (pré-version) , 146 144 octets
-2 octets en supprimant les parenthèses redondantes
Je travaillais également sur une réponse très similaire juste avant que Noodle9 ne publie la leur, et j'ai combiné des idées à partir de cela pour obtenir ceci ( votez! ). Celui-ci est maintenant assez différent car ils en avaient initialement un cassé, alors j'ai pensé publier le mien.
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)})
Explication:
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 octets
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
Port de ma réponse Python.
Python 3 ,
En utilisant itertools et une recette de golf pour 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
Attend une entrée sous forme de chaîne.
La fonction pretourne Truesi son entrée n'est pas première et Falsesi elle est première; la fonction principale renvoie (forall t, p(t)) > p(s)où tprend toutes les "sous-valeurs" de s. La seule façon pour les booléens de satisfaire cette inégalité est True > False, ce qui signifie que tous tsont nonprimes et sne sont pas nonprimes.
Avertissement: Il y avait déjà deux réponses python lorsque j'ai posté celle-ci.