Números magnánimos


24

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


Estoy confundido por la definición del desafío de cómo 1 y 2 son incluso entradas válidas. Y mucho menos el hecho de que 1con un signo más insertado entre dos caracteres (sin inserción) solo puede dar como resultado 1, lo que en sí mismo no es primo.
Magic Octopus Urn

44
@MagicOctopusUrn El plus debe ser insertado entre dos dígitos, por lo tanto ya 1y 2no tienen dos dígitos, el conjunto de expresiones está vacío. Todos los miembros del conjunto vacío son primos. Además, ninguno de ellos lo es, pero eso es aparte del punto. Es un poco confuso, te lo daré, pero creo que tiene más sentido que las alternativas.
Wheat Wizard

Respuestas:


8

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ómo funciona 1 - 9? El producto de un conjunto vacío es 1? ¿Por qué?
Magic Octopus Urn

@MagicOctopusUrn El producto vacío siempre es igual a 1.
Adnan

@MagicOctopusUrn Tomar el producto es básicamente comenzar 1y multiplicarlo por cada elemento del conjunto, así que ...
ETHproductions

1
Ah, matemáticamente tiene sentido. Guess igual que la forma sumen []que es equivalente a 0, utilizando la propiedad de inducción en la aplicación era muy inteligente.
Magic Octopus Urn

@ jontro Sí, en UTF-8 , es de 14 bytes. Sin embargo, 05AB1E usa la página de códigos 05AB1E , donde son 10 bytes.
Adnan

7

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


Esto debería ser dos respuestas separadas. Además, la solución de Mathematica da resultados incorrectos para 1, 98y 4063.
ngenisis

6

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.


4

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!



3

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

1
Creo que hay al menos dos formas de acortar esto: en primer lugar, reemplazar el bucle pcon recursividad; en segundo lugar, acumule los resultados de modo que la función principal solo requiera una returndeclaración al hacer que el valor centinela sea pbe -1y usar &para verificar que todos los valores devueltos sean -1.
Peter Taylor

1
En realidad, el más grande es: no use cadenas.
Peter Taylor

n->{for(long d=10,m=1;d<n;d*=10)m|=p(n/d+n%d,2)-2;return m>0;}long p(long n,int i){return i<n?p(n%i<1?1:n,i+1):n;}
Peter Taylor

@PeterTaylor ¡Gracias por las sugerencias! En cuanto a su función sugerida al final, ¿está seguro de que es correcta? Actualmente doy resultados incorrectos , a menos que esté haciendo algo mal.
Kevin Cruijssen

1
Ok, d<=npara manejar 10. El desbordamiento de la pila no es un problema (la especificación no proporciona un rango de entrada que debe manejarse), pero se puede solucionar y se pueden obtener más ahorros volviendo a un bucle y alineando .
Peter Taylor

2

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

2

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!



Genial, gracias @HyperNeutrino
officialaimm

1
96 bytes : no necesita el x-1al final del rango; La gama es exclusiva a la derecha.
HyperNeutrino

1
Esto falla por 10 (nuevo caso de prueba).
Dennis

1
Esto falla para 10. También creo que 10 es el único número para el que falla.
Wheat Wizard

2

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.


Gah! ¡Casi idéntico a la solución alternativa en la que estaba trabajando! Aquí están los 22 bytes que tenía hasta ahora. EDITAR: Lo bajé a 20 bytes combinando cosas de ambos.
Shaggy

@Shaggy Curiosamente, estoy trabajando en mi edición en este momento ... Es sorprendentemente similar a la tuya: ethproductions.github.io/japt/…
Oliver

Sugerencia: xconvierte automáticamente los elementos de la matriz a números ;-)
ETHproductions

Sí, ahí es donde yo también iría, @ETHproductions: 16 bytes .
Shaggy

Además, XîUes genio. Creo que U¯Xfunciona para la misma duración, pero aún así
ETHproductions

2

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

2

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.


0&! es más corto que 1+:*
Peter Taylor

@PeterTaylor Ooh eso es inteligente ... abusaste del hecho de que !devuelve una intersección booleana y utilizada con el valor falso 0para que puedas hacer 0&!3 en lugar de 1&!!...
Erik the Outgolfer

Puede guardar otros 3 bytes asignando la entrada a una variable, lo que simplifica las manipulaciones de la pila, y utilizando el ,operador de filtro en lugar de f.
Peter Taylor

PD: No veo ningún abuso al usar !para convertir a un booleano: eso era estándar en GolfScript y es estándar en CJam. Y 1&!!sería incorrecto: 0&!es la prueba obvia porque el requisito es general, no existe.
Peter Taylor

@PeterTaylor Eso no es lo que quise decir ...: P
Erik the Outgolfer

2

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


@ETHproductions, no, tenías razón; la versión original estaba equivocada; solo buscando primos magnánimos . ¬£i+YÄÃe@OxX j
Shaggy

Sabía que no me había
vuelto

1
Falla 4063(debe ser verdadero, es falso). El truco aquí es que JS cree que un líder 0significa que quieres octal ...
ETHproductions

Hmmm ... OK, creo que tengo una alternativa: tomaré unos minutos para probarlo y jugar golf.
Shaggy

Creo que esto fallará ahora en algún caso que contenga dos ceros seguidos de otros dos dígitos ... ( 40043por ejemplo) Simplemente agregue un +después 0para solucionar esto.
ETHproductions

2

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


2

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.


2

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.


1

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.


1

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

Si utiliza p x=[x]==[i|i<-[2..x],x`mod`i<1]como su primer cheque, puede guardar 2 bytes.
Wheat Wizard

También puede usar en divMod x$10^ilugar dex`divMod`(10^i)
Wheat Wizard

@WheatWizard: Sabía que la prueba principal aún podría mejorarse de alguna manera. ;) ¡Gracias!
siracusa

1

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


1

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?

0

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.


0

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.


0

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

0

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


0

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

0

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 .


Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.