Primos delicados

Question

Inspirado en Find the mayor frágil prime .

Al eliminar al menos 1 dígito de un número entero positivo, podemos obtener un número entero no negativo diferente. Tenga en cuenta que esto es diferente a la Removefunción en la pregunta vinculada. Decimos que un número primo es delicado si todos los enteros generados de esta manera no son primos. Por ejemplo, \$60649\$ genera los siguientes enteros:

0, 4, 6, 9, 49, 60, 64, 66, 69, 604, 606, 609, 649, 664, 669, 6049, 6064, 6069, 6649

Ninguno de estos enteros es primo, por lo tanto \$60649\$es una flor delicada. Tenga en cuenta que se eliminan los ceros iniciales y que el requisito es "no primo", por lo que \$0\$y \$1\$ambos califican, lo que significa que, por ejemplo, \$11\$ es una flor delicada.

De manera similar a la regla de secuencia estándar , debe realizar una de las siguientes tareas:

• Dado un entero positivo \$n\$, genera dos valores distintos y consistentes ^* dependiendo de si \$n\$ es una flor delicada o no
• Dado un entero positivo \$n\$, muestra el \$n\$th delicada flor
• Dado un entero positivo \$n\$, muestra el primer \$n\$ primos delicados
• Genere infinitamente la lista de primos delicados

^* : En su lugar, puede optar por generar dos conjuntos de valores, donde los valores del conjunto corresponden a la definición de verdad y falsedad de su idioma. Por ejemplo, una respuesta de Python puede generar una lista vacía para falsey / truthy y una lista no vacía de lo contrario.

Puede elegir cuál de las tareas desea realizar.

Puede ingresar y emitir de cualquier manera estándar y, como se trata de un código de golf , el código más corto en bytes gana

Como referencia, los primeros 20 primos delicados son:

2, 3, 5, 7, 11, 19, 41, 61, 89, 409, 449, 499, 881, 991, 6469, 6949, 9001, 9049, 9649, 9949

Un par más a tener en cuenta:

821 - False (Removing the 8 and the 1 gives 2 which is prime)

---

Ofreceré una recompensa de +100 por una respuesta que implemente una de las E / S de secuencia estándar en lugar del método de problema de decisión , que:

• es más corto que una implementación ingenua de problemas de decisión (incluya dicha versión como prueba si aún no se ha publicado una)
• o que no se basa en verificar si los valores son números primos delicados o no al generar valores (por ejemplo, puede usar el hecho de que solo pueden ocurrir dígitos específicos, o algo más que no sea simplemente un "bucle sobre números, encontrar números primos delicados" )

Esto es un poco subjetivo en cuanto a lo que se considera "comprobar si hay primos delicados", así que usaré mi mejor juicio cuando se trata de otorgar la recompensa.

Answer 1

05AB1E , 4 bytes

Código

Utiliza la codificación 05AB1E . Comprueba si el número dado es un primo delicado o no.

æpJΘ

¡Pruébelo en línea! o Compruebe todos los números entre 1 y 9949 .

Explicación

æ      # 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.

Answer 2

APL (Dyalog extendido) , ¹⁶ 14 bytes

</1⍭⍎⍕(⊢,,¨)\⍞

¡Pruébelo en línea!

-2 bytes ( ∊⍎¨¨ → ⍎⍕) gracias a @ngn.

Programa completo que toma un solo número de stdin e imprime 1 (verdadero) o 0 (falso).

El truco aquí es cómo genera todas las subsecuencias no vacías:

• (⊢,,¨)/ strda todas las subsecuencias strque incluyen el último carácter.

  (⊢,,¨)/ '1234'
→ '1' (⊢,,¨) '2' (⊢,,¨) '3' (⊢,,¨) '4'
→ '1' (⊢,,¨) '2' (⊢,,¨) '4' '34'
→ '1' (⊢,,¨) '4' '34' '24' '234'
→ '4' '34' '24' '234' '14' '134' '124' '1234'

• (⊢,,¨)\ strse aplica (⊢,,¨)/a cada prefijo de str, dando todas las subsecuencias no vacías como una lista de listas de cadenas.

  (⊢,,¨)\ '1234'
→ '1' ('2' '12') ('3' '23' '13' '123') ('4' '34' '24' '234' '14' '134' '124' '1234')

Explicación de todo el código:

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

Answer 3

Brachylog , ⁷ 6 bytes

ṗ⊇ᵘṗˢȮ

¡Pruébelo en línea!

ṗ⊇ᵘṗˢȮ 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)

Answer 4

Gelatina , 7 bytes

DŒPḌẒḄ’

Un enlace monádico que acepta un entero positivo que devuelve cero (falsey) si es un número primo delicado, o un entero distinto de cero (verdadero) si no es así.

¡Pruébelo en línea! O vea los primeros veinte .

¿Cómo?

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

Answer 5

Japonés , 7 bytes

¥à f_°j

Pruébalo o prueba[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?

Answer 6

J , ²⁵ 23 bytes

-2 gracias a Jonah!

Devuelve una lista que contiene 1 como verdadero o 0 en caso contrario.

1</@p:(#~2#:@i.@^#)&.":

¡Pruébelo en línea!

Cómo funciona

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)

Answer 7

Pyth , ¹⁴ 8 bytes

qjfP_sTy

¡Pruébelo en línea!

Explicación

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

Answer 8

Retina 0.8.2 , 53 bytes

^
;
+%`;(.)
$1;$'¶$`;
.+
$*
%A`^.?$|^(..+)\1+$
^1+¶+$

¡Pruébelo en línea! El enlace incluye casos de prueba. Explicación:

^
;
+%`;(.)
$1;$'¶$`;

Genere todas las subsecuencias de la entrada.

.+
$*

Convierta luego en unario.

%A`^.?$|^(..+)\1+$

Elimine los que no sean principales, pero no elimine las nuevas líneas. (Una sustitución de varias líneas también funciona, pero es más difícil dar formato a una explicación).

^1+¶+$

Verifique que la entrada original fuera principal pero que ninguna de las subsecuencias adecuadas lo fuera.

Answer 9

Scala , 173 170 bytes

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)

¡Pruébelo en línea!

Answer 10

R , 163 154 bytes

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])

¡Pruébelo en línea!

Comprueba si hay primos entre los números formados al eliminar todas las combinaciones de dígitos de x. La primera combinación es la eliminación de ningún dígito: debe ser VERDADERO y todas las demás pruebas principales deben ser FALSAS.

Comentó:

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

Answer 11

Wolfram Language (Mathematica) , 54 bytes

Select[FromDigits/@Subsets@@RealDigits@#,PrimeQ]=={#}&

¡Pruébelo en línea!

Answer 12

JavaScript (ES6),  98  95 bytes

Espera ncomo una cadena. Devuelve un valor 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

¡Pruébelo en línea!

¿Cómo?

Calculamos el conjunto de potencias de los dígitos de nde tal manera que el orden se conserva y nse calcula en último lugar. El resultado es verdadero si el único primo entre los enteros resultantes es el último.

Answer 13

Python 2 , ^{139 \$\cdots\$ 145} 142 bytes

Se agregaron 36 bytes para corregir un error amablemente señalado por pxeger .
5 bytes guardados gracias 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))})

¡Pruébelo en línea!

Introduce un número entero como una cadena y devuelve Truesi es un número primo delicado o Falseno.

Answer 14

Python 3.8 (versión preliminar) , ¹⁴⁶¹⁴⁴ bytes

-2 bytes eliminando paréntesis redundantes

También estaba trabajando en una respuesta muy similar justo antes de que Noodle9 publicara la suya, y combiné ideas de eso para obtener esto (¡ votalo a favor! ). Ese ahora es bastante diferente porque inicialmente tenían uno roto, así que pensé en publicar el mío.

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

¡Pruébelo en línea!

Explicación:

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`

Answer 15

SageMath , 139 bytes

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

¡Pruébelo en línea!

Puerto de mi respuesta de Python.

Answer 16

Python 3 , 181 bytes

Usando herramientas de iteración y una receta de 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

¡Pruébelo en línea!

Espera entrada como una cadena.

La función pdevuelve Truesi su entrada no es prima y Falsesi es prima; la función principal devuelve (forall t, p(t)) > p(s)donde ttoma todos los "subvalores" de s. La única forma de que los booleanos satisfagan esta desigualdad es True > False, lo que significa que todos tson nonprimes y sno son nonprime.

Descargo de responsabilidad: ya había dos respuestas de Python cuando publiqué esta.