La tâche est simple: votre programme lit un entier en entrée et affiche s'il s'agit d'un nombre premier ou non. Vous pouvez imprimer "oui / non", "vrai / faux" ou tout ce qui identifie sans ambiguïté le résultat.

Le défi est que le code doit fonctionner avec ses lignes et colonnes transposées.

Pour exclure la solution évidente (la solution la plus courte "simple" répétée verticalement caractère par caractère avec l'utilisation de commentaires), la métrique est un peu différente du code-golf habituel:

Étant donné que le formatage est très important dans ce défi , la taille du code est mesurée dans la zone du plus petit rectangle dans lequel le code tient. En d'autres termes, les espaces comptent et les lignes doivent être remplies pour être de longueur égale (vous ne le faites pas devez le faire lorsque vous postez la solution, par souci de simplicité). Par exemple

int main()   
{            
    return 0;
}            

aurait une taille de 4 * 13 = 52, _{(et évidemment il ne correspond à aucun des deux critères: détection primaire et transposable.)}

La plus petite taille gagne.

Vous pouvez utiliser n'importe quel langage et n'importe quelle fonction de bibliothèque, sauf si le seul but de cette fonction est de rechercher, générer ou détecter des nombres premiers.

Éditer:

Alors que le gagnant serait probablement la solution Golfscript, je vais attribuer une prime de 50 points pour la meilleure solution C ou C ++!

GolfScript, 13 × 1

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

GolfScript frappe à nouveau!

Répète l'entrée si elle est première, sinon imprime l'entrée concaténée avec son plus petit diviseur approprié. Oui, je sais que cela étire la définition de «tout ce qui identifie sans ambiguïté le résultat», mais faire quelque chose de plus sophistiqué coûterait quelques caractères supplémentaires. Si vous voulez une sortie plus agréable, ajouter les trois caractères ;]!au code donne 1des nombres premiers et 0des nombres composites.

L'algorithme est vraiment inefficace, juste une division d'essai par force brute de 2 à n −1. La plupart des opérateurs GolfScript ne sont que des caractères uniques, donc ce code fonctionne tout aussi bien transposé. Malheureusement, l'opérateur d'affectation :n'autorise pas les espaces entre lui et sa cible, j'ai donc dû le faire entièrement sans variables.

C, 2 * 70 2 * 60

Imprime ypour les nombres premiers, rien d'autre.
EDIT : code modifié pour enregistrer 10 caractères. Doit être exécuté sans paramètres (donc m=1).

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

La méthode de gestion de la transposition est assez générique et peut être appliquée à n'importe quel programme.
Il est basé sur la conversion de ceci:

abcd/*
\\\\*/

Pour ça:

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

Et les deux signifient simplement abcd.

C - 13x13

Lit l'entrée de stdin et imprime un 1pour premier et un 0pour pas premier.

////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: compile avec gcc et clang maintenant, les autres compilateurs n'ont pas été testés

C, 12 x 12 caractères

Une solution à deux dimensions, contrairement à mon autre réponse , basée sur le même code (et comme ça, imprime ypour le premier, rien pour le composite).
La structure est similaire à la réponse de Quasimodo , mais mon code est plus court, et je pense que mon utilisation des comemnts est un peu plus efficace, donc je peux tenir 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

Je pense que je comprends cela. Spécifiez le nombre comme argument de ligne de commande, sorties 0ou 1. Probablement plus de marge d'amélioration.

$   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

Commentaires abusifs pour une solution symétrique et de caractère inefficace.

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

Prend l'entrée de STDIN, retourne un booléen.

Gelée , 2x2 carré

PÆ
ÆP

Essayez-le en ligne!

Je pense que j'ai la partie de transposition correcte, et si oui, la version transposée de ceci est

PÆ
ÆP

Essayez-le en ligne!

(qui est le même code)

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

Ce n'est pas un gros programme; chaque ligne est un programme alternatif séparé pour aborder la vérification principale (sans utiliser la fonction intégrée principale).

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

-2 octets grâce à Grimy .

Les espaces entre les lignes sont sans opération dans 05AB1E, et comme je n'utilise que des commandes à 1 octet, cela fonctionne très bien après la transposition.

Sorties 1/ 0pour vérité / falsey respectivement.

Essayez le premier en ligne ou vérifiez d'autres cas de test pour tous (avec eval intégré .V) .
Transposé: essayez le premier en ligne .

Explication:

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

REMARQUE: Si seule une valeur truey / falsey est valide, et qu'elle ne doit pas nécessairement être distincte, Ògou Õαpeut être utilisée comme 2 octets valides, car seule 1est truey dans 05AB1E, et tout le reste est falsey: Essayez les deux eux pour certains cas de test .

Si les builds étaient autorisés, un seul paurait suffi: essayez-le en ligne ou vérifiez d'autres cas de test .

Enchantements runiques , 7 × 1

v̀i'PA@

Essayez-le en ligne!

Runic ne se soucie pas de vos faibles tentatives de réarrangement des sources! Conforme à l'exigence de toujours fonctionner après avoir transposé la source coûte +3 octets (+2 largeur de rectangle) pour le modificateur de réflexion et le point d'entrée.

Transposé ou transposé, mais en laissant le caractère de combinaison attaché à son parent .

dzaima / APL, 8 × 9 = 72

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

Essayez l'original ou transposé !

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

Essayez-le en ligne!

JavaScript (Node.js) , 26 25x5

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

Essayez-le en ligne!

Transposé:

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

Essayez-le en ligne!

APL (Dyalog Unicode) , 10x11

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

Essayez-le en ligne!

Correction de la fonction pour se conformer aux spécifications. Merci @ Adám pour l'avertissement.

Renvoie 0 pour la vérité, 1 pour la fausse .

Comment

{⍵∊∘.×⍨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 version transposée est exactement la même.