Écrivez un programme ou une fonction dans n'importe quelle langue qui indique si l'entrée est un nombre premier.

• L'entrée est une chaîne représentant un nombre naturel en base-10.
• La sortie est l'une des deux chaînes "Prime" ou "Not !!" qui identifie correctement l'entrée.
• Les opérateurs arithmétiques, les opérateurs bit à bit, les variables et constantes numériques, les "math-stuff" en général, etc ... ne sont autorisés nulle part dans votre programme. Vous devez utiliser des opérations de chaîne pour effectuer tous les "calculs" nécessaires.
• Vous pouvez comparer les longueurs de chaîne (qui sont des nombres) - mais -10 à votre score si vous ne le faites pas.
• Votre programme devrait fonctionner sur n'importe quelle entrée de longueur (avec suffisamment de mémoire et de temps).
• Le nombre d'octets le plus bas (UTF-8) l'emporte.

Rubis, 64-10 = 54

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

Cela itère de la chaîne '1' (plus une nouvelle ligne) à la chaîne d'entrée, en utilisant la méthode d'itération de chaîne intégrée de Ruby qui ressemble énormément à l'ajout de 1, mais qui ne crée techniquement aucune variable numérique de haut niveau à aucun moment . Il utilise le fait qu'il y aura n itérations pour une entrée de n pour créer une chaîne de longueur n, puis utilise une expression régulière pour déterminer si cette chaîne peut être regroupée en sous-chaînes identiques.

Rubis: 52-10 = 42

En utilisant une variation de cette fameuse expression rationnelle d'appariement premier.

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

Juste pour être clair: ?_*gets.to_iest une opération de chaîne qui s'ajoute "_"à elle-même n fois, où n est le numéro d'entrée. Comme je le vois, aucune longueur de chaîne n'est comparée, ce qui devrait satisfaire au critère de bonus de 10 caractères.

Perl 52-10 = 42

la mise en oeuvre

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

Démo

$ 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

Sonne comme une tâche pour regex. E / S avec prompt/ alertcomme d'habitude.

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

La boucle while décrémente le nombre décimal d'une unité à chaque itération uniquement par l'expression régulière. Le regex final correspond à une chaîne composée d'un nombre composé de x, en faisant d'abord correspondre un facteur, puis un autre en répétant le premier facteur un pour le reste de la chaîne.

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]

Crée une fonction appelée N qui imprimera le résultat souhaité. La version non réduite ressemble à ceci. J'ai fait une minification de la main pour nettoyer certaines variables, puis j'ai exécuté cela à travers uglify, puis à nouveau minifié à la main.

// 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!!");
}

Testé à l'aide de cet extrait:

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

Bash 66 - 10 = 56

la mise en oeuvre

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

Démo

$ 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()])

Pas de comparaison de longueurs de chaîne, mais d'inclusion de chaîne. Croix postée à partir d'un doublon Déterminer si un nombre est premier sans utiliser d'arithmétique