Escriba un programa o función en cualquier idioma que indique si la entrada es un número primo.

• La entrada es una cadena que representa un número natural en base-10.
• La salida es una de las dos cadenas "Prime" o "Not !!" que identifica correctamente la entrada.
• No se permiten operadores aritméticos, operadores de bits, variables numéricas y constantes, "cosas matemáticas" en general, etc. en ningún lugar de su programa. Debe usar operaciones de cadena para hacer todos los "cálculos" necesarios.
• Puede comparar longitudes de cadena (que son números), pero -10 a su puntaje si no lo hace.
• Su programa debería funcionar en cualquier entrada de longitud (con suficiente memoria y tiempo).
• El conteo de bytes más bajo (UTF-8) gana.

Rubí, 64-10 = 54

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

Esto itera desde la cadena '1' (más una nueva línea) a la cadena de entrada, utilizando el método de iteración de cadena incorporado de Ruby que se parece mucho a sumar 1, pero que técnicamente no crea una variable numérica de alto nivel en ningún punto . Utiliza el hecho de que habrá n iteraciones para una entrada de n para crear una cadena de longitud n, luego usa una expresión regular para determinar si esa cadena se puede agrupar en subcadenas idénticas.

Rubí: 52-10 = 42

Usando una variación de esa famosa expresión regular de coincidencia de primos.

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

Para ser claros: ?_*gets.to_ies una operación de cadena que se agrega "_"a sí misma n veces, donde n es el número de entrada. Como lo veo, no se comparan las longitudes de cadena, por lo que debería satisfacer el criterio de bonificación de 10 caracteres.

Perl 52-10 = 42

Implementación

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

Manifestación

$ 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

Suena como una tarea para expresiones regulares. E / S con prompt/ alertcomo siempre.

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

El ciclo while disminuye el número decimal en uno cada iteración únicamente por expresiones regulares. La expresión regular final coincide con una cadena que consiste en un número compuesto de x, primero haciendo coincidir un factor, luego otro repitiendo el primer factor uno para el resto de la cadena.

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]

Crea una función llamada N que imprimirá el resultado deseado. La versión no minificada se ve así. Hice un minify manual para limpiar algunas variables y luego lo ejecuté a través de uglify y luego lo minificó a mano nuevamente.

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

Probado con este fragmento:

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

Golpe 66-10 = 56

Implementación

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

Manifestación

$ 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

Pitón 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()])

No se comparan longitudes de cadena, sino inclusión de cadena. Cruzado publicado desde duplicado Determine si un número es primo sin usar aritmética