Escreva um programa ou função em qualquer idioma que diga se a entrada é um número primo.

• A entrada é uma sequência que representa um número natural na base 10.
• A saída é uma das duas strings "Prime" ou "Not !!" que identifica corretamente a entrada.
• Operadores aritméticos, operadores bit a bit, variáveis ​​e constantes numéricas, "coisas matemáticas" em geral, etc ... não são permitidos em nenhum lugar do seu programa. Você deve usar operações de string para fazer todos os "cálculos" necessários.
• Você pode comparar comprimentos de string (que são números) - mas -10 à sua pontuação, se não o fizer.
• Seu programa deve funcionar com qualquer entrada de comprimento (com tempo e memória suficientes).
• A menor contagem de bytes (UTF-8) vence.

Ruby, 64 - 10 = 54

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

Isso itera da string '1' (mais uma nova linha) para a string de entrada, usando o método de iteração de string incorporado do Ruby, que se parece muito com a adição de 1, mas que tecnicamente não cria uma variável numérica de alto nível a qualquer momento . Ele usa o fato de que haverá n iterações para uma entrada de n para criar uma cadeia de comprimento n e, em seguida, usa uma expressão regular para determinar se essa cadeia pode ser agrupada em substrings idênticos.

Ruby: 52 - 10 = 42

Usando uma variação desse famoso regex de correspondência principal.

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

Só para ficar claro: ?_*gets.to_ié uma operação de cadeia que anexa "_"a si mesma n vezes, onde n é o número de entrada. A meu ver, não são comparados comprimentos de cadeia, o que deve satisfazer o critério de bônus de 10 caracteres.

Perl 52-10 = 42

Implementação

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

Soa como uma tarefa para regex. E / S com prompt/ alertcomo de costume.

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

O loop while diminui o número decimal em um a cada iteração puramente por regex. O regex final corresponde a uma sequência que consiste em um número composto de x, correspondendo primeiro um fator e, em seguida, outro, repetindo o primeiro fator um para o restante da sequência.

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]

Cria uma função chamada N que imprime o resultado desejado. A versão não compactada fica assim. Eu fiz um hand minify para limpar algumas variáveis ​​e, em seguida, executei o uglify e depois o hand minify novamente.

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

Testei usando este trecho:

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

Festança 66 - 10 = 56

Implementação

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

Não comparando comprimentos de string, mas inclusão de string. Postagem cruzada de duplicado Determine se um número é primo sem usar aritmética