Étant donné un entier positif en entrée, déterminez s'il s'agit d'un nombre magnanime.

Un nombre magnanime est un nombre tel que toute insertion d'un +signe entre deux chiffres quelconques dans la base 10 entraîne l'expression d'un entier premier.

Par exemple, 40427 est magnanime car

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

Sortie

Vous devez sortir deux valeurs distinctes, une lorsque l'entrée est magnanime et une lorsque l'entrée ne l'est pas.

Notation

Le but de ce concours sera de rendre la taille du code source écrit pour résoudre cette tâche, donnée en octets, aussi petite que possible.

Cas de test

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 octets

Code

η¨¹.s¨R+pP

Utilise l' encodage 05AB1E . Essayez-le en ligne! ou Vérifiez tous les cas de test!

Explication

η¨             # 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 octets

Toutes les optimisations désactivées et uniquement sur GCC 32 bits.

-1 octet grâce à @ceilingcat

+ quelques octets pour le 1cas.

+ quelques octets pour les fonctions réutilisables.

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

Prend l'entrée comme un entier. Renvoie 1 pour les faux cas, 0 pour les vrais cas.

Essayez-le en ligne!

Voir ma autre réponse pour le code Mathematica (55 octets).

Rétine , 38 octets

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

Essayez-le en ligne!

Imprime 1pour les nombres magnanimes et 0autres.

Explication

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

Nous commençons par faire correspondre chaque position entre deux chiffres (positions qui ne sont pas des limites de mot) et en insérant le préfixe et le suffixe de cette correspondance en unaire, en utilisant _comme chiffre unaire. Ainsi, au lieu d'insérer +s, nous y insérons directement le résultat unaire de la somme.

S`\d

Maintenant, nous séparons la chaîne autour des chiffres, de sorte que chaque somme va sur sa propre ligne et nous nous débarrassons de ces chiffres (il y aura également une ligne de début et de fin vide, mais ce n'est pas important).

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

Il s'agit de l'expression rationnelle standard pour faire correspondre les nombres non premiers en unaire. L'utilisation d'une Gétape de représentation signifie ici que nous gardons simplement toutes les lignes qui contiennent des non-nombres positifs (en éliminant les lignes vides).

^$

Enfin, nous vérifions si la chaîne est vide. Si l'entrée était magnanime, l'étape précédente aura supprimé toutes les lignes (car elles étaient toutes des nombres premiers), et cela nous donne 1. Sinon, si une ligne n'était pas un nombre premier, elle restera dans la chaîne et l'expression régulière échouera, donnant 0.

Python 2 , 82 79 78 octets

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

Ceci est lent et ne peut faire face qu'aux cas de test avec mémorisation.

Essayez-le en ligne!

Version alternative, 79 octets

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

Accéléré au prix d'un octet.

Essayez-le en ligne!

Gelée , 12 octets

DJ⁵*⁸dṖS€ÆPẠ

Essayez-le en ligne!

Vérifiez tous les cas de test.

Java 8, 175 171 94 88 octets

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 grâce à @PeterTaylor en utilisant une arithmétique (au lieu de String with .substring) et en supprimant la méthode séparée pour vérifier si l'entier est un nombre premier.
-6 octets en utilisant la méthode de vérification principale de @SaraJ , alors assurez-vous de lui donner un vote positif!

Essayez-le ici.

Explication:

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 octets

.AmP_ssMcQ]dtU

Essayez-le en ligne! S'affichera Truesi le nombre est magnanime, Falsesinon. Prend le nombre sous forme de chaîne.

Explications

.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 , 104 102 102 98 96 103 octets

• Merci à @Wheat Wizard pour 2 octets: rendu icomplètement anonyme car il n'est appelé qu'une seule fois.
• Merci à @Hyperneutrino pour 4 octets: une façon plus intelligente d'obtenir les numéros du numéro principal au lieu de les découper
• @Hyperneutrino a sauvé encore 2 octets: x-1juste xpour le rarnge de vérification principal.
• Correction d'un échec pour le cas x=10, ajoutant ainsi 7 octets, grâce à @Dennis et @Wheat Wizard pour l'avoir repéré: ma version précédente considérait 1 comme un premier

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

Essayez-le en ligne!

Japt , 24 16 octets

C'était à peu près une collaboration entre @Shaggy, @ETHproduction et moi-même.

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

Essayez-le en ligne!

Prend l'entrée sous forme de chaîne.

Pip , 25 24 octets

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

Essayez-le en ligne!

Explication

a est le premier argument de ligne de commande. 1,#agénère une plage contenant des nombres à 1travers len(a)-1. Pour cela, nous mappons une fonction lambda:

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

Ensuite, nous mappons une autre fonction lambda, 0N_%,_=1 qui teste la primalité. Je l'ai pris de cette réponse ; vous pouvez y lire l'explication. Enfin, nous replions la liste sur AND logique ( $&). Le résultat est 1ssi toutes les sommes étaient importantes,0 si aucune ne l'était.

Exemple, avec entrée de 4063:

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

CJam , 22 octets

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

Essayez-le en ligne!

Imprime un entier positif pour la vérité, zéro pour la fausse.

-1 grâce à un astucieux tour de Peter Taylor .
-3 grâce à une autre astuce de Peter Taylor.

Japt , 23 octets

Prend l'entrée sous forme de chaîne.

Dang it; battu au poinçon sur une alternative beaucoup plus courte sur laquelle je travaillais.

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

Essaye-le

Mathematica, 75 octets

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

Functionqui attend a String. PrimeQ@ToExpression@StringInsert[#,"+",n]renvoie si l'insertion d'un +après le ne chiffre donne un nombre premier. Table[...,{n,2,StringLength@#}]donne la liste de ces valeurs sous forme de nplages allant 2de la longueur de la chaîne. Nous prenons ensuite Andchacun des éléments de cette liste. Idéalement, si StringLength@#<2, alorsTable[...] est la liste vide, pour laquelleAnd@@{}==True

Mathematica, 55 50 45 49 50 54 62 octets

Il semble que je devrais le poster séparément.

+6 octets pour la longueur de code remesurée.

+5 octets grâce à ngenisis.

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

Prend l'entrée comme un entier et retourne régulier Trueet False. L' entre-deux est unicode 0xF4A1, abréviation de Function[,]. La longueur du code est mesurée sur la taille du fichier (UTF-8 sans nomenclature), commentez s'il n'est pas correct.

PowerRange[x]renvoie 1, 10, 100 ... pas plus grand que x, qui est introduit dans Mathematica 10.

Plain English 4204 341 315 251 241 240 octets

(Re-) incorporé le test de primalité dans la bibliothèque de Plain English, en déplaçant 3 863 octets dans la bibliothèque de Plain English. Suppression de 26 octets d'espace blanc. 64 octets enregistrés en abrégeant les variables locales. 10 octets enregistrés en abrégeant l'interface. Selon la suggestion de RosLuP , sauvé 1 octet en changeant la façon dont m est initialisé et incrémenté.

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.

Version non golfée du code 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.

Remarques: L'IDE en anglais simple est disponible sur github.com/Folds/english . L'IDE s'exécute sur Windows. Il se compile en code x86 32 bits.

La fourche dynamique de l'anglais simple de l' Osmosian Order avait déjà des tests de primalité dans la version 4700, mais elle utilisait un algorithme très inefficace (de janvier à juin 2017). Les versions 4001 à 4011 de la fourche dynamique du site GitHub ont omis les tests de primalité. La version 4013 de la fourche dynamique du site GitHub inclut des tests de primalité. Le code pour effectuer le test de primalité a été développé dans le cadre des révisions précédentes de cette réponse.

Perl 6 , 58 octets

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

Essayez-le en ligne!

10, 10 * * ...^ * > $_est la séquence géométrique de multiples de dix, prise jusqu'à un avant l'élément qui dépasse le paramètre d'entrée $_. Ensuite, nous vérifions simplement que pour chaque puissance de dix, la somme du paramètre d'entrée pris div et mod cette puissance est première.

Haskell, 114 110 octets

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

Non golfé avec explication:

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

Axiome, 88 octets

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)

test et résultats

(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 octets

{~cĊℕᵐ+}ᶠṗᵐ

Essayez-le en ligne!

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

Perl 6 , 35 octets

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

Essayez-le en ligne!

Explication:

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

Empilé , 51 octets

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

Essayez-le en ligne!

Ceci est une fonction. Il fonctionne en convertissant son argument en une chaîne ( tostr), en le dupliquant et en obtenant sa longueur ( :#'), en soustrayant 1 ( 1-), en faisant une plage de 1 à ce nombre ( ~>). La pile ressemble à ceci, pour l'entrée 40427:

('40427' (1 2 3 4))

Nous effectuons une vectorisation splitat, ce qui fait que le tableau suivant se trouve en haut de la pile:

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

En transposant cela avec tr, on obtient:

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

Ensuite, nous mappons la fonction ['+',' '## ~ prime] (withmap`). Cette fonction:

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

Ensuite, après la carte, nous concaténons 1. Ceci est depuis allretourne undefpour une liste vide.

JavaScript (ES6), 70 octets

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)

Échoue sur le dernier cas dans mon navigateur en raison d'une erreur "trop ​​de récursivité" lors du calcul P(200023). Espérons que cela ne l'invalide pas.

QBIC , 38 octets

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

Explication

_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 octets)

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

Démo en ligne en ligne, suite de tests en ligne

Dissection

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 octets

.AmP_svcz]dtUz

Suite de tests

Enregistré un octet en utilisant la dernière modification de Pyth.

APL (NARS), caractères 35, octets 70

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

tester:

  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 

Ce serait la traduction en APL d'Axiom post algo ici ...

{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 octets

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;

s'imprime 1si l'entrée est magnanime, la sortie vide sinon. Exécuter en tant que pipe avec -nRou l' essayer en ligne .

Perl 5 -p , 42 octets

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

Essayez-le en ligne!