Die Aufgabe ist einfach: Ihr Programm liest eine Ganzzahl als Eingabe und gibt aus, ob es sich um eine Primzahl handelt oder nicht. Sie können "ja / nein", "wahr / falsch" oder irgendetwas drucken, was das Ergebnis eindeutig identifiziert.

Die Herausforderung besteht darin, dass der Code mit vertauschten Zeilen und Spalten arbeiten muss.

Um die offensichtliche Lösung auszuschließen (kürzeste "einfache" Lösung, die vertikal char-by-char mit der Verwendung von Kommentaren wiederholt wird), unterscheidet sich die Metrik ein wenig vom üblichen Code-Golf:

Da die Formatierung bei dieser Herausforderung sehr wichtig ist , wird die Codegröße im Bereich des kleinsten Rechtecks ​​gemessen, in das der Code passt. Mit anderen Worten, Leerzeichen zählen, und die Zeilen sollten mit der gleichen Länge gefüllt werden (dies ist nicht der Fall) müssen es tatsächlich tun, wenn Sie die Lösung veröffentlichen (der Einfachheit halber). Beispielsweise

int main()   
{            
    return 0;
}            

hätte eine Größe von 4 * 13 = 52 _{(und offensichtlich entspricht es keinem der beiden Kriterien: Primerkennung und transponierbar.)}

Die kleinste Größe gewinnt.

Sie können jede Sprache und jede Bibliotheksfunktion verwenden, es sei denn, der einzige Zweck dieser Funktion besteht darin, Primzahlen zu finden, zu generieren oder zu erkennen.

Bearbeiten:

Während der Gewinner wahrscheinlich die Golfscript-Lösung sein wird, werde ich eine Prämie von 50 Punkten für die beste C- oder C ++ - Lösung vergeben!

GolfScript, 13 × 1

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

GolfScript schlägt wieder zu!

Wiederholt die Eingabe, wenn es sich um eine Primzahl handelt, andernfalls wird die Eingabe zusammen mit dem kleinsten geeigneten Divisor gedruckt. Ja, ich weiß, dass dies die Definition von "irgendetwas, was das Ergebnis eindeutig identifiziert" erweitert, aber alles, was schicker ist, würde ein paar zusätzliche Zeichen kosten. Wenn Sie eine bessere Ausgabe wünschen, können Sie die drei Zeichen ;]!an den Code anhängen, 1um Primzahlen und 0zusammengesetzte Zahlen zu erhalten.

Der Algorithmus ist wirklich ineffizient, nur eine Brute-Force-Teilung von 2 auf n −1. Die meisten GolfScript-Operatoren bestehen nur aus einzelnen Zeichen, daher funktioniert dieser Code genauso gut transponiert. Leider :erlaubt der Zuweisungsoperator keine Leerzeichen zwischen sich und seinem Ziel, daher musste ich dies komplett ohne Variablen tun.

C 2 * 70 2 * 60

Drucke yfür Primzahlen, sonst nichts.
BEARBEITEN : Code geändert, um 10 Zeichen zu sparen. Muss ohne Parameter ausgeführt werden (so m=1).

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

Die Methode zur Bearbeitung der Transposition ist sehr allgemein und kann auf jedes Programm angewendet werden.
Es basiert auf der Konvertierung von:

abcd/*
\\\\*/

Dazu:

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

Und beide meinen einfach abcd.

C - 13 × 13

Liest die Eingabe von stdin und gibt ein 1für Prim und ein 0für nicht Prim aus.

////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: kompiliert jetzt mit gcc und clang, andere compiler wurden nicht getestet

C, 12 × 12 Zeichen

Eine zweidimensionale Lösung, die im Gegensatz zu meiner anderen Antwort auf demselben Code basiert (und die wie diese yfür prime druckt , nichts für composite).
Die Struktur ähnelt der Antwort von Quasimodo , aber mein Code ist kürzer und ich denke, dass meine Verwendung von Comemnts ein bisschen effizienter ist, sodass ich 12x12 anpassen kann.

////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

Ich glaube, ich bekomme den Dreh raus. Geben Sie die Nummer als Befehlszeilenargument an, geben Sie 0oder aus 1. Wahrscheinlich mehr Raum für Verbesserungen.

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

Missbrauchte Kommentare für eine symmetrische, ineffiziente Lösung.

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

Übernimmt die Eingabe von STDIN und gibt einen Booleschen Wert zurück.

Gelee , 2x2 Quadrat

PÆ
ÆP

Probieren Sie es online!

Ich denke, ich habe den Transpositionsteil richtig und wenn ja, ist die transponierte Version davon

PÆ
ÆP

Probieren Sie es online!

(das ist der gleiche Code)

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

Dies ist kein einziges großes Programm. Jede Zeile ist ein separates alternatives Programm, um den Prime Check zu lösen (ohne das eingebaute Prime zu verwenden).

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

-2 Bytes dank Grimy .

Leerzeichen zwischen den Zeilen sind in 05AB1E No-Ops, und da ich nur 1-Byte-Befehle verwende, funktioniert dies nach dem Transponieren einwandfrei.

Ausgänge 1/ 0für Wahrhaftigkeit / Falschheit.

Probieren Sie den ersten online aus oder überprüfen Sie einige weitere Testfälle für alle (mit eval builtin .V) .
Transponiert: Probieren Sie den ersten online aus .

Erläuterung:

Ñ    # 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)

HINWEIS: Wenn nur ein truthy / Falsey Wert gültig ist , und es nicht nötig hat verschieden sein, entweder Ògoder Õαkönnte als gültige 2-byters verwendet werden, nur weil 1truthy in 05AB1E ist, und alles andere ist Falsey: beide Versuchen von sie für einige Testfälle .

Wenn Builtins erlaubt pwären, hätte ein einzelnes ausgereicht: Probieren Sie es online aus oder überprüfen Sie einige weitere Testfälle .

Runenverzauberungen , 7 × 1

v̀i'PA@

Probieren Sie es online!

Runic kümmert sich nicht um Ihre schwachen Versuche, die Quelle neu zu ordnen! Entsprechend der Anforderung, nach dem Umsetzen der Quelle noch zu funktionieren, werden +3 Byte (+2 Rechteckbreite) für den Reflexionsmodifikator und den Einstiegspunkt berechnet.

Transponiert oder transponiert, wobei das kombinierende Zeichen dem übergeordneten Element zugeordnet bleibt .

dzaima / APL, 8 × 9 = 72

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

Probieren Sie das Original oder transponiert !

Python 3 , 28 x 28 Größe

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   
 )   
\)"""

Probieren Sie es online!

JavaScript (Node.js) , 26 x 25

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

Probieren Sie es online!

Transponiert:

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

Probieren Sie es online!

APL (Dyalog Unicode) , 10 x 11

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

Probieren Sie es online!

Die Funktion wurde korrigiert, um den Spezifikationen zu entsprechen. Vielen Dank an @ Adám für das Heads-up.

Gibt 0 für wahr, 1 für falsch zurück .

Wie

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

Die transponierte Fassung ist genau die gleiche.