Défi:

Étant donné un tableau de nombres entiers non négatifs dans la plage de0 to Infinity , vérifiez si tous sont des nombres premiers ou non. (Vous pouvez également prendre l'entrée comme une chaîne si vous le souhaitez)

Contribution:

Entrée: un tableau de nombres

Sortie: le tableau avec chaque élément remplacé par l'un d'eux:

-1                 -----> If 0, 1
1                  -----> If it is a prime number greater than 1
the highest factor -----> If that number is not prime

Renvoie -1 (0, 1), 1 (pour les nombres premiers> = 2) ou le facteur le plus élevé du nombre donné (pour les nombres non premiers)

Exemples:

[1, 2, 3, 4, 10, 11, 13]                        ---> [-1, 1, 1, 2, 5, 1, 1]
[100, 200, 231321, 12312, 0, 111381209, 123123] ---> [50, 100, 77107, 6156, -1, 1, 41041]

Remarque:

L'entrée sera toujours valide, c'est-à-dire qu'elle ne consistera qu'en nombres et les décimales ne sont pas testées. Le tableau peut être vide, si c'est le cas, renvoyez le tableau vide.

Restriction:

C'est le code-golf donc le code le plus court en octets pour chaque langue gagne.

Classement :

Voici un extrait de pile pour générer à la fois un classement régulier et un aperçu des gagnants par langue.

Pour vous assurer que votre réponse s'affiche, veuillez commencer votre réponse avec un titre, en utilisant le modèle de démarque suivant:

# Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores dans le titre, en les barrant. Par exemple:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Si vous souhaitez inclure plusieurs nombres dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou que vous souhaitez répertorier les pénalités de drapeau d'interprète séparément), assurez-vous que le score réel est le dernier numéro de l'en-tête:

# Perl, 43 + 2 (-p flag) = 45 bytes

Vous pouvez également faire du nom de la langue un lien qui apparaîtra ensuite dans l'extrait de classement:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

var QUESTION_ID=163882,OVERRIDE_USER=8478;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

Gelée ,  7 6 octets

ÆḌṪ€o-

Un lien monadique acceptant une liste d'entiers non négatifs et conservant une liste d'entiers supérieurs ou égaux à -1.

Essayez-le en ligne!

Comment?

Notez que:

• Tous les nombres premiers ont un seul diviseur propre (un)
• Tous les composites ont plusieurs diviseurs appropriés (un plus les autres)
• Aucun nombre n'a lui-même comme diviseur approprié
• L'atome de diviseurs get-proper-diviseurs de Jelly ÆḌ, donne une liste des diviseurs appropriés dans l'ordre croissant
• Zéro et un n'ont pas de diviseurs appropriés (ils ne sont ni premiers ni composites)
• L'application de l'atome de queue de Jelly Ṫà une liste vide donne zéro
• Aucun nombre n'a un diviseur propre de zéro (sans parler d'être le diviseur maximal)
• Tous les nombres non nuls sont véridiques dans Jelly, tandis que zéro est falsey

ÆḌṪ€o- | Link: list of integers   e.g. [ 0, 1,  2,  5,     10,    5183]
ÆḌ     | proper divisors (vectorises)  [[],[],[1],[1],[1,2,5],[1,71,73]]
  Ṫ€   | tail €ach                     [ 0, 0,  1,  1,      5,      73]
     - | literal minus one
    o  | logical OR (vectorises)       [-1,-1,  1,  1,      5,      73]

Gelée , 9 8 octets

1 octet enregistré grâce à @Dennis

:ÆfṂ€$~~

Essayez-le en ligne! ou exécutez tous les cas de test

Commenté

Nous profitons du fait que les deux nanet infdevenir 0en gelée quand Bitwise pas leur est appliquée.

:ÆfṂ€$~~ - main link, taking the input list
 ÆfṂ€$   - treat these two links as a monad:
 Æf      -   get the lists of prime factors (0 --> 0; 1 --> empty list; prime --> itself)
    €    -   for each list,
   Ṃ     -   isolate the minimum prime factor (turns empty lists into 0)
