Transposto, primos, oh meu!

15

A tarefa é simples: seu programa lê um número inteiro como uma entrada e imprime se é um primo ou não. Você pode imprimir "sim / não", "verdadeiro / falso" ou qualquer outra coisa que identifique o resultado sem ambiguidade.

O desafio é que o código precisa trabalhar com suas linhas e colunas transpostas.

Para excluir a solução óbvia (a solução "simples" mais curta repetida verticalmente por caractere com o uso de comentários), a métrica é um pouco diferente do código-golfe usual:

Como a formatação é muito importante nesse desafio , o tamanho do código é medido na área do menor retângulo no qual o código se encaixa. Em outras palavras, o espaço em branco conta e as linhas devem ser preenchidas com o mesmo comprimento (você não precisa fazê-lo quando você publica a solução, por uma questão de simplicidade). Por exemplo

int main()   
{            
    return 0;
}            

teria um tamanho de 4 * 13 = 52 (e, obviamente, não se encaixa em nenhum dos dois critérios: detecção primária e transposição).

Menor tamanho ganha.

Você pode usar qualquer idioma e qualquer função de biblioteca, exceto se o único objetivo dessa função é localizar, gerar ou detectar números primos.

Editar:

Embora o vencedor provavelmente seja a solução Golfscript, concederei uma recompensa de 50 pontos pela melhor solução em C ou C ++!

vsz
fonte
Sua métrica de retângulo não desencoraja a solução óbvia - melhor seria levar o maior comprimento lateral. Porém, isso reduziria a resposta GS a ter pontuação 4.
Boothby
Você está certo. O próximo problema transposto deve ter uma métrica diferente e proibir soluções simétricas. No entanto, acho que mesmo assim haverá alguém que burlará as regras ou pelo menos encontrará uma solução que o controle de qualidade não esperava ao compor as regras.
vsz 10/10

Respostas:

7

GolfScript, 13 × 1

~.,2>{1$\%!}?

GolfScript ataca novamente!

Repete a entrada, se estiver prime, caso contrário, imprime a entrada concatenada com o menor divisor apropriado. Sim, eu sei que isso está ampliando a definição de "qualquer coisa que identifique inequivocamente o resultado", mas fazer algo mais sofisticado custaria alguns caracteres extras. Se você deseja uma saída mais agradável, acrescentar os três caracteres ;]!ao código resulta 1em números primos e 0números compostos.

O algoritmo é realmente ineficiente, apenas a divisão de teste de força bruta de 2 a n- 1. A maioria dos operadores GolfScript são apenas caracteres únicos, portanto esse código funciona da mesma maneira que é transposto. Irritantemente, porém, o operador de atribuição :não permite espaços em branco entre ele e seu destino, então eu tive que fazer isso totalmente sem variáveis.

Ilmari Karonen
fonte
WRT "qualquer coisa mais extravagante custaria alguns caracteres extras" - você pode obter um GolfScript-style booleana por apenas 2.
Peter Taylor
@ Peter: Você quer dizer algo como a minha edição acima, apenas sem o !? Ou você tinha algo mais sofisticado em mente?
Ilmari Karonen 07/10/12
1
Eu estava pensando )antes do ,para que ele sempre encontre um divisor e =no final.
Peter Taylor
:seguido de nova linha, atribui ao caractere de nova linha - então não é que os espaços em branco não é permitido, é justo que o espaço em branco é o que é atribuído a
gnibbler
@gnibbler: Tecnicamente, nós dois estamos certos. :não permite espaço em branco, ou qualquer outra coisa , entre si e seu destino: o que quer que seja imediatamente seguido, seja espaço em branco ou qualquer outro token (sim, números pares, seqüências de caracteres ou blocos de código), é o que é atribuído. No entanto, espaço em branco é o que a documentação oficial especificamente adverte, e por boas razões - já que na maioria dos outros lugares, adicionar espaço em branco entre tokens no GolfScript não faz nada (normalmente, a menos que tenha sido atribuído a ...).
Ilmari Karonen 10/10/12
21

C, 2 * 70 2 * 60

Imprime ypara primos, nada de diferente.
EDIT : código alterado para salvar 10 caracteres. Deve ser executado sem parâmetros (então m=1).

main(m,n){for(scanf("%d",&n);n%++m&&n>1;);n-m||puts("y");}/*
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\*/ 

O método para lidar com a transposição é bastante genérico e pode ser aplicado a qualquer programa.
É baseado na conversão disso:

abcd/*
\\\\*/

Para isso:

a\
b\
c\
d\
/*
*/

E ambos significam simplesmente abcd.

Ugoren
fonte
wow, mau uso inteligente de linha de concatenação :)
vsz
2
Este é um site de golfe / quebra-cabeças. Não existe mau uso.
usar o seguinte comando
2
@ Boothby, acho que ele quer dizer abuso. Mas não discuto com elogios.
ugoren
14

C - 13x13

Lê a entrada de stdin e imprime um 1para primo e um 0para não primo.

////m(i;(a=)<
////aans")a;2
//:Di)tc%;;p)
//O n{ adfau+
main//bn"o%t4
(a){///f,r-c8
int b///&(-h)
;scanf///bba;
("%d",&///;r}
a);for(b///( 
=a;a%--b;//( 
);putchar((b 
<2)+48);}    

edit: compila com gcc e clang agora, outros compiladores não foram testados

quasimodo
fonte
12

C, 12x12 caracteres

Uma solução bidimensional, diferentemente da minha outra resposta , baseada no mesmo código (e, como ela, imprime ypara primo, nada para composto).
A estrutura é semelhante à resposta de Quasimodo , mas meu código é mais curto, e acho que meu uso de comemnts é um pouco mais eficiente, para que eu possa ajustar 12x12.

////m()s";np
////am{c%n>u
////i,fad%1t
////nnon"+;s
main//rf,+)(
(m,n//((&m;"
){for(//n&ny
scanf(//)&-"
"%d",&n)//m)
;n%++m&&//|;
n>1;);n-m|| 
puts("y"); }
Ugoren
fonte
7

Perl, 14 x 14

Eu acho que estou pegando o jeito disso. Especifique o número como argumento de linha de comando, outputs 0ou 1. Provavelmente mais espaço para melhorias.

$   n=pop;$p|=
 !  ($n%$_)for
  2 ..$n/2;   
   print!$p+m~
n(.r          
=$.i          
pn$n          
o%nt          
p$/!          
;_2$          
$);p          
pf +          
|o m          
=r ~          
multidão
fonte
3

Q

Comentários abusados ​​para uma solução ineficiente de caráter simétrico.

/{/////////////////////////////////
{(~)any 0=mod[x;2+(!)x-2]}"I"$(0:)0
/~
/)
/a
/n
/y
/ 
/0
/=
/m
/o
/d
/[
/x
/;
/2
/+
/(
/!
/)
/x
/-
/2
/]
/}
/"
/I
/"
/$
/(
/0
/:
/)
/0

Pega a entrada de STDIN, retorna um booleano.

skeevey
fonte
Percebeu o sqrtlá. Ao procurar números primos no código-golfe, geralmente é vantajoso (desperdiçar) dividir até n em vez de parar no sqrt n.
Gnibbler 10/10/12
Muito verdade, obrigado. Ainda não tive a chance de tentar obter uma pontuação melhor.
Skeevey 10/10/12
Você deve incluir uma pontuação na sua resposta
FlipTack 28/12
2

Gelatina , quadrado 2x2

PÆ
ÆP

Experimente online!

Eu acho que tenho a parte de transposição correta, e se sim, a versão transposta disso é

PÆ
ÆP

Experimente online!

(que é o mesmo código)

caird coinheringaahing
fonte
4
Esta é inválida: " Você pode usar qualquer linguagem, e qualquer função de biblioteca , exceto se o único propósito de que a função é encontrar, gerar, ou detectar primos . "
Kevin Cruijssen
1

05AB1E , 1x5 1x3 ( 5 3 bytes )

Este não é um grande programa; cada linha é um programa alternativo separado para lidar com o cheque principal (sem usar o embutido principal).

