Napisz program lub funkcję w dowolnym języku, który mówi, czy wejście jest liczbą pierwszą.

• Dane wejściowe to ciąg reprezentujący liczbę naturalną w bazie-10.
• Wyjściem jest jeden z dwóch ciągów „Prime” lub „Not !!” który poprawnie identyfikuje dane wejściowe.
• Operatory arytmetyczne, operatory bitowe, zmienne i stałe numeryczne, ogólnie „matematyka” itp. Są niedozwolone w twoim programie. Powinieneś użyć operacji na łańcuchach, aby wykonać wszystkie niezbędne „obliczenia”.
• Możesz porównać długości łańcuchów (które są liczbami) - ale -10 do swojego wyniku, jeśli tego nie zrobisz.
• Twój program powinien działać na dowolnym wejściu długościowym (biorąc pod uwagę wystarczającą ilość pamięci i czasu).
• Wygrywa najniższa liczba bajtów (UTF-8).

Rubin, 64-10 = 54

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

Powoduje to iterację od ciągu „1” (plus nowy wiersz) do ciągu wejściowego, przy użyciu wbudowanej w Ruby metody iteracji ciągu, która wygląda okropnie podobnie jak dodanie 1, ale która nie tworzy technicznie zmiennej numerycznej wysokiego poziomu w dowolnym momencie . Wykorzystuje fakt, że będą istnieć n iteracje dla wejścia n, aby utworzyć ciąg o długości n, a następnie używa wyrażenia regularnego, aby ustalić, czy ten ciąg może być zgrupowany w identyczne podłańcuchy.

Rubin: 52-10 = 42

Używając odmiany tego słynnego wyrażenia regularnego dopasowującego liczby pierwsze.

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

Żeby było jasne: ?_*gets.to_ito operacja łańcuchowa, która dołącza się "_"do siebie n razy, gdzie n jest liczbą wejściową. Widzę, że długości łańcuchów nie są porównywane, więc powinno spełniać kryterium premii 10 znaków.

Perl 52-10 = 42

Realizacja

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

Próbny

$ 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

Brzmi jak zadanie dla wyrażenia regularnego. I / O z prompt/ alertjak zwykle.

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

Pętla while zmniejsza liczbę dziesiętną o jeden w każdej iteracji wyłącznie za pomocą wyrażenia regularnego. Ostateczne wyrażenie regularne dopasowuje ciąg składający się ze złożonej liczby x, najpierw dopasowując jeden czynnik, a następnie drugi, powtarzając pierwszy czynnik jeden dla reszty łańcucha.

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]

Tworzy funkcję o nazwie N, która wydrukuje pożądany wynik. Wersja nieuprawniona wygląda następująco. Zrobiłem ręczną minify, aby wyczyścić niektóre zmienne, a następnie przejrzałem to przez uglify, a następnie ręcznie zminimalizowałem to ponownie.

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

Przetestowałem to za pomocą tego fragmentu:

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

Bash 66-10 = 56

Realizacja

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

Próbny

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

Nie porównuje długości ciągów, ale włączanie ciągów. Krzyż wysłany z duplikatu Ustal, czy liczba jest liczbą pierwszą bez użycia arytmetyki