:        - divide each entry by its minimum prime factor (0/0 --> nan; 1/0 --> inf)
      ~~ - bitwise NOT x2 (nan or inf --> 0 --> -1; other entries are unchanged)

R, 68 62 octets

Map(function(n,v=rev(which(!n%%1:n)))"if"(n<2,-1,v[2]),scan())

Une solution utilisant uniquement la base R, pas de bibliothèques! Merci à Giuseppe d'avoir joué au golf 6 octets.

Utilise scanpour lire dans une liste de nombres séparés par des espaces, %%pour identifier quels sont les facteurs. vcontient alors un vecteur de tous les facteurs dans l'ordre croissant (y compris 1 et n). Cela a la belle propriété que lorsque nous reversons v, le numéro que nous voulons sera à la deuxième place, évitant un appel coûteux à lengthou tail(s'il nétait premier, vcontient n 1, sinon il contient n (factors in descending order) 1).

Exemple de sortie (lien TIO ici ):

> Map(function(n,v=rev(which(!n%%1:n)))"if"(n<2,-1,v[2]),scan())
1: 0 1 2 3 4 5 6 7 8 9
11: 
Read 10 items
[[1]]
[1] -1

[[2]]
[1] -1

[[3]]
[1] 1

[[4]]
[1] 1

[[5]]
[1] 2

[[6]]
[1] 1

[[7]]
[1] 3

[[8]]
[1] 1

[[9]]
[1] 4

[[10]]
[1] 3

Si vous pensez que la liste n'est pas un type de retour acceptable, permuter Mappour sapplyet ajouter 3 octets.

05AB1E , 11 9 8 octets

Ñε¨àDd<+

-3 octets grâce à @Emigna , en changeant ©d1-®+vers Dd<+et ۬ۈvers ε¨à.

Seule ma deuxième réponse 05AB1E, peut donc certainement être jouée .

Essayez-le en ligne.

Explication:

Ñ           # Divisors of each item in the input-list (including itself)
            #  [1,2,10,3] → [[1],[1,2],[1,2,5,10],[1,2,3]]
 ε          # For each:
  ¨         #  Remove last item (so it's now excluding itself)
            #   [[1],[1,2],[1,2,5,10],[1,2,3]] → [[],[1],[1,2,5],[1,2]]
   à        #  And get the max
            #   [[],[1],[1,2,5],[1,2]] → ['',1,5,2]
    D       # Duplicate the list
     d      # Is it a number (1 if it's a number, 0 otherwise)
            #  ['',1,5,2] → [0,1,1,1]
      <     # Subtract 1
            #  [0,1,1,1] → [-1,0,0,0]
       +    # Add both lists together
            #  ['',1,5,2] and [-1,0,0,0] → ['-1',1,5,2]

J , 21 octets

