Um teste de primeira linha que é literalmente primo


23

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:


12
Em idiomas que não praticam golfe, parece que você pode pegar o código mais curto de decisão principal e ajustar os nomes das variáveis ​​até que a soma seja prime.
Xnor

5
Por que as restrições de E / S?
Jonathan Allan

2
O que é um "valor Unibyte"?! ???
Aditsu

5
Você fala sobre caracteres e páginas de código. Um caractere Unicode sempre tem o mesmo ponto de código, independentemente da codificação usada para representá-lo. Quanto aos caracteres não ASCII, eles devem ser atribuídos ao valor em sua respectiva codificação. me faz pensar que você realmente quer que a soma dos valores de bytes seja primária
Dennis

Respostas:



7

Ruby, soma 3373, 37 bytes

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

6

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.



4

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.

4

Haskell, 52 bytes, 4421

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

Teorema de Wilson.


2
Transformado em um programa independente completo.
Fquarp 01/04

O ::IO Intrealmente não deve ser necessário a menos que esse é o caminho mais curto você pode obter uma soma prime.
Ørjan Johansen

Boa decisão. No entanto, obtemos algum código que `hashes 'para um valor par. Adicionar espaços ou novas linhas não faz nada (valores pares), nem altera o nome da variável (ela aparece quatro vezes, portanto, substituir o código (digamos c) equivale a subtrair 4 * ce adicionar 4 * c ', deixando o . soma ainda entanto, ele pode ser mexido por quebrar as linhas e ainda ser mais curto, o que fiz.
fquarp

1
47 bytes com um teste de primalidade diferente: Experimente online! (observe que existem guias em vez de espaços para acertar a contagem).
Laikoni

Bem-vindo ao PPCG!
Laikoni

4

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


3

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


3

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!


Algo que algo "comentários não são permitidos", mas acho que as no-ops eficazes funcionam bem: D
Value Ink

2

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


@Artyer É fixo.
Titus

2

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
> 

cat(!!gmp::isprime(scan()))é 5 bytes mais curto e soma 2243também, principal.
precisa saber é o seguinte

@rturnbull obrigado por isso :)
MickyT


1

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


ƓÆPG(311) e ÆPF(163) deve estar bem, eu acho?
Lynn

Como Unicode, para ƓÆḍ,ṠE, o valor 16183é coincidentemente primo!
Artyer

@ Lynn Sim, parece que a "restrição desnecessária de código" (exceto o caractere de espaço) foi levantada, tornando ƓÆPGOK. Também perguntei se um programa que receba informações e não o uso de STDIN é aceitável.
Jonathan Allan

1
... Se ambas as coisas estão OK, então ÆP¥é de 3 bytes e 97.
Jonathan Allan


1

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.


1

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



1

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


1

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

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!


1
n;main(i){for(scanf("%d",&n);++i<n;)n=n%i?n:0;puts("*"+!n);}pode precisar de mudar algum nome variável para sum nobre
l4m2

@ l4m2 Nice!
Gastropner

1

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.


1

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.


1

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.



0

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.



0

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



0

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
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.