Il compito è semplice: il tuo programma legge un numero intero come input e stampa se è un numero primo o no. Puoi stampare "sì / no", "vero / falso" o qualsiasi cosa identifichi in modo inequivocabile il risultato.

La sfida è che il codice deve funzionare con le sue righe e colonne trasposte.

Per escludere la soluzione ovvia (la soluzione "semplice" più breve ripetuta verticalmente a carboncino con l'uso di commenti), la metrica è un po 'diversa dal solito code-golf:

Poiché la formattazione è molto importante in questa sfida , la dimensione del codice viene misurata nell'area del rettangolo più piccolo in cui si inserisce il codice. In altre parole, lo spazio bianco conta e le linee devono essere riempite per avere la stessa lunghezza (non devi effettivamente farlo quando pubblichi la soluzione, per semplicità). Per esempio

int main()   
{            
    return 0;
}            

avrebbe una dimensione di 4 * 13 = 52, _{(e ovviamente non si adatta a nessuno dei due criteri: rilevazione primaria e trasposizione.)}

Vince la dimensione più piccola.

È possibile utilizzare qualsiasi linguaggio e qualsiasi funzione di libreria, tranne se l'unico scopo di quella funzione è trovare, generare o rilevare numeri primi.

Modificare:

Mentre il vincitore sarebbe probabilmente la soluzione Golfscript, assegnerò un premio di 50 punti per la migliore soluzione C o C ++!

GolfScript, 13 × 1

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

GolfScript colpisce ancora!

Ripete l'input se è primo, altrimenti stampa l'input concatenato con il suo divisore proprio più piccolo. Sì, lo so che sta allungando la definizione di "qualunque cosa identifichi in modo inequivocabile il risultato", ma fare qualcosa di più fantasioso costerebbe qualche personaggio in più. Se si desidera un output migliore, aggiungendo i tre caratteri ;]!al codice si ottengono i 1numeri primi e quelli 0composti.

L'algoritmo è davvero inefficiente, solo divisione di prova della forza bruta da 2 a n −1. La maggior parte degli operatori GolfScript sono solo singoli caratteri, quindi questo codice funziona altrettanto bene trasposto. In modo fastidioso, tuttavia, l'operatore di assegnazione :non consente spazi bianchi tra se stesso e il suo obiettivo, quindi ho dovuto farlo completamente senza variabili.

C, 2 * 70 2 * 60

Stampe yper numeri primi, nient'altro.
EDIT : codice modificato per salvare 10 caratteri. Deve essere eseguito senza parametri (quindim=1 ).

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

Il metodo per gestire la trasposizione è abbastanza generico e può essere applicato a qualsiasi programma.
Si basa sulla conversione di questo:

abcd/*
\\\\*/

A questo:

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

Ed entrambi significano semplicemente abcd.

C - 13x13

Legge l'input da stdin e stampa a 1 per prime e a 0per non 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);}    

modifica: compila ora con gcc e clang, altri compilatori non sono stati testati

C, 12x12 caratteri

Una soluzione bidimensionale, a differenza della mia altra risposta , basata sullo stesso codice (e simile, stampa yper prime, niente per composito).
La struttura è simile alla risposta di Quasimodo , ma il mio codice è più breve e penso che il mio uso dei commenti sia un po 'più efficiente, quindi posso adattarmi a 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

Penso di aver capito bene. Specificare il numero come argomento della riga di comando, output 0o 1. Probabilmente c'è più margine di miglioramento.

$   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

Commenti abusati per una soluzione simmetrica e inefficiente per il personaggio.

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

Riceve input da STDIN, restituisce un valore booleano.

Gelatina , 2x2 quadrati

PÆ
ÆP

Provalo online!

Penso di avere la parte di trasposizione corretta, e in tal caso, la versione trasposta di questo è

PÆ
ÆP

Provalo online!

(che è lo stesso codice)

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

Questo non è un grande programma; ogni riga è un programma alternativo separato per affrontare il controllo primo (senza usare il primo incorporato).

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

-2 byte grazie a Grimy .

Gli spazi bianchi tra le linee non sono operativi in ​​05AB1E e poiché utilizzo solo comandi a 1 byte, questo funziona bene dopo la trasposizione.

Output 1/ rispettivamente 0per verità / falsità.

Prova il primo online o verifica alcuni altri casi di test per tutti (con eval builtin .V) .
Trasposto: prova il primo online .

Spiegazione:

Ñ    # 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 solo un valore di verità / falsità è valido e non è necessario che sia necessario distinguerlo, uno Ògo Õαpotrebbe essere utilizzato come valido 2 byte, poiché solo in 105AB1E è vero e tutto il resto è falso: prova entrambi per alcuni casi di test .

Se i builtin fossero stati consentiti, psarebbe bastato un singolo : provalo online o verifica alcuni altri casi di test .

Incantesimi runici , 7 × 1

v̀i'PA@

Provalo online!

Runic non si preoccupa dei tuoi deboli tentativi di riorganizzazione della fonte! Conforme al requisito di funzionare ancora dopo aver trasposto la sorgente costa +3 byte (+2 larghezza rettangolo) per il modificatore della riflessione e il punto di ingresso.

Trasposto o trasposto, ma lasciando il carattere combinato attaccato al suo genitore .

dzaima / APL, 8 × 9 = 72

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

Prova l'originale o trasposto !

Python 3 , dimensioni 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   
 )   
\)"""

Provalo online!

JavaScript (Node.js) , 26 25x5

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

Provalo online!

trasposto:

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

Provalo online!

APL (Dyalog Unicode) , 10x11

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

Provalo online!

Correzione della funzione in conformità con le specifiche. Grazie @Adám per l'heads-up.

Restituisce 0 per verità, 1 per falsa .

Come

{⍵∊∘.×⍨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 versione trasposta è esattamente la stessa.