_1:`(%{.@q:)@.(>&1)"0

Essayez-le en ligne!

Explication:

(>&1)"0 chaque nombre est-il supérieur à 1?

@. sinon, retournez _1:

(%{.@q:)si son 2 ou plus, divisez %le nombre par le premier {.des facteurs premiersq:

Japt , 6 octets

Après le golf, a fini par être presque identique à la solution de Jonathan et tout aussi courte que celle-ci.

®â¬ÌªJ

Essayez-le

Explication

®          :Map
 ⬠       :  Proper divisors
   Ì       :  Get last element (returns null if the array is empty)
    ª      :  Logical OR
     J     :  -1

Python 3 , 62 octets

lambda l:[max([k for k in range(1,n)if n%k<1]+[-1])for n in l]

Essayez-le en ligne!

Pour 0et 1 range(1,n)est vide, le code est donc évalué à max([]+[-1]) = -1. Pour les nombres premiers, le seul diviseur dans [1, n) est 1, qui est la sortie souhaitée.

Noix de coco , 50 octets

map$(n->max([k for k in range(1,n)if n%k<1]+[-1]))

Essayez-le en ligne!

Java 8, 105 103 87 bytes

a->{for(int i=a.length,n,x;i-->0;a[i]=n<2?-1:n/x)for(n=a[i],x=1;++x<n;)if(n%x<1)break;}

Modifie le tableau d'entrée au lieu d'en renvoyer un nouveau pour économiser des octets.

Essayez-le en ligne.

Explication:

a->{                  // Method with integer-array parameter and no return-type
  for(int i=a.length,n,x;i-->0;
                      //  Loop backward over the array
      a[i]=           //    After every iteration: change the current item to:
           n<2?       //     If the current item is 0 or 1:
            -1        //      Change it to -1
           :          //     Else:
            n/x)      //      Change it to `n` divided by `x`
     for(n=a[i],      //   Set `n` to the current item
         x=1;++x<n;)  //   Inner loop `x` in range [2,`n`)
       if(n%x<1)      //    If `n` is divisible by `x`:
         break;}      //     Stop the inner loop (`x` is now the smallest prime-factor)
                      //   (if the loop finishes without hitting the `break`,
                      //    it means `n` is a prime, and `x` and `n` will be the same)

Haskell, 52 49 octets

map(\x->last$[d|d<-[1..x-1],mod x d<1]++[-1|x<2])

Essayez-le en ligne!

map                     -- for each element in the input array
  \x->                  -- apply the lambda function
    last                -- pick the last element of the following list
     [d|d<-[1..x-1]     --  all d from 1 to x-1 
           ,mod x d<1]  --    where d divides x 
     ++[-1|x<2]         --  followed by -1 if x<2

Husk , 8 octets

m(|_1→hḊ

Essayez-le en ligne!

Explication

m(|_1→hḊ  Implicit Input         [1,2,3,4,10]
m(        Map each element
       Ḋ    List of divisors     [[1],[1,2],[1,3],[1,2,4],[1,2,5,10]]
     →h     Penultimate element  [0,1,1,2,5]
  |_1       If falsy then -1     [-1,1,1,2,5]

Attaché , 23 octets

@{Max&-1!Divisors@_@-2}

Essayez-le en ligne!

29 octets, sans point: @(Max&-1@Last@ProperDivisors)

24 octets, également sans point: @(Max&-1@`@&-2@Divisors)

Cela obtient simplement l'avant-dernier diviseur de npuis en prend le maximum et -1. L'avant-dernier élément d'un tableau contenant moins de deux éléments est nilet Max[-1, nil]est -1. @vectorise simplement cette fonction, la faisant s'appliquer à chaque atome.

Wolfram Language (Mathematica) , 33 octets

