La tarea es simple: su programa lee un número entero como entrada e imprime si es primo o no. Puede imprimir "sí / no", "verdadero / falso" o cualquier cosa que identifique inequívocamente el resultado.

El desafío es que el código tiene que funcionar con sus filas y columnas transpuestas.

Para excluir la solución obvia (la solución "simple" más corta repetida verticalmente char-by-char con el uso de comentarios), la métrica es un poco diferente del código de golf habitual:

Debido a que el formato es muy importante en este desafío , el tamaño del código se mide en el área del rectángulo más pequeño en el que se ajusta el código. En otras palabras, el espacio en blanco sí cuenta y las líneas deben rellenarse para que tengan la misma longitud (no tiene que hacerlo cuando publique la solución, por simplicidad). Por ejemplo

int main()   
{            
    return 0;
}            

tendría un tamaño de 4 * 13 = 52 _{(y obviamente no se ajusta a ninguno de los dos criterios: detección principal y transposición).}

El tamaño más pequeño gana.

Puede usar cualquier idioma y cualquier función de biblioteca, excepto si el único propósito de esa función es encontrar, generar o detectar números primos.

Editar:

Si bien el ganador probablemente sería la solución Golfscript, ¡otorgaré una recompensa de 50 puntos por la mejor solución C o C ++!

GolfScript, 13 × 1

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

¡GolfScript ataca de nuevo!

Repite la entrada si es primo; de lo contrario, imprime la entrada concatenada con su divisor adecuado más pequeño. Sí, sé que eso está ampliando la definición de "cualquier cosa que identifique inequívocamente el resultado", pero hacer algo más elegante costaría unos pocos caracteres adicionales. Si desea una salida más agradable, agregar los tres caracteres ;]!al código produce 1primos y 0números compuestos.

El algoritmo es realmente ineficiente, solo la división de prueba de fuerza bruta de 2 a n −1. La mayoría de los operadores de GolfScript son solo caracteres individuales, por lo que este código funciona igual de bien transpuesto. Sin embargo, molestamente, el operador de asignación :no permite espacios en blanco entre sí y su objetivo, por lo que tuve que hacer esto completamente sin variables.

C, 2 * 70 2 * 60

Imprime ypara primos, nada de lo contrario.
EDITAR : Se modificó el código para guardar 10 caracteres. Debe ejecutarse sin parámetros (así m=1).

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

El método para manejar la transposición es bastante genérico y puede aplicarse a cualquier programa.
Se basa en convertir esto:

abcd/*
\\\\*/

A esto:

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

Y ambos significan simplemente abcd.

C - 13x13

Lee la entrada de stdin e imprime a 1for prime y a 0for not prime.

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

editar: compila con gcc y clang ahora, otros compiladores no fueron probados

C, 12x12 caracteres

Una solución bidimensional, a diferencia de mi otra respuesta , basada en el mismo código (y al igual que, imprime ypara prime, nada para composite).
La estructura es similar a la respuesta de Quasimodo , pero mi código es más corto y creo que mi uso de comentarios es un poco más eficiente, por lo que puedo 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

Creo que me estoy acostumbrando a esto. Especifique el número como argumento de línea de comando, salidas 0o 1. Probablemente más margen de mejora.

$   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

Comentarios maltratados para una solución simétrica de carácter ineficiente.

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

Toma información de STDIN, devuelve un booleano.

Gelatina , cuadrado 2x2

PÆ
ÆP

Pruébalo en línea!

Creo que tengo la parte de transposición correcta, y si es así, la versión transpuesta de esto es

PÆ
ÆP

Pruébalo en línea!

(que es el mismo código)

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

Este no es un gran programa; cada línea es un programa alternativo separado para abordar el primer cheque (sin usar el primo incorporado).

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

-2 bytes gracias a Grimy .

Los espacios en blanco entre líneas son no-ops en 05AB1E, y dado que solo uso comandos de 1 byte, esto funciona bien después de la transposición.

Salidas 1/ 0para veracidad / falsey respectivamente.

Pruebe el primero en línea o verifique algunos casos de prueba más para todos ellos (con eval incorporado .V) .
Transpuesto: pruebe el primero en línea .

Explicación:

Ñ    # 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: Si solo un valor verdadero / falso es válido, y no necesariamente tiene que ser distinto, ya sea Ògo Õαpodría usarse como 2 bytes válidos, ya que solo 1es verdadero en 05AB1E, y todo lo demás es falso: Pruebe ambos ellos para algunos casos de prueba .

Si se permitieran las incorporaciones, una sola phubiera sido suficiente: Pruébelo en línea o verifique algunos casos de prueba más .

Encantamientos rúnicos , 7 × 1

v̀i'PA@

Pruébalo en línea!

¡Runic no se preocupa por tus débiles intentos de reorganización de la fuente! Cumpliendo con el requisito de seguir funcionando después de tener el costo de la fuente transpuesta +3 bytes (+2 ancho del rectángulo) para el modificador de reflexión y el punto de entrada.

Transpuesta o transpuesto, pero dejando el carácter que combina unido a su padre .

dzaima / APL, 8 × 9 = 72

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

¡Prueba el original o transpuesto !

Python 3 , tamaño 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   
 )   
\)"""

Pruébalo en línea!

JavaScript (Node.js) , 26 25x5

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

Pruébalo en línea!

Transpuesto:

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

Pruébalo en línea!

APL (Dyalog Unicode) , 10x11

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

Pruébalo en línea!

Se corrigió la función para cumplir con las especificaciones. Gracias @ Adám por el aviso.

Devuelve 0 para verdad, 1 para falsedad .

Cómo

{⍵∊∘.×⍨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.

La versión transpuesta es exactamente la misma.