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 ++!

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.

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.

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

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

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 ~          

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.

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)

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 .

Encantos Rúnicos , 7 × 1

v̀i'PA@

Experimente online!

A Runic não se importa com suas fracas tentativas de rearranjo da fonte! Em conformidade com o requisito de continuar funcionando depois de a fonte ter transposto o custo +3 bytes (+2 largura do retângulo) para o modificador de reflexão e o ponto de entrada.

Transposto ou transposto, mas deixando o caractere de combinação anexado ao seu pai .

dzaima / APL, 8 × 9 = 72

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

Experimente o original ou transposto !

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!

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!

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.