Divisors[#][[-2]]/._Part:>-1&/@#&

Essayez-le en ligne!

R + numbers, 88 79 octets

Merci aux commentaires pour quelques conseils principalement sur la façon de faire des soumissions.

function(y)sapply(y,function(x)"if"(x<2,-1,prod(numbers::primeFactors(x)[-1])))

Utilise le produit de tous les facteurs premiers, sauf le plus petit, et le fait que le produit des éléments d'un vecteur vide est défini comme étant 1.

Essayez-le en ligne!

Brachylog , 10 octets

{fkt|∧_1}ˢ

Essayez-le en ligne!

L'explication suivante est principalement formulée impérativement par souci de concision et ne reflète pas fidèlement la nature déclarative de Brachylog.

{          Start of inline predicate.
           Implicit input to the predicate.
 f         Create a list of all of the input's factors (including itself).
  k        Remove the last item of this list so that it no longer contains the original number.
   t       Take the last item of the list with the last item removed.
           Implicitly unify the output with the aforementioned last item.
    |      If that failed, because one of the lists was empty...
     ∧     discarding the input, (there's probably some obvious reason ∨ won't work here but I don't know what it is)
      _1   unify the output with -1 instead.
        }  End of the inline predicate.
         ˢ For every item of the input, unify it with the predicate's input and get a list of the corresponding outputs.

J'ai décidé d'apprendre Brachylog afin de pouvoir m'amuser avec le golf de code tout en espérant apprendre le comportement du Prolog réel par osmose, et je l'apprécie vraiment jusqu'à présent, même si je ne suis pas tout à fait sûr de savoir comment le les caractères de contrôle d'exécution fonctionnent.

Stax , 14 13 octets

ü±p╞Ö*«òτ♀╣â▀

Exécuter et déboguer

Explication (déballé):

m|fc%c{vsH1?}U? Full program, implicit input-parsing
m               Map
 |fc%c            Get factorisation and length of it (0 and 1 yield [])
      {     } ?   If length != 0:
       v            Decrement
           ?        If still != 0:
        sH            Last element of factorisation
           ?        Else:
          1           Push 1
              ?   Else:
             U      Push -1

Pseudocode à l'intérieur de la carte:

f = factorisation(i)
l = length(f)
if l:
    if --l:
        return f[-1]
    else:
        return 1
else:
    return -1

Pyth, 12 octets

me+_1f!%dTSt

Essayez-le ici

Explication

me+_1f!%dTSt
m            Q    For each number d in the (implicit) input...
          Std     ... get the range [1, ..., d - 1]...
     f!%dT        ... take the ones that are factors of d...
  +_1             ... prepend -1...
 e                ... and take the last.

J , 14 octets

1(%0{q:,-)@>.]

Essayez-le en ligne!

Pour chaque nombre n, prenez à la place le maximum de (n, 1).
Ajoutez le nombre négatif à la liste de ses facteurs premiers (liste vide pour 1) et divisez le nombre par le premier élément de la liste.

Aussi 14 octets

(%0{q:) ::_1"0

Essayez-le en ligne!

Divisez chaque nombre par le premier de ses facteurs premiers. 0 déclenche une erreur de domaine avec q:, et nous recherchons le 0ème élément dans une liste vide pour 1 - c'est également une erreur. Pour tout nombre contenant des erreurs, renvoyez −1.

Japt , 14 11 8 octets

®/k v)ªÉ
®        // For each input number,
 /k v    // return the number divided by it's first prime factor,
     )ªÉ // or -1 if such a number doesn't exist (the previous result is NaN).

Essayez-le en ligne!

Rasé ces trois octets embêtants grâce à Shaggy .

JavaScript (Node.js) , 61 55 octets

-6 octets grâce à @shaggy

_=>_.map(_=>eval('for(v=_/(d=_>>1);v!=~~v;v=_/--d);d'))

Essayez-le en ligne!

Explication:

_ =>                                     // input i.e : the original array
    _.map(                               // map over all elements of the array
        eval('                           // eval a string
            for(v=_/(d=_>>1);            // set v = _ / _ >> 1 and set that to d
                v!=~~v;                  // and keep going until v !== floor(v)
                        v=_/d--);        // to _ / d again (d was changed)
                    d'                   // return d
            ))                           // end eval and map and function

C'est toujours pour l'ancien code que je n'ai pas mis à jour.

Convient également à ES5:

 const primeOrNot = function(input) { // the function with argument input
      return input.map(function(value) { // returns the array after mapping over them
           d = Math.floor(value * 0.5); // multiply each element by 0.5 and floor it 
           for(let v = value / d; v != Math.floor(v);) { // for loop goes until v!=~~v
                d --; // subtract one from d
                v = value / d; // set v again to value / d
           }
           return d; // return d
      })
 };

Utilitaires Bash + GNU, 49

• 9 octets enregistrés grâce à @Cowsquack

factor|sed '/:$/c-1
/: \w+$/c1
s%: %/%
y/ /#/'|bc

Explication

• factor lit les numéros d'entrée de STDIN, un par ligne et les sorties au format <input number>: <space-separated list of prime factors (ascending)>
• sed traite cela comme suit:
  • /:$/c-1 Les nombres d'entrée 0 et 1 n'ont pas de facteurs premiers et sont remplacés par -1
  • /: \w+$/c1Les nombres avec un facteur premier (eux-mêmes) sont premiers. Remplacez-les par1
  • s%: %/%Remplacez :par/ . Cela construit une expression arithmétique pour diviser le nombre d'entrée (non premier) par son plus petit facteur premier pour donner le plus grand facteur
  • y/ /#/ Supprimer la liste des autres facteurs (inutiles) (en commentant)
• bc Évaluation et affichage arithmétiques

Essayez-le en ligne!

Python 2 , 61 59 octets

lambda x:[max(k for k in[-1]+range(1,n)if n%k<1)for n in x]

Essayez-le en ligne!

Améliorations

• 61 à 59 octets par Dennis .

JavaScript (Node.js) , 37 octets

x=>x.map(a=>(f=t=>a%--t<1?t:f(t))(a))

Essayez-le en ligne!

Récursif, débordement de pile pour les entrées volumineuses

JavaScript (Node.js) , 41 octets

x=>x.map(a=>eval('for(t=a;a%--t!=0;);t'))

Essayez-le en ligne!

Pari / GP , 37 octets

a->[if(x<2,-1,x/divisors(x)[2])|x<-a]

Essayez-le en ligne!

Raquette , 105 octets

(λ(L)(map(λ(n)(if(< n 2)-1(p n(- n 1))))L))(define(p n d)(if(= d 1)1(if(=(modulo n d)0)d(p n(- d 1)))))

Essayez-le en ligne!

Befunge-98 (FBBI) , 39 octets

j&:!+f0p1-1:::' -:!j;3k$.nbj;-\%!!j:1+a

Essayez-le en ligne!

Se termine par &quand il n'y a plus de numéros. Cela provoque le blocage du programme pendant 60 secondes jusqu'à ce que TIO termine le programme. C'est inévitable pour Befunge-98, au moins sur TIO car les deux interprètes le font. Après avoir joué, vous pouvez arrêter le programme après un moment afin de voir ce qui serait sorti si vous attendiez la minute.

Essentiellement, pour chaque nouveau nombre, s'il est 0, il le transforme en un 1. Ensuite, il met un -1 sur la pile suivi d'un nombre qui part de 1 et compte jusqu'à ce qu'il atteigne le numéro d'entrée, auquel cas il imprime le deuxième nombre sur la pile (-1 pour une entrée de 0 ou 1, et le facteur le plus élevé pour les autres). Chaque fois dans la boucle, nous ajoutons la valeur de l'itérateur à la pile derrière lui if ( input % iterator == 0). Cela signifie que lorsque nous arrivons à l'entrée, il nous suffit de jeter l'itérateur et d'imprimer. Ensuite, nous effaçons la pile avecn et revenons à la fonction d'entrée de lecture.

Je peux développer l'explication plus tard, nous verrons ...

Retina 0.8.2 , 33 octets

%(`^0|^1$
-1
\d+
$*
^(1+)\1+$
$.1

Essayez-le en ligne! Link inclut les cas de test qui ne sont pas trop lents. Explication:

%(`

Faites une boucle sur chaque numéro d'entrée.

^0|^1$
-1

Cas particulier 0 et 1.

\d+
$*

Convertir en unaire (n'affecte pas -1).

^(1+)\1+$
$.1

Remplacez chaque nombre par son plus grand facteur approprié en décimal.

tinylisp , 75 octets

(load library
(q((L)(map(q((N)(i(l N 2)(- 1)(/ N(min(prime-factors N))))))L

Essayez-le en ligne! (Contient 4 octets supplémentaires pour donner un nom à la fonction anonyme afin que nous puissions l'appeler dans le pied de page.)

Non golfé / explication

Observez que renvoyer 1 pour prime $n$ et le plus grand facteur inférieur à $n$ pour composite $n$ peut être combiné en retour $n/p$ où $p$ est le plus petit facteur premier de $n$.

(load library)               Library gives us map, -, /, min, and prime-factors functions

(lambda (L)                  Anonymous function, takes a list of numbers L
 (map                         Map
  (lambda (N)                  Anonymous function, takes a number N
   (if (less? N 2)              If N < 2
    (- 1)                        -1; else
    (/ N                         N divided by
     (min                        the minimum
      (prime-factors N)))))      of the prime factors of N
  L)))                        ... to L