ÑPQ
ÒgΘ
ÒQP
ÕαΘ
fQO
fs¢
f`Q

-2 bytes graças ao Grimy .

Espaços em branco entre linhas não são ops em 05AB1E e, como eu só uso comandos de 1 byte, isso funciona bem após a transposição.

Saídas 1/ 0para verdade / falsey, respectivamente.

Experimente o primeiro online ou verifique mais alguns casos de teste para todos eles (com o eval integrado .V) .
Transposto: experimente o primeiro online .

Explicação:

Ñ    # Get a list of all divisors of the (implicit) input-integer
     # (which would be only 1 and the integer itself for primes)
 P   # Take the product of that list
  Q  # And check if it's equal to the (implicit) input-integer

Ò    # Get a list of all prime factors of the (implicit) input-integer 
 g   # Get the amount of those prime factors by taking the length of the list
  Θ  # Check if that's equal to 1 (so only itself is a prime factor)

Ò    # Get a list of all prime factors of the (implicit) input-integer including duplicates
 Q   # Check for each if it's equal to the (implicit) input-integer
     # (1 if truthy; 0 if falsey)
  P  # Take the product of those checks (resulting in either 1 or 0 as well)

Õ    # Get the Euler totient of the (implicit) input-integer
 α   # Take the absolute difference with the (implicit) input-integer
  Θ  # Check if that's equal to 1

f    # Get a list of all prime factors of the (implicit) input-integer without duplicates
 Q   # Check for each if it's equal to the (implicit) input-integer
  O  # And take the sum of that (resulting in either 1 or 0)

f    # Get a list of all prime factors of the (implicit) input-integer without duplicates
 s   # Swap to get the (implicit) input-integer
  ¢  # And count how many time it occurs in the list

f    # Get a list of all prime factors of the (implicit) input-integer without duplicates
 `   # Dump all the content of this list onto the stack
  Q  # Check if the top two values are equal, or if only a single value is present, it will
     # use the (implicit) input-integer as second value

     # For all these program the same applies at the end:
     # (implicitly output the result with trailing newline)

NOTA: Se apenas um valor de verdade / falsey for válido e não for necessário precisar ser distinto, poderá Ògou Õαpoderá ser usado como dois bytes válidos, pois apenas 1é verdade em 05AB1E e todo o resto é falsey: tente os dois para alguns casos de teste .

Se os componentes internos fossem permitidos, um único pseria suficiente: Experimente online ou verifique mais alguns casos de teste .

Kevin Cruijssen
fonte
1
ÑPQou ÒgΘou ÒQPpor 3 bytes. ( Ñe Òambos têm objetivos diferentes de "encontrar, gerar ou detectar números primos", para que não sejam incluídos na proibição, pela minha leitura).
Grimmy
1
Mais de 3 byters: ÕαΘ, fQO, fs¢,f`Q
Grimmy
@ Grimy Ah, não posso acreditar que não tinha pensado nos divisores ou nos fatores primos incorporados. Respondi rápido demais, acho. Mas não sabia Õα! Essa é bem legal.
Kevin Cruijssen
0

dzaima / APL, 8 × 9 = 72

{t0,1↓⍳⍵
 ←⍵∊∘.×⍨t
 0      
 ,∘      
 1.      
 ↓×      
 ⍳⍨      
 t     }

Experimente o original ou transposto !

dzaima
fonte
0

Python 3 , tamanho 28 x 28

lambda i:i>1 and           \
all(i%j for j in range(2,i))
ml="""                     "
b("                        "
di"                        "
a%"  
 j   
i    
:f   
io   
>r   
1    
 j   
a    
ni   
dn   
     
 r   
 a   
 n   
 g   
 e   
 (   
 2   
 ,   
 i   
 )   
\)"""

Experimente online!

Joel
fonte
0

JavaScript (Node.js) , 26 25x5

n=>!( P/**//*-
= * P =* /** -         r 
>**/= r=>n%--r?P(r):~-r)(
/*////=  %  *        /*/n
*1 )//>*/   /        *//)

Experimente online!

Transposto:

n=>/*
= **1
>**/ 
! //)
(P=//
   //
P=r=>
/*= *
* > /
*/n% 
/*%  
/*-  
* -*/
--r  
  ?  
  P  
  (  
  r  
  )  
  :  
  ~  
  -/*
  r*/
 r)//
  (n)

Experimente online!

Shieru Asakoto
fonte
0

APL (Dyalog Unicode) , 10x11

{⍵∊∘.×⍨1↓⍳⍵          
           
           
 .          
 ×          
           
 1          
           
           
          }

Experimente online!

Corrigida a função para atender às especificações. Obrigado @ Adám pelo aviso.

Retorna 0 para verdade, 1 para falsidade .

Quão

{⍵∊∘.×⍨1↓⍳⍵  Dfn. everything below this is a noop up until closing the brace
         ⍳⍵  Range [1..arg]
       1    Dropping the first element (yields [2..arg])
   ∘.×⍨      Multiplication table for each element in the vector
 ⍵∊          Check if the argument is in the table.

A versão transposta é exatamente a mesma.

J. Sallé
fonte