Escreva um programa que teste a primalidade de um número especificado e dê a saída como um valor booleano (True é primo). Seu teste principal pode (mas não precisa) ser válido para o número 1.

Aqui está o problema: seu próprio programa deve somar um número primo. Converta todos os caracteres (incluindo espaços) em seu valor Unicode / ASCII ( tabela ). Em seguida, adicione todos esses números para obter a soma do seu programa.

Por exemplo, considere este programa não tão bom que escrevi no Python 3.3:

q=None
y=int(input())
for x in range(2,int(y**0.5)+1):
    if y%x==0:
        q=False
if not q:
    q=True
print(q)

Se você converter todos os caracteres para o valor Unicode / ASCII correspondente, obterá:

113 61 78 111 110 101 10 121 61 105 110 116 40 105 110 112 117 116 40 41 41 10 102 111 114 32 120 32 105 110 32 114 97 110 103 101 40 50 44 105 110 116 40 121 42 42 48 46 53 41 43 49 41 58 10 32 32 32 32 105 102 32 121 37 120 61 61 48 58 10 32 32 32 32 32 32 32 32 113 61 70 97 108 115 101 10 105 102 32 110 111 116 32 113 58 10 32 32 32 32 113 61 84 114 117 101 10 112 114 105 110 116 40 113 41 

Você pode encontrar a soma desses números manualmente ou com seu próprio programa. Este programa específico é 8293, que é um número primo.

Obviamente, esse é o Code Golf; portanto, quanto menor você puder fazer seu programa, melhor. Como apontado por outros usuários, este programa não é muito divertido.

Algumas regras:

Entradas válidas incluem STDIN e prompts (sem funções, é apenas uma maneira de adicionar código extra gratuito). Os espaços são permitidos, mas somente se forem cruciais para a funcionalidade do seu programa. A saída deve ser uma saída, não apenas armazenada em uma variável ou retornada (use print, STDOUT etc.)

Os sinalizadores podem ser usados ​​e devem ser contados literalmente, não expandidos. Comentários não são permitidos. Quanto aos caracteres não ASCII, eles devem ser atribuídos ao valor em sua respectiva codificação.

Certifique-se de listar o tamanho do seu programa e a soma do programa. Vou testar para garantir que os programas sejam válidos.

Boa sorte!

Aqui está um trecho para contar a soma do seu programa e verificar se ele é primo:

function isPrime(number) { var start = 2; while (start <= Math.sqrt(number)) { if (number % start++ < 1) return false; } return number > 1; } var inp = document.getElementById('number'); var text = document.getElementById('input'); var out = document.getElementById('output'); function onInpChange() { var msg; var val = +inp.value; if (isNaN(val)) { msg = inp.value.toSource().slice(12, -2) + ' is not a valid number.'; } else if (isPrime(val)) { msg = val + ' is a prime number!'; } else { msg = val + ' is not a prime number.'; } out.innerText = msg; } function onTextChange() { var val = text.value; var total = new Array(val.length).fill().map(function(_, i) { return val.charCodeAt(i); }).reduce(function(a, b) { return a + b; }, 0); inp.value = '' + total; onInpChange(); } text.onkeydown = text.onkeyup = onTextChange; inp.onkeydown = inp.onkeyup = onInpChange;

body { background: #fffddb; } textarea, input, div { border: 5px solid white; -webkit-box-shadow: inset 0 0 8px  rgba(0,0,0,0.1), 0 0 16px rgba(0,0,0,0.1); -moz-box-shadow:  inset 0 0 8px  rgba(0,0,0,0.1), 0 0 16px rgba(0,0,0,0.1); box-shadow:  inset 0 0 8px  rgba(0,0,0,0.1), 0 0 16px rgba(0,0,0,0.1);  padding: 15px; background: rgba(255,255,255,0.5); margin: 0 0 10px 0; font-family: 'Roboto Mono', monospace; font-size: 0.9em; width: 75%; }</style><meta charset="utf-8"><style>/**/

<link href="https://fonts.googleapis.com/css?family=Roboto+Mono" rel="stylesheet"><textarea id="input" tabindex="0">Insert your (UTF-8 encoded) code here
Or directly input a number below</textarea><br><input id="number" value="6296" tabindex="1"><br><div id="output">6296 is not a prime number.</div>

Olá Mundo! , 13 bytes,1193

hello, world!

Ruby, soma 3373, 37 bytes

require'prime'
g=gets.to_i
p g.prime?

Microscript II, 2 bytes (soma 137)

N;

Microscript II, 4 bytes (soma 353)

N;ph

Estou realmente surpreso que esses dois acabem tendo somas de bytes principais.

Japt , 2 bytes,191

Uj

U :85

j : 106

Experimente online!

Pyth, 2 bytes, 127

/P

Experimente online

Saídas 1para números primos, 0para não primos.

/tem ponto de código 47. Ptem ponto de código 80.

Como funciona:

/P
/PQQ    Implicit variables.
        Q = input
 PQ     Prime factorize Q.
/  Q    Count how many times Q appears. 1 if prime, 0 if not.

Haskell, 52 bytes, 4421

main=do
 k<-readLn
 print$product[1..k-1]`rem`k==k-1

Teorema de Wilson.

Python 2, 50 bytes, 4201

Funciona para 1. A saída é positiva se for prime ou zero se não.

p=input();print all(p%m for m in range(2,p))*~-p;p

Experimente online

Python 2, 44 bytes, 3701

Não funciona para 1. Produz um booleano.

p=input();print all(p%k for k in range(2,p))

Experimente online

JavaScript (ES6), 47 bytes, 3541

Isso se baseia fortemente na função de teste de primalidade da ETHproductions , que pode ser encontrada aqui .

alert((F=(n,x=n)=>n%--x?F(n,x):!~-x)(prompt()))

05AB1E , 2 bytes,173

p=

Explicação:

p  # Checks if number is prime - returns 1 if true and 0 if false. Uses implicit input.
 = # Wouldn't usually be required for this sort of program, but I added it to make the sum prime.

Experimente online!

PHP, 38 bytes, soma 2791

Curiosidade: em $hvez de $c, a soma seria 2801(também um primo) e sua representação binária 101011110001lida como decimal também é um número primo.

for($b=$c=$argv[1];$c%--$b;);echo$b<2;

aceita argumento de linha de comando, imprime 1ou string vazia. Corra com -r.

Código retirado da minha própria função principal (veja a postagem original, se puder).

R, 27 32 bytes, soma 2243 2609

Guardado 5 bytes graças a @rturnbull

cat(gmp::isprime(scan(),r=43)>0)

Isso faz uso da função isprime da biblioteca gmp.

> sum(as.integer(charToRaw('cat(!!gmp::isprime(scan()))')))
[1] 2243
> cat(!!gmp::isprime(scan()))
1: 2243
2: 
Read 1 item
TRUE
> 

Python 2, 44 bytes, soma de bytes 3109

Esta é a implementação de 44 bytes do xnor com os nomes de variáveis ​​com menor valor que produzem uma soma de bytes principais.

Imprime 1se for prime e 0se não for.

C=B=1
exec"B*=C*C;C+=1;"*~-input()
print B%C

Geléia 6 bytes , soma de bytes 691

ƓÆḍ,ṠE

imprime 1se prime e 0se não estiver.

TryItOnline!

Os bytes em hexadecimal são 93 0D D5 2C CD 45(consulte a página de códigos ) ou em decimal são 147 13 213 44 205 69soma de 691, o que é primo.

Quão?

ƓÆḍ,ṠE - Main Link: no arguments
Ɠ      - read and evaluate a line from STDIN (integer expected)
 Æḍ    - proper divisor count
   ,   - paired with
    Ṡ  - sign
     E - all equal? - returns a boolean (1 or 0)
       - implicit print

A Æḍfuncionalidade é tal que primos e suas negações retornam um enquanto outros inteiros não retornam (compostos e suas negações retornam números maiores que um, um e menos um retornam retornos zero e zero, curiosamente, menos um).

A Ṡfuncionalidade é tal que números inteiros negativos retornam menos um, zero retorna zero e números positivos positivos retornam um.

Assim, as duas funções retornam apenas o mesmo valor para os números primos.

Observe que o programa de 3 bytes ƓÆPque testa diretamente se a entrada do STDIN é primária, infelizmente, não é um programa de soma primária (240).

Testar a igualdade usando =(iguais), e(existe em) ou ⁼(sem vetorização) para 5 bytes também não produz programas de soma primária.

4 bytes alternativos (talvez não aceitáveis), soma 571

Se as restrições de E / S ainda permitirem programas completos que levam um argumento.

Æḍ⁼Ṡ

... usando o mesmo princípio acima, onde ⁼existe igualdade não-vetorizadora (o aspecto não-vetorizável não tem efeito, pois não há nada a ser vetorizado). Os valores hexadecimais são 0D D5 8C CDo que são 13 213 140 205em decimal, que soma 571, um primo.

Observe novamente que o programa de 2 bytes ÆPnão possui uma soma primária (93).

CJam , 4 bytes, soma de bytes 439

qimp

Usa o teste de primalidade interno.

Experimente online!

Solução alternativa, 4 bytes, soma 461

r~mp

Mathematica, 21 bytes, 1997

Print@*PrimeQ@Input[]

Input[]lê uma linha de entrada (a partir do STDIN se nenhuma extremidade frontal é utilizado, através de uma caixa de diálogo, se a extremidade dianteira Mathematica é usada), Print@*PrimeQé a composição ( @*) do Printe PrimeQfunções, e @é notação função prefixo.

Perl 6 , 24 22 bytes,1949

say .is-prime
for +get

Todos os três caracteres de espaço em branco são obrigatórios.
No entanto, o Perl 6 não se importa com o tipo de caractere de espaço em branco, então escolhi uma nova linha em vez do espaço mais usado para o segundo ...)

Pyth, 4 bytes, 367

}QPQ

Experimente aqui!

Pip , 8 bytes,511

0Na%,a=1

Escrevi um cheque principal e a soma foi excelente. Conveniente. Verifique as entradas 1-30: Experimente online!

Explicação

          a is first command-line argument
    ,a    Numbers from 0 to a-1
  a%      Take a mod each of those numbers (a%0 gives nil)
0N        Count number of times 0 occurs in that list
      =1  If 0 occurs only 1 time (for a%1), then a is prime

Pari / GP , 23 bytes,2111

print(2>=numdiv(input))

Experimente online!

J, 18 bytes, 1103

echo 1&p:".(1!:1)1

Não muito longe do ideal, o mínimo que eu poderia realizar em um teste de primalidade de programa completo era 17 bytes:, o echo(p:[:".1!:1)1que infelizmente equivale a 1133 = 11 * 103.

Infelizmente, não consigo descobrir como fazer com que a entrada do teclado funcione no TIO, portanto ainda não há link.

Explicação:

echo 1&p:".(1!:1)1  | Full program
           (1!:1)1  | Read a line of input from keyboard
         ".         | Evaluate (converts string to int)
     1&p:           | 1 for prime, 0 for composite
echo                | Print result. The space is required, as 'echo1' would be interpreted as a variable

Validando o programa:

   1 p:+/u:inv'echo 1&p:".(1!:1)1'  NB. Convert to ints, sum, and test primality
1

C (gcc) , 62 60 bytes, 4583

Bem direto. Saídas * se prime, caso contrário, gera um espaço. Não funciona para 1.

-2 graças a l4m2

p;main(i){for(scanf("%d",&p);++i<p;)p=p%i?p:0;puts("*"+!p);}

Experimente online!

AWK , 36 bytes, soma de bytes 2239

{for(a=1;$0%++a&&a<$0;);$0=(a==$0)}1

Experimente online!

Saídas 0se não for prime e 1for prime. Definitivamente não é o código mais eficiente, pois verifica todos os números inteiros maiores do que 1para ver se ele divide a entrada.

Excel (57 bytes, soma do código 3547)

=XOR(0<PRODUCT(MOD(A1,ROW(OFFSET(D2,0,,SQRT(A1))))),3>A1)

O Excel realmente não possui uma "entrada" como tal, mas essa fórmula espera que o número a ser testado esteja em A1 e seja emitido para qualquer célula em que você o soltar. É uma fórmula de matriz, então pressione Ctrl-Shift-Enter para inserir , em vez de Enter.

Java 8, 114 bytes, Prime 10037

interface M{static void main(String[]a){long n=new Long(a[0]),x=2;for(;x<n;n=n%x++<1?0:n);System.out.print(n>1);}}

Experimente online.

Explicação:

interface M{                     // Class
  static void main(String[]a){   //  Mandatory main-method
    long n=new Long(a[0]),       //   The first argument as number
    x=2;for(;x<n;n=n%x++<1?0:n); //   Check if `n` is a prime
    System.out.print(n>1);}}     //   Print whether `n` was a prime
                                 //    (if `n` is still the same: it's a prime;
                                 //     if `n` is now 0 or 1: it's not a prime)

Eu usei em xvez de ifazer a soma unicode um primo. Verifique a soma unicode aqui.

Gelatina , 4 bytes, Σ = 239

ÆPa1

Experimente online!

Prova: Experimente online! (pegue os índices baseados em 1 dos caracteres do programa da página de código de Jelly, diminua para torná-los baseados em 0, some e verifique se o resultado é primo).

SmileBASIC, 42 bytes, 2687

INPUT N:FOR D=2TO N/2P=P+!(N MOD D)NEXT?!P

Emite 1 (verdadeiro) se o número for primo, caso contrário, 0 (falso).

Os nomes das variáveis ​​não foram escolhidos apenas para tornar o programa principal. Né o n úmero de teste, Dé o d iVisor, e Pcontrola se N é p rime.

Maravilha , 7 bytes,537

pr rl e

Provavelmente existe uma maneira melhor ...

Ferrugem, 190 bytes, 15013 score

fn main(){let A=&mut"".into();std::io::stdin().read_line(A);let(B,mut C)=(A.trim().parse::<u64>().unwrap(),true);for H in 2..((B as f64).sqrt()+1.0) as u64{if B%H==0{C=false}}print!("{}",C)}

Ungolfed

fn main() {
    let input = &mut "".into();
    std::io::stdin().read_line(input);
    let (number, mut prime) = (input.trim().parse::<u64>().unwrap(), true);

    for x in 2..((number as f64).sqrt() + 1.0) as u64 {
        if number % x == 0 {
            prime = false;
        }
    }

    print!("{}", prime);
}

Não funciona para 1

Stax , 349

|pq

Execute e depure

Sussurros v2 , 33 bytes

>>> ⊤ℙ∘ℕ
> Input
>> 1∘2

Experimente online!

1. Ponto: 44381
2. Apenas 6 bytes / 2 caracteres adicionados para torná-lo válido!
3. 1 não é primo

Como funciona

Isso é mostrado na ordem em que é executado:

		; Line 3:
>>  ∘		; Compose...
   1            ; Line 1 with
     2          ; The result of line 2

		; Line 2:
> Input		; Retrieve a line of input

		; Line 1:
>>> ⊤		; The input is...
     ℙ		; Prime
      ∘		; And it is...
       ℕ	; Natural