Herausforderung:

Sie erhalten eine Zeichenfolge, die nur Ziffern enthält. Ihre Aufgabe ist es, die minimale Anzahl von Primzahlen auszugeben, die verkettet werden müssen, um die Zeichenfolge zu bilden. Ist dies nicht möglich, wird ausgegeben 0.

Testfälle:

Eingabe -> Ausgabe:

252 -> 3
235 -> 2
92 -> 0
31149 -> 2

JavaScript (ES6), 123 121 120 Byte

f=(s,v)=>(p=n=>--n-1?s%n&&p(n):1)(s)||[...s].map((_,i)=>!(n=i&&(a=f(s.slice(0,i)))&&(b=f(s.slice(i)))&&a+b)|n>v?0:v=n)|v

Dank @Neil ein Byte gespeichert!

Erläuterung

Nimmt eine einzelne Zeichenfolge als Eingabe. Aufgrund der Prime-Checking-Methode (rekursive Trial-Division) kann die größte Zahl sicher überprüft werden 13840. Einige Zahlen darüber schlagen fehl, weil die maximale Call-Stack-Größe überschritten wird. Es endet jedoch sofort für jeden Fall, den es behandeln kann.

f=(s,v)=>
  (p=n=>--n-1?s%n&&p(n):1)(s) // if s is prime, return 1
  ||[...s].map((_,i)=>        // else for each index in s, split s into 2
    !(n=i&&                   // v = return value (initialised to undefined)
      (a=f(s.slice(0,i)))&&
      (b=f(s.slice(i)))&&
      a+b
    )|n>v?0:v=n               // if i, a, b and n are all > 0 and !(n > v), v = n
  )|v                         // cast v to an integer and return it

// Test
var testCases = [ "252", "235", "92", "3149", "24747" ];
document.write("<pre>" + testCases.map(c => c + ": " + f(c)).join("\n"));

MATL , 26 24 Bytes

0in:"GUtZq@Z^V10ZA=a?x@.

Bei einigen Testfällen dauert es einige Sekunden.

Probieren Sie es online!

Erläuterung

0       % Push 0
in:     % Take input. Generate array [1,2,...,N] where N is input length
"       % For each. In each iteration the number of used primes is increased
  GU    %   Push input. Convert to number
  tZq   %   Duplicate. Array of primes smaller than the input
  @     %   Push number of primes to bes tested in this iteration
  Z^    %   Cartesian power
  V     %   Convert to 2D array. Each row is a combination of primes
  10ZA  %   Convert each row to base 10, disregarding spaces
  =a    %   Do any of the results equal the input number? 
  ?     %   If so
    x   %     Remove the 0 that's at the bottom of the stack
    .   %     Break for each loop
        %   Implicitly end if
        % Implicitly end for each
        % Implicitly display

Pyth, 16 Bytes

lhaf!f!P_sYT./zY

Testsuite

Erklärung folgt.

Pyth - 19 17 16 Bytes

lhf.AmP_sdTa./zY

Test Suite .

Bash + Coreutils, 169 158 149 Bytes

c()
{
test $1||echo a
for i in `seq ${#1}`
do factor ${1::$i}|grep -q ': \w*$'&&printf b%s\\n `c ${1:$i}`
done
}
c $1|sort|sed '/a/!d;s/..//;q'|wc -c

Wir zählen in unary und geben eine Zeile mit einer bfür jede Primzahl und einer Endung aam Ende der Zeile aus (so dass printfes einen Token gibt, mit dem wir arbeiten können).

Der Primalitätstest factor $n | grep -q ': \w*$'bestimmt, ob die Zahl genau einen Primfaktor hat.

Wir partitionieren die Eingabe rekursiv. Wenn die linke Hälfte eine Primzahl ist, filtern wir die Ergebnisse der rechten Hälfte, indem wir zu jedem Wert eine hinzufügen. Wenn Sie afür eine Eingabe der Länge Null zurückgeben, wird die Rekursion beendet.

Schließlich nehmen wir alle Ergebnisse und sortieren, um die kürzesten zu finden (ignorieren alle, die keinen aErfolg anzeigen können); Wir müssen zwei (für die eingefügte aund für die neue Zeile) löschen und dann die Zeichen zählen, um das Ergebnis zu erhalten.

Tests

$ for i in 252 235 92 31149 111; do echo "$i:"$'\t'"$(./77623.sh $i)"; done
252:    3
235:    2
92:     0
31149:  2
111:    0

Ich 111habe den Tests hinzugefügt, um zu zeigen, dass dies 1korrekterweise als Nicht-Primzahl gilt.

Mathematica, 142 135 Bytes

Min[Length/@Select[Join@@@Permutations/@IntegerPartitions@Length[a=#],And@@PrimeQ@*FromDigits/@a~Internal`PartitionRagged~#&]]/.∞->0&

Wie Sie sehen, wurde Mathematica nicht für diese Aufgabe entwickelt. Nimmt eine Liste von Ziffern.