Transposé, nombres premiers, oh mon Dieu!


15

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


Votre métrique rectangle ne parvient pas à décourager la solution évidente - mieux serait de prendre la longueur latérale la plus longue. Cependant, cela réduirait la réponse de GS à avoir un score de 4.
boothby

Tu as raison. Le prochain problème transposé devrait avoir une métrique différente et interdire les solutions symétriques. Cependant, je pense que même dans ce cas, il y aura quelqu'un qui contournera les règles ou trouvera au moins une solution à laquelle l'AQ ne s'attendait pas lors de la rédaction des règles.
vsz

Réponses:


7

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.


Wrt "n'importe quoi plus sophistiqué coûterait quelques caractères supplémentaires" - vous pouvez obtenir un booléen de style GolfScript pour seulement 2.
Peter Taylor

@Peter: Vous voulez dire quelque chose comme mon montage ci-dessus, uniquement sans le !? Ou aviez-vous quelque chose de plus sophistiqué en tête?
Ilmari Karonen du

1
Je pensais )avant le ,pour qu'il trouve toujours un diviseur et =à la fin.
Peter Taylor

:suivi de la nouvelle ligne, assigne le caractère de nouvelle ligne - ce n'est donc pas que les espaces blancs ne sont pas autorisés, c'est juste que les blancs sont ce qui est assigné
gnibbler

@gnibbler: Techniquement, nous avons tous les deux raison. :n'autorise pas d'espaces, ni rien d'autre , entre lui-même et sa cible: tout ce qui le suit immédiatement, que ce soit des espaces ou tout autre jeton (oui, des nombres pairs, des chaînes ou des blocs de code), est ce qui est attribué. Cependant, les espaces sont ce que la documentation officielle met en garde spécifiquement et pour une bonne raison - car dans la plupart des autres endroits, l'ajout d'espaces entre les jetons dans GolfScript ne fait rien (normalement, à moins qu'il ne soit attribué à ...).
Ilmari Karonen

21

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.


wow, mauvaise utilisation intelligente de la concaténation de ligne :)
vsz

2
Ceci est un site de golf / puzzles. Il n'y a pas de mauvaise utilisation.
stand

2
@boothby, je suppose qu'il veut dire abus. Mais je ne conteste pas les compliments.
ugoren

14

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


12

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

7

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 ~          

3

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.


J'ai remarqué le sqrtdedans. Lorsque vous recherchez des nombres premiers dans le code-golf, il est généralement avantageux de diviser (inutilement) jusqu'à n plutôt que de vous arrêter à sqrt n.
grignoteur

Très vrai, merci. Je n'ai pas encore eu l'occasion d'essayer d'obtenir un meilleur score.
skeevey

Vous devez inclure un score dans votre réponse
FlipTack

2

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)


4
Ceci n'est pas valide: " 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 trouver, générer ou détecter des nombres premiers . "
Kevin Cruijssen

1

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 .


1
ÑPQou ÒgΘou ÒQPpour 3 octets. ( Ñet les Òdeux ont des objectifs autres que «trouver, générer ou détecter des nombres premiers», ils ne sont donc pas inclus dans l'interdiction, d'après ma lecture).
Grimmy

1
Plus de 3 byters: ÕαΘ, fQO, fs¢,f`Q
Grimmy

@Grimy Ah, je ne peux pas croire que je n'avais pas pensé aux diviseurs ou aux facteurs premiers intégrés. J'ai répondu trop rapidement, je suppose. Je n'en savais rien Õα, cependant! C'est plutôt sympa.
Kevin Cruijssen





0

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.

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.