Dado un entero positivo como entrada, determine si es un número magnánimo.

Un número magnánimo es un número tal que cualquier inserción de un +signo entre dos dígitos en la base 10 da como resultado una expresión de un entero primo.

Por ejemplo 40427 es magnánimo porque

4+0427  = 431  is prime
40+427  = 467  is prime
404+27  = 431  is prime
4042+7  = 4049 is prime

Salida

Debe generar dos valores distintos, uno cuando la entrada es magnánima y otro cuando la entrada no lo es.

Tanteo

El objetivo de este concurso será hacer que el tamaño del código fuente escrito para resolver esta tarea, dado en bytes, sea lo más pequeño posible.

Casos de prueba

1       -> True
2       -> True
4       -> True
10      -> False
98      -> True
101     -> True
109     -> False
819     -> False
4063    -> True
40427   -> True
2000221 -> True

OEIS 253996

05AB1E , 10 bytes

Código

η¨¹.s¨R+pP

Utiliza la codificación 05AB1E . Pruébalo en línea! o Verifique todos los casos de prueba!

Explicación

η¨             # Take the prefixes of the input and remove the last element
  ¹.s¨         # Take the suffixes of the input and remove the last element
      R        # Reverse the array of suffixes
       +       # Vectorized addition
        p      # Check if each element is prime
         P     # Product of the array

C (gcc) , 8384 85 83 84 86 75 111 bytes

Todas las optimizaciones están desactivadas y solo en GCC de 32 bits.

-1 byte gracias a @ceilingcat

+ algunos bytes para el 1caso.

+ algunos bytes para funciones reutilizables.

i,j,r,s;f(a){for(i=10,r=1;a/i;i*=10)for(s=a%i+a/i,r*=s-1,j=2;j<s;)r*=s%j++>0;a=!r;}

Toma la entrada como un entero. Devuelve 1 para casos falsos, 0 para casos verdaderos.

Pruébalo en línea!

Vea mi otra respuesta para el código de Mathematica (55 bytes).

Retina , 38 bytes

\B
$`$*_$'$*_
S`\d
G`^_$|^(__+)\1+$
^$

Pruébalo en línea!

Imprime 1números magnánimos y 0otros.

Explicación

\B
$`$*_$'$*_

Comenzamos haciendo coincidir cada posición entre dos dígitos (posiciones que no son límites de palabras) e insertando tanto el prefijo como el sufijo de esa coincidencia en unario, utilizando _como dígito unario. Entonces, en lugar de insertar +s, insertamos directamente el resultado unario de la suma allí.

S`\d

Ahora dividimos la cadena alrededor de los dígitos, de modo que cada suma vaya en su propia línea y eliminemos esos dígitos (también habrá una línea inicial y posterior vacía, pero eso no es importante).

G`^_$|^(__+)\1+$

Esta es la expresión regular estándar para unir números no primos en unario. Usar una Getapa de repetición aquí significa que simplemente mantenemos todas las líneas que contienen no primos positivos (descartando las líneas vacías).

^$

Finalmente verificamos si la cadena está vacía. Si la entrada fue magnánima, la etapa anterior habrá descartado todas las líneas (porque eran todas primas), y esto nos da 1. De lo contrario, si alguna línea no era un primo, permanecerá en la cadena y la expresión regular falla, dando 0.

Python 2 , 82 79 78 bytes

f=lambda n,d=10:n<d or d/n<all((n/d+n%d)%k*f(n,10*d)for k in range(2,n/d+n%d))

Esto es lento y solo puede hacer frente a los casos de prueba con la memorización.

Pruébalo en línea!

Versión alternativa, 79 bytes.

f=lambda n,d=10:n<d or f(n,10*d)>d/n<all((n/d+n%d)%k for k in range(2,n/d+n%d))

Acelerado a costa de un byte.

Pruébalo en línea!

Jalea , 12 bytes

DJ⁵*⁸dṖS€ÆPẠ

Pruébalo en línea!

Verifique todos los casos de prueba.

Java 8, 175 171 94 88 bytes

n->{long d=10,r=0,i,t;for(;d<=n;d*=10,r|=t-i)for(t=n/d+n%d,i=1;t%++i%t>0;);return r==0;}

-77 gracias a @PeterTaylor al usar una aritmética (en lugar de String with .substring) y deshacerse del método separado para verificar si el entero es primo.
-6 bytes usando el método de verificación principal de @SaraJ , ¡así que asegúrate de votarla!

Pruébalo aquí

Explicación:

n->{                  // Method with long as both parameter and return-type
  long d=10,r=0,i,t;  //  Some temp longs
  for(;d<=n           //  Loop as long as `d` is below or equal to input `n`
                      //  (inclusive instead of exclusive due to special case 10)
      ;               //    After every iteration:
       d*=10,         //     Multiple `d` by 10
       r|=t-i)        //     and Bitwise-OR `r` with `t-i`
    for(t=n/d+n%d,    //   Set `t` to `n` integer-divided by `d` plus `n` modulo-`d`
        i=1;          //   Set `i` to 1
        t%++i%t>0;);  //   Inner oop as long as `t` modulo `i+1` modulo `t` is not 0 yet
                      //   (after we've first increased `i` by 1 with `++i`)
                      //   (if `t` equals `i` afterwards, it means `t` is a prime)
  return r==0;}       //  Return if `r` is still 0

Pyth , 14 bytes

.AmP_ssMcQ]dtU

Pruébalo en línea! Se mostrará Truesi el número es magnánimo, de lo Falsecontrario. Toma el número como una cadena.

Explicaciones

.AmP_ssMcQ]dtU

              Q    # Implicit input Q
            tU     # Generate the range [1, 2, ..., len(Q)-1]
  m                # For each index d in the above range...
        cQ]d       # Split Q at index d
      sM           # Convert the two parts to integers
     s             # Sum
   P_              # Check it is a prime
.A                 # ...end for. Check all elements are True

Python 2 , 104102 98 96103 bytes

• Gracias a @Wheat Wizard por 2 bytes: hecho icompletamente anónimo ya que se llama solo una vez.
• Gracias a @Hyperneutrino por 4 bytes: una forma más inteligente de obtener los números del número principal en lugar de cortarlos
• @Hyperneutrino guardó otros 2 bytes: x-1solo xpara la prueba de verificación principal.
• Se x=10corrigió la falla para el caso , agregando así 7 Bytes, gracias a @Dennis y @Wheat Wizard por detectarlo: mi versión anterior estaba considerando 1 como primo

lambda x:all((lambda x:x>1and all(x%j for j in range(2,x)))(x/10**j+x%10**j)for j in range(1,len(`x`)))

Pruébalo en línea!

Japt , 24 16 bytes

Esto fue más o menos una colaboración entre @Shaggy, @ETHproduction y yo.

¬£[YîU UtY]xÃÅej

Pruébalo en línea!

Toma la entrada como una cadena.

Pip , 25 24 bytes

$&0N_%,_=1M$+(a^@_)M1,#a

Pruébalo en línea!

Explicación

aes el primer argumento de línea de comandos. 1,#agenera un rango que contiene números a 1través len(a)-1. Para esto, mapeamos una función lambda:

$+(a^@_)
   a^@_   Split a at this index
$+(    )  Fold the resulting 2-element list on +

Luego, mapeamos otra función lambda 0N_%,_=1, que prueba la primalidad. Lo tomé de esta respuesta ; Puedes leer la explicación allí. Finalmente, doblamos la lista en AND lógico ( $&). El resultado es 1si todas las sumas fueran primas, 0si alguna de ellas no lo fuera.

Ejemplo, con entrada de 4063:

                    1,#a   [1; 2; 3]
           $+(a^@_)M       [67; 103; 409]
  0N_%,_=1M                [1; 1; 1]
$&                         1

CJam , 22 bytes

r:L,({)_L<i\L>i+mp!},!

Pruébalo en línea!

Imprime un entero positivo para la verdad, cero para la falsedad.

-1 gracias a un ingenioso truco de Peter Taylor .
-3 gracias a otro consejo de Peter Taylor.

Japt , 23 bytes

Toma la entrada como una cadena.

Dang it; golpeado hasta el golpe en una alternativa mucho más corta en la que estaba trabajando.

£i+Ýe@OxXr"%+0+"'+)j

Pruébalo

Mathematica, 75 bytes

And@@Table[PrimeQ@ToExpression@StringInsert[#,"+",n],{n,2,StringLength@#}]&

Functionque espera a String. PrimeQ@ToExpression@StringInsert[#,"+",n]devuelve si insertar un +después del ndígito th da un número primo. Table[...,{n,2,StringLength@#}]da la lista de estos valores como nrangos desde 2hasta la longitud de la cadena. Luego tomamos Andcada uno de los elementos de esa lista. Convenientemente, si StringLength@#<2, entonces Table[...]es la lista vacía, para la cualAnd@@{}==True

Mathematica, 55 50 45 49 50 54 62 62 bytes

Parece que debería publicarlo por separado.

+6 bytes para la longitud del código medida nuevamente.

+5 bytes gracias a ngenisis.

And@@(qPrimeQ[#~Mod~q+⌊#/q⌋])@Rest@PowerRange@#&

Toma la entrada como un entero y devuelve regular Truey False. El intermedio es unicode 0xF4A1, abreviatura de Function[,]. La longitud del código se mide según el tamaño del archivo (UTF-8 sin BOM), comente si no es correcto.

PowerRange[x]devuelve 1, 10, 100 ... no mayor que x, que se introduce en Mathematica 10.

Inglés simple 4,204 341 315 251 241 240 bytes

(Re-) incorporó pruebas de primalidad en la biblioteca de Plain English, moviendo 3.863 bytes a la biblioteca de Plain English. Se eliminaron 26 bytes de espacio en blanco. Ahorró 64 bytes al abreviar las variables locales. Ahorró 10 bytes al abreviar la interfaz. Según la sugerencia de RosLuP , se guardó 1 byte al cambiar cómo se inicializa e incrementa m.

To decide if a n number is g:
Put 1 in a m number.
Loop.
Multiply the m by 10.
If the m is greater than the n, say yes.
Divide the n by the m giving a q quotient and a r remainder.
Add the q to the r.
If the r is not prime, say no.
Repeat.

Versión no codificada del código final:

To decide if a number is magnanimous:
  Put 1 in another number.
  Loop.
    Multiply the other number by 10.
    If the other number is greater than the number, say yes.
    Divide the number by the other number giving a quotient and a remainder.
    Add the quotient to the remainder.
    If the remainder is not prime, say no.
  Repeat.

Notas: El IDE en inglés simple está disponible en github.com/Folds/english . El IDE se ejecuta en Windows. Se compila en código x86 de 32 bits.

La bifurcación dinámica del inglés simple de la Orden de Osmosia ya tenía pruebas de primalidad en la versión 4700, pero utilizaba un algoritmo muy ineficiente (desde enero hasta junio de 2017). Las versiones 4001-4011 de la bifurcación dinámica del sitio GitHub omitieron las pruebas de primalidad. La versión 4013 de la bifurcación dinámica del sitio GitHub incluye pruebas de primalidad. El código para realizar la prueba de primalidad se desarrolló como parte de revisiones anteriores de esta respuesta.

Perl 6 , 58 bytes

{?(10,10* *...^*>$_).map({$_ div$^a+$_%$^a}).all.is-prime}

Pruébalo en línea!

10, 10 * * ...^ * > $_es la secuencia geométrica de múltiplos de diez, tomada hasta una antes del elemento que excede el parámetro de entrada $_. Luego, solo verificamos que para cada potencia de diez, la suma del parámetro de entrada tomado div y modifique esa potencia sea primo.

Haskell 114 110 bytes

p x=[x]==[i|i<-[2..x],x`mod`i<1]
i!x|i<1=0<1|0<1=p(uncurry(+)$divMod x$10^i)&&(i-1)!x
f x=(length(show x)-1)!x

Sin disculpas con la explicación:

-- Check if x is a prime number
p x = [x] == [i | i<-[2..x], x`mod`i < 1]
-- Checks all pairs of numbers a '+' can be put in between
i ! x | i<1 = 0<1                                -- Single-digit numbers are always truthy
      | 0<1 = p (uncurry (+) $ divMod x $ 10^i)  -- Does x split at i digits from right sum up to a prime?
           && (i-1) ! x                          -- If so, check next pair
-- Start (!) with the number of digits in x minus one
f x = (length (show x)-1) ! x

Axioma, 88 bytes

f(n:PI):Boolean==(i:=10;repeat(q:=n quo i;q=0 or ~prime?(q+n rem i)=>break;i:=i*10);q=0)

prueba y resultados

(10) -> [[i,f(i)]  for i in [1,2,4,10,98,101,109,819,4063,40427,2000221,999999999999999999999999999999999999999999999]]
   (10)
   [[1,true], [2,true], [4,true], [10,false], [98,true], [101,true],
    [109,false], [819,false], [4063,true], [40427,true], [2000221,true],
    [999999999999999999999999999999999999999999999 ,false]]

Brachylog , 11 bytes

{~cĊℕᵐ+}ᶠṗᵐ

Pruébalo en línea!

{      }ᶠ      Find every
      +        sum of
   Ċ           two
    ℕᵐ         whole numbers
 ~c            which concatenate to the input,
          ᵐ    and assert that all of them
         ṗ     are prime.

Perl 6 , 35 bytes

{m:ex/^(.+)(.+)$/.all.sum.is-prime}

Pruébalo en línea!

Explicación:

{                                 }     # Anonymous code block that
 m:ex/^        $/                         # Match all
       (.+)(.+)                           # Splits of the input number
                 .all                     # Are all of them
                     .sum                   # When summed
                         .is-prime          # Prime?

Apilado , 51 bytes

[tostr:#'1-~>splitat tr['+',' '#`#~prime]map 1,all]

Pruébalo en línea!

Esta es una función. Funciona convirtiendo su argumento en una cadena ( tostr), duplicándolo y obteniendo su longitud ( :#'), restando 1 ( 1-), haciendo un rango de 1 a ese número ( ~>). La pila se ve más o menos así, para entrada 40427:

('40427' (1 2 3 4))

Realizamos vectorizados splitat, lo que da como resultado que la siguiente matriz esté en la parte superior de la pila:

(('4' '40' '404' '4042') ('0427' '427' '27' '7'))

Transponiendo esto con tr, obtenemos:

(('4' '0427') ('40' '427') ('404' '27') ('4042' '7'))

Luego, mapeamos la función ['+',' '## ~ prime] (withmap`). Esta función hace:

['+',' '#`#~prime]
 '+',                concatenate a plus sign (string)    `('4' '0427' '+')
     ' '#`           join by spaces                      `'4 0427 +'`
          #~         evaluate                            `431`
            prime    check primality                     `1`

Luego, después del mapa, concatenamos 1. Esto se debe a que alldevuelve undefuna lista vacía.

JavaScript (ES6), 70 bytes

P=(n,x=2)=>n%x?P(n,x+1):n==x
f=(n,i=10)=>i>n||P((n/i|0)+n%i)&f(n,i*10)

Falla en el último caso en mi navegador debido a un error de "demasiada recursividad" durante el cálculo P(200023). Esperemos que esto no lo invalide.

QBIC , 38 bytes

_L;|[a-1|q=q*µ!_sA,b|!+!_sA,b+1,a|!}?q

Explicación

_L |     Create a variable a and set it to the length of
  ;      the input string (A$)
[a-1|    FOR b = 1 to a-1
q=q*     multiply q by
 µ       -1 if prime, 0 if not, of
  !        a cast of 
   _s       a substring of
     A,       A$
     b        from index 1 to index b (only one index is given, so that is assumed to be the req. length from 1)
      |!   to number
 +         plus
 !         a cast of
  _s         a substring of
    A,         A$
    b+1        from index b+1
    ,a         for the length of a (does not error if it exceeds the end of the string)
      |!   to number
 }       NEXT 
 ?q      PRINT q, which is eitrher -1 or 1 for all-prime sums, or 0 otherwise

CJam (21 bytes)

r:R,({RiA@)#md+mp!},!

Demostración en línea , banco de pruebas en línea

Disección

r:R       e# Take a token of input and assign it to R
,(        e# Take the length of R minus one
{         e# Filter i = 0 to (length of R minus two)
  Ri      e#   Push R as an integer value
  A@)#    e#   Push 10 to the power of (i + 1)
  md      e#   divmod
  +mp!    e#   Add, primality test, negate result
},        e# The result of the filter is a list of splits which give a non-prime
!         e# Negate result, giving 0 for false and 1 for true

Pyth, 15 14 bytes

.AmP_svcz]dtUz

Banco de pruebas

Guardado un byte usando el cambio más reciente de Pyth.

APL (NARS), caracteres 35, bytes 70

{0≥k←¯1+≢⍕⍵:1⋄∧/0π(m∣⍵)+⌊⍵÷m←10*⍳k}

prueba:

  f←{0≥k←¯1+≢⍕⍵:1⋄∧/0π(m∣⍵)+⌊⍵÷m←10*⍳k}
  f¨1 2 4 10 98 101 109 819 4063 40427 2000221
1 1 1 0 1 1 0 0 1 1 1 

Esta sería la traducción en APL de Axiom post algo aquí ...

{0≥k←¯1+≢⍕⍵:1⋄∧/0π(m∣⍵)+⌊⍵÷m←10*⍳k}
 0≥k←¯1+≢⍕⍵:1⋄  assign to k the length as array of argument return 1 if that is <=0
 ∧/0π(m∣⍵)+⌊⍵÷m←10*⍳k
              m←10*⍳k  m is the array pow(10,1..k)
           ⌊⍵÷m       the array of quotient of argumet with m
          +           sum 
     (m∣⍵)            with array of remander
   0π                 build the binary array of "are prime each"
 ∧/                   and that array

PHP, 100 bytes

for(;++$k<strlen($a=$argn);$x+=$i==1)for($i=$n=substr($a,$k)+$b.=$a[$k-1];--$i&&$n%$i;);echo$x+2>$k;

imprime 1si la entrada es magnánima, si no la salida está vacía. Ejecutar como tubería -nRo probarlo en línea .

Perl 5 -p , 42 bytes

$\=1;s//map$\&&=($`+$')%$_,2..$`+$'-1/ge}{

Pruébalo en línea!