Schreiben Sie ein Programm oder eine Funktion in einer beliebigen Sprache, die angibt, ob die Eingabe eine Primzahl ist.

• Die Eingabe ist eine Zeichenfolge, die eine natürliche Zahl in der Basis 10 darstellt.
• Die Ausgabe ist eine der beiden Zeichenfolgen "Prime" oder "Not !!" die die Eingabe korrekt identifiziert.
• Arithmetische Operatoren, bitweise Operatoren, numerische Variablen und Konstanten, "math-stuff" im Allgemeinen usw. sind an keiner Stelle in Ihrem Programm zulässig. Sie sollten Zeichenfolgenoperationen verwenden , um alle erforderlichen "Berechnungen" durchzuführen .
• Sie können Stringlängen (Zahlen) vergleichen, aber -10 mit Ihrer Punktzahl, wenn Sie dies nicht tun.
• Ihr Programm sollte mit Eingaben beliebiger Länge (bei genügend Arbeitsspeicher und Zeit) arbeiten.
• Die niedrigste Bytezahl (UTF-8) gewinnt.

Ruby, 64 - 10 = 54

puts ('1
'..gets).map{?1}*''=~/^1?$|^(11+?)\1+$/?'Not!!': :Prime

Dies iteriert von der Zeichenfolge '1' (plus einer neuen Zeile) zur Eingabezeichenfolge, wobei Rubys integrierte Zeichenfolgeniterationsmethode verwendet wird, die einer Addition von 1 sehr ähnlich sieht, aber technisch zu keinem Zeitpunkt eine übergeordnete numerische Variable erstellt . Es verwendet die Tatsache, dass es n Iterationen für eine Eingabe von n gibt, um eine Zeichenfolge mit n Längen zu erstellen, und verwendet dann einen regulären Ausdruck, um zu bestimmen, ob diese Zeichenfolge in identische Teilzeichenfolgen gruppiert werden kann.

Rubin: 52 - 10 = 42

Verwenden Sie eine Variation dieses berühmten Prime Matching Regex.

puts ?_*gets.to_i=~/^(_|(__+?)\2+)$/?"Not!!":"Prime"

Nur um klar zu sein: ?_*gets.to_iist eine Zeichenfolgeoperation, die angehängt wird"_" die n- mal an sich selbst , wobei n die eingegebene Zahl ist. Aus meiner Sicht werden keine Stringlängen verglichen, so dass das 10 Zeichen Bonuskriterium erfüllt sein sollte.

Perl 52-10 = 42

Implementierung

print((('-'x$ARGV[0])=~/^.$|^(..+?)\1+$/)?Not:Prime)

Demo

$ seq 1 10|xargs -I{} bash -c "echo -n '{} '  && perl Prime.pl {} && echo"
1 Not
2 Prime
3 Prime
4 Not
5 Prime
6 Not
7 Prime
8 Not
9 Not
10 Not

ECMAScript 6, 159-10 = 149

Klingt nach einer Aufgabe für Regex. I / O mit prompt/ alertwie gewohnt.

for(s=prompt(u=""); /[^0]/.test(s); )
  s=s.replace(/(.)(0*)$/,(_,d,t)=>u+="x"," 012345678"[d]+t.replace(/0/g,"9"))
alert(/^((xx+)\2+|x?)$/.test(u)?"Not!!":"Prime")

Die while-Schleife dekrementiert die Dezimalzahl bei jeder Iteration nur durch Regex. Der endgültige reguläre Ausdruck entspricht einer Zeichenfolge, die aus einer zusammengesetzten Anzahl von x besteht, indem zuerst ein Faktor und dann ein weiterer Faktor für den Rest der Zeichenfolge abgeglichen wird.

Javascript 266

function N(a){function b(a){return P.every(function(b){if(n=b,i=a.length,j=b.length,j>i) return;if(j==i) return 1;while(n.length<i)n+=b;return n.length!=i})}if(q=A,A!=a)for(;q.length.toString()!=a;)b(q)&&P.push(q),q+=A;console.log(b(q)?"Prime":"Not!!")}A="0",P=[A+A]

Erstellt eine Funktion mit dem Namen N, die das gewünschte Ergebnis ausgibt. Die ungekürzte Version sieht so aus. Ich habe eine Handminimierung durchgeführt, um einige Variablen zu bereinigen, und dann habe ich diese durch uglify ausgeführt und dann die Handminimierung erneut durchgeführt.

// A a string of "0" for using to generate long strings
// P is the store for all known primes
A="0", P=[A+A];
function N(val) {
  function _isPrime(str) {
    // go through all the known primes and return true
    // if we don't match on any of them
    return P.every(function(prime) {
      // prime is some known string whose length is a prime number
      tsr = prime, strlen = str.length, primelen = prime.length;
      // if the string we're checking has fewer chars than
      // this then it's not a prime
      if(strlen < primelen) return 0;
      // if the string we're checking has the same number of chars
      // as the the prime we're checking against then it is a prime
      if(primelen == strlen) return 1;
      // Keep incrementing our temporary string with the prime we're
      // checking. we'll break out of the loop once the temporary string
      // is greater than or equal to the string we're testing
      while(tsr.length < strlen) {
        tsr += prime;
      }
      return !(tsr.length == strlen)
    });
  }
  // start with a string of one unit
  nstr = A
  if(A!=val) {
    // keep incrementing the string so that we can compile a list
    // of known primes smaller than this value
    while(nstr.length.toString() !== val) {
      if(_isPrime(nstr)) {
        P.push(nstr);
      }
      nstr += A;
    }
  }
  console.log(_isPrime(nstr) ? "Prime" : "Not!!");
}

Getestet mit diesem Snippet:

for(var X=0;X<10;X++) {
  console.log('checking: ' + X);
  N(X.toString());
}

Bash 66 - 10 = 56

Implementierung

[[ -z `printf %$1s|grep -P "^(..+?)\1+$"` ]]&&echo Prime||echo Not

Demo

$ seq 1 10|xargs -I{} bash -c "echo -n '{} '  && ./Prime.sh {}"
1 Prime
2 Prime
3 Prime
4 Not
5 Prime
6 Not
7 Prime
8 Not
9 Not
10 Not

Python 3, 109-10 = 89

print(['Not','Prime'][(lambda i:not any(' '*i==(' '*u)*v for u in range(i)for v in range(i)))(int(input()])

Nicht die Länge von Strings vergleichen, sondern die Einbeziehung von Strings. Cross posted from duplicate Bestimmen Sie, ob eine Zahl eine Primzahl ist, ohne Arithmetik zu verwenden