Bei einer positiven Ganzzahl als Eingabe bestimmen Sie, ob es sich um eine großmütige Zahl handelt.

Eine großmütige Zahl ist eine Zahl, bei der jede Einfügung eines +Zeichens zwischen zwei Ziffern in der Basis 10 zum Ausdruck einer Primzahl führt.

Zum Beispiel ist 40427 großmütig, weil

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

Ausgabe

Sie sollten zwei unterschiedliche Werte ausgeben, einen, wenn die Eingabe großartig ist, und einen, wenn die Eingabe nicht großartig ist.

Wertung

Das Ziel dieses Wettbewerbs ist es, die Größe des zur Lösung dieser Aufgabe geschriebenen Quellcodes in Byte so klein wie möglich zu halten.

Testfälle

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

Code

η¨¹.s¨R+pP

Verwendet die 05AB1E- Codierung. Probieren Sie es online! oder Überprüfen Sie alle Testfälle!

Erläuterung

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

Alle Optimierungen deaktiviert und nur auf 32-Bit-GCC.

-1 Byte dank @ceilingcat

+ einige Bytes für den 1Fall.

+ einige Bytes für wiederverwendbare Funktionen.

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

Übernimmt die Eingabe als Ganzzahl. Geben Sie 1 für falsche Fälle und 0 für wahre Fälle zurück.

Probieren Sie es online!

Siehe meine andere Antwort für Mathematica-Code (55 Bytes).

Retina , 38 Bytes

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

Probieren Sie es online!

Druckt 1für großmütige Zahlen und 0sonst.

Erläuterung

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

Wir beginnen damit, jede Position zwischen zwei Ziffern (Positionen, die keine Wortgrenzen sind) abzugleichen und das Präfix und das Suffix dieser Übereinstimmung in unary einzufügen, wobei _als unary-Ziffer verwendet wird. Anstatt also +s einzufügen, fügen wir dort direkt das unäre Ergebnis der Summe ein.

S`\d

Jetzt teilen wir die Zeichenfolge um Ziffern auf, sodass jede Summe in einer eigenen Zeile steht und wir diese Ziffern entfernen (es wird auch eine leere führende und nachfolgende Zeile geben, aber das ist nicht wichtig).

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

Dies ist der Standard-reguläre Ausdruck, um Nicht-Primzahlen in Unary abzugleichen. Wenn Sie hier eine GWiederholungsstufe verwenden, behalten Sie einfach alle Zeilen bei, die positive Nicht-Primzahlen enthalten (verwerfen Sie die leeren Zeilen).

^$

Zuletzt prüfen wir, ob der String leer ist. Wenn die Eingabe großmütig war, hat die vorherige Stufe alle Zeilen verworfen (weil sie alle Primzahlen waren), und dies gibt uns 1. Wenn eine Zeile keine Primzahl war, bleibt sie in der Zeichenfolge und der reguläre Ausdruck schlägt fehl 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))

Dies ist langsam und kann nur die Testfälle mit Memoisierung bewältigen.

Probieren Sie es online!

Alternative Version, 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))

Beschleunigt auf Kosten eines Bytes.

Probieren Sie es online!

Gelee , 12 Bytes

DJ⁵*⁸dṖS€ÆPẠ

Probieren Sie es online!

Überprüfen Sie alle Testfälle.

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 Dank an @PeterTaylor, indem Sie eine Arithmetik (anstelle von String with .substring) verwenden und die separate Methode loswerden, um zu überprüfen, ob die Ganzzahl eine Primzahl ist.
-6 Bytes mit @SaraJs Prime-Checking-Methode , also stelle sicher, dass du sie positiv bewertest!

Probieren Sie es hier aus.

Erläuterung:

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

Probieren Sie es online! Wird angezeigt, Truewenn die Zahl großmütig ist, Falseansonsten. Nimmt die Nummer als String.

Erklärungen

.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 98 96 103 Bytes

• Danke an @Wheat Wizard für 2 Bytes: iVollständig anonymisiert, da es nur einmal aufgerufen wird.
• Dank an @Hyperneutrino für 4 Bytes: Intelligentere Methode, um die Zahlen von der Hauptzahl zu erhalten, anstatt sie aufzuteilen
• @Hyperneutrino sparte weitere 2 Bytes: x-1um nur xdie Prime Checking-Grenze zu überschreiten.
• Ein Fehler für case x=10wurde behoben, wodurch dank @Dennis und @Wheat Wizard für das Erkennen 7 Bytes hinzugefügt wurden: Meine frühere Version betrachtete 1 als Primzahl

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

Probieren Sie es online!

Japt , 24 16 Bytes

Dies war so ziemlich eine Zusammenarbeit zwischen @Shaggy, @ETHproduction und mir.

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

Probieren Sie es online!

Übernimmt die Eingabe als Zeichenfolge.

Pip , 25 24 Bytes

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

Probieren Sie es online!

Erläuterung

aist das erste Befehlszeilenargument. 1,#aErzeugt einen Bereich mit Zahlen 1bis len(a)-1. Dazu bilden wir eine Lambda-Funktion ab:

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

Als nächstes bilden wir eine andere Lambda-Funktion ab 0N_%,_=1, die auf Primalität prüft. Ich habe es dieser Antwort entnommen ; Sie können die Erklärung dort lesen. Zum Schluss falten wir die Liste auf logisches AND ( $&). Das Ergebnis ist1 wenn alle Beträge erstklassig waren, 0wenn keiner von ihnen es war.

Beispiel mit Eingabe von 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!},!

Probieren Sie es online!

Gibt eine positive Ganzzahl für Wahrheit und eine Null für Falschheit aus.

-1 dank eines cleveren Tricks von Peter Taylor .
-3 danke an einen anderen tipp von peter taylor.

Japt , 23 Bytes

Übernimmt die Eingabe als Zeichenfolge.

Dang es; auf eine viel kürzere Alternative geschlagen, an der ich gearbeitet habe.

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

Probier es aus

Mathematica, 75 Bytes

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

Functiondas erwartet a String. PrimeQ@ToExpression@StringInsert[#,"+",n]Gibt zurück, ob das Einfügen eines +nach der nvierten Ziffer eine Primzahl ergibt. Table[...,{n,2,StringLength@#}]Gibt die Liste dieser Werte in nBereichen von 2bis zur Länge der Zeichenfolge an. Wir nehmen dann Andjedes der Elemente dieser Liste. Wenn ja, StringLength@#<2dann Table[...]ist die leere Liste, für dieAnd@@{}==True

Mathematica, 55 50 45 49 50 54 62 Bytes

Es scheint, ich sollte es separat posten.

+6 Bytes für neu gemessene Codelänge.

+5 Bytes dank Genisis.

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

Übernimmt die Eingabe als Ganzzahl und gibt reguläres Trueund zurück False. Das Dazwischen ist Unicode 0xF4A1, kurz für Function[,]. Die Codelänge wird anhand der Dateigröße (UTF-8 ohne Stückliste) gemessen. Kommentieren Sie, wenn dies nicht korrekt ist.

PowerRange[x]gibt 1, 10, 100 ... nicht größer als zurück x, was in Mathematica 10 eingeführt wird.

Englisch 4,204 341 315 251 241 240 Bytes

(Neu-) Aufnahme von Primalitätstests in die Bibliothek von Plain English, indem 3.863 Bytes in die Bibliothek von Plain English verschoben werden. 26 Byte Leerraum gelöscht. 64 Byte durch Abkürzung lokaler Variablen eingespart. Durch Abkürzung der Schnittstelle 10 Byte eingespart. Nach dem Vorschlag von RosLuP wurde 1 Byte gespart, indem geändert wurde , wie m initialisiert und inkrementiert wird.

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.

Ungolfed-Version des endgültigen Codes:

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.

Anmerkungen: Die Plain English IDE ist unter github.com/Folds/english verfügbar . Die IDE läuft unter Windows. Es wird in 32-Bit-x86-Code kompiliert.

Die dynamische Gabelung des Osmosianischen Ordens für einfaches Englisch wurde bereits in Version 4700 auf Primalität getestet, verwendete jedoch einen sehr ineffizienten Algorithmus (Stand Januar bis Juni 2017). In den Versionen 4001-4011 der dynamischen Verzweigung der GitHub-Site wurden keine Primalitätstests durchgeführt. Version 4013 der dynamischen Verzweigung der GitHub-Site enthält Primalitätstests. Der Code zum Durchführen des Primalitätstests wurde im Rahmen früherer Überarbeitungen dieser Antwort entwickelt.

Perl 6 , 58 Bytes

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

Probieren Sie es online!

10, 10 * * ...^ * > $_ist die geometrische Folge von Vielfachen von zehn, bis eins vor dem Element, das den Eingabeparameter überschreitet $_. Dann überprüfen wir einfach, dass für jede Zehnerpotenz die Summe der Eingangsparameter div und mod, die diese Potenz hat, die Primzahl ist.

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

Ungolfed mit Erklärung:

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

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

Test und Ergebnisse

(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Ċℕᵐ+}ᶠṗᵐ

Probieren Sie es online!

{      }ᶠ      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}

Probieren Sie es online!

Erläuterung:

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

Gestapelt , 51 Bytes

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

Probieren Sie es online!

Dies ist eine Funktion. Es konvertiert sein Argument in einen String ( tostr), dupliziert es und erhält seine Länge ( :#'), subtrahiert 1 ( 1-) und erstellt einen Bereich von 1 bis zu dieser Zahl ( ~>). Der Stack sieht für die Eingabe ungefähr so ​​aus 40427:

('40427' (1 2 3 4))

Wir führen eine Vektorisierung durch splitat, was dazu führt, dass das folgende Array ganz oben auf dem Stapel steht:

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

Wenn trwir dies umsetzen , erhalten wir:

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

Dann ordnen wir die Funktion ['+',' '## ~ prime] (withmap`) zu. Diese Funktion macht:

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

Dann verketten wir nach der Karte 1. Dies ist seit allRückkehr undeffür eine leere Liste.

JavaScript (ES6), 70 Byte

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)

Schlägt im letzten Fall in meinem Browser aufgrund eines Fehlers "zu viel Rekursion" während der Berechnung fehl P(200023). Ich hoffe, das macht es nicht ungültig.

QBIC , 38 Bytes

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

Erläuterung

_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!},!

Online-Demo , Online-Testsuite

Präparation

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 bis 14 Bytes

.AmP_svcz]dtUz

Testsuite

Mit Pyths neuester Änderung ein Byte gespeichert.

APL (NARS), Zeichen 35, Bytes 70

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

Prüfung:

  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 

Dies wäre die Übersetzung in APL von Axiom post algo hier ...

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

druckt, 1wenn die Eingabe großmütig ist, leere Ausgabe, wenn nicht. Laufen Sie als Pipe mit -nRoder versuchen Sie es online .

Perl 5 -p , 42 Bytes

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

Probieren Sie es online!