Sfida:

Data una matrice di numeri interi non negativi nell'intervallo di0 to Infinity , Controlla se tutti sono numeri primi o no. (Puoi prendere anche l'input come stringa se vuoi)

Ingresso:

Input: una matrice di numeri

Output: l'array con ogni elemento sostituito da uno di questi:

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

Restituisce -1 (0, 1), 1 (per numeri primi> = 2) o il fattore più alto di un determinato numero (per i numeri primi)

Esempi:

[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]

Nota:

L'immissione sarà sempre valida, ovvero consisterà solo di numeri e decimali per i quali non vengono testati. L'array può essere vuoto, in tal caso, restituire l'array vuoto.

Restrizione:

Questo è code-golf, quindi il codice più breve in byte per ogni lingua vince.

Classifica :

Ecco uno snippet di stack per generare sia una classifica regolare che una panoramica dei vincitori per lingua.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, usando il seguente modello Markdown:

# Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

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

Se si desidera includere più numeri nell'intestazione (ad esempio perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

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

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet della classifica:

# [><>](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>

Gelatina ,  7 6 byte

ÆḌṪ€o-

Un collegamento monadico che accetta un elenco di numeri interi non negativi e ritenta un elenco di numeri interi maggiore o uguale a -1.

Provalo online!

Come?

Nota che:

• Tutti i numeri primi hanno un solo divisore proprio (uno)
• Tutti i compositi hanno più divisori propri (uno più gli altri)
• Nessun numero ha se stesso come un vero divisore
• L'atomo di Jelly di divisori propri ÆḌ, produce un elenco di divisori propri in ordine crescente
• Zero e uno non hanno divisori propri (non sono né primi, né compositi)
• Applicando l'atomo di coda di Jelly Ṫ, a una lista vuota si ottiene zero
• Nessun numero ha un divisore corretto di zero (per non parlare del massimo)
• Tutti i numeri diversi da zero sono veri in Jelly, mentre zero è falso

ÆḌṪ€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]

Gelatina , 9 8 byte

Salvato 1 byte grazie a @Dennis

:ÆfṂ€$~~

Provalo online! o eseguire tutti i casi di test

Commentate

Approfittiamo del fatto che entrambi nane infdiventiamo 0in Jelly quando viene applicato un NOT bit a bit.

:Æ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 byte

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

Una soluzione che utilizza solo la base R, nessuna libreria! Grazie a Giuseppe per aver giocato a golf 6 byte.

Utilizza scanper leggere in un elenco di numeri separato da spazi, %%per identificare quali sono i fattori. vcontiene quindi un vettore di tutti i fattori in ordine crescente (compresi 1 e n). Questo ha la simpatica proprietà che quando si reverse v, il numero che vogliamo sarà in secondo luogo, evitando una chiamata costosi da lengtho tail(se nera Primo, vcontiene n 1, altrimenti contiene n (factors in descending order) 1).

Esempio di output (link TIO qui ):

> 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

Se si pensa che un elenco non è un tipo di rendimento accettabile, poi scambiare Mapper sapplye aggiungere 3 byte.

05AB1E , 11 9 8 byte

Ñε¨àDd<+

-3 byte grazie a @Emigna , cambiando ©d1-®+in Dd<+e ۬ۈin ε¨à.

Solo la mia seconda risposta 05AB1E, quindi può sicuramente essere giocata a golf .

Provalo online.

Spiegazione:

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

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

Provalo online!

Spiegazione:

(>&1)"0 ogni numero è maggiore di 1?

@. in caso contrario, tornare _1:

(%{.@q:)se è 2 o maggiore, dividi %il numero per il primo {.dei fattori primiq:

Japt , 6 byte

Dopo il golf, finì per essere quasi identico alla soluzione di Jonathan e altrettanto breve.

®â¬ÌªJ

Provalo

Spiegazione

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

Python 3 , 62 byte

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

Provalo online!

Perché 0ed 1 range(1,n)è vuoto, quindi il codice valuta max([]+[-1]) = -1. Per i numeri primi, l'unico divisore in [1, n) è 1, che è l'output desiderato.

Cocco , 50 byte

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

Provalo online!

Java 8, 105 103 87 byte

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

Modifica l'input-array invece di restituirne uno nuovo per salvare i byte.

Provalo online.

Spiegazione:

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 byte

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

Provalo online!

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

Buccia , 8 byte

m(|_1→hḊ

Provalo online!

Spiegazione

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]

Attache , 23 byte

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

Provalo online!

29 byte, senza punti: @(Max&-1@Last@ProperDivisors)

24 byte, anche senza punti: @(Max&-1@`@&-2@Divisors)

Questo semplicemente ottiene il penultimo divisore di nquindi ne prende il massimo e -1. Il penultimo elemento in un array con meno di due elementi è niled Max[-1, nil]è -1. @vettorializza semplicemente questa funzione, facendola applicare ad ogni atomo.

Wolfram Language (Mathematica) , 33 byte

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

Provalo online!

R + numbers, 88 79 byte

Grazie ai commenti per alcuni consigli principalmente su come presentare osservazioni.

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

Utilizza il prodotto di tutti i fattori primi tranne il più piccolo e il fatto che il prodotto di elementi di un vettore vuoto sia definito come 1 .

Provalo online!

Brachylog , 10 byte

{fkt|∧_1}ˢ

Provalo online!

La seguente spiegazione è per lo più formulata in modo imperativo per ragioni di brevità e non riflette accuratamente la natura dichiarativa di 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.

Ho deciso di imparare Brachylog in modo da potermi divertire un po 'con il code golf sperando di apprendere un po' del comportamento del Prolog reale attraverso l'osmosi, e mi sto davvero divertendo finora, anche se non sono del tutto sicuro di come i personaggi del controllo dell'esecuzione funzionano.

Stax , 14 13 byte

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

Esegui ed esegui il debug

Spiegazione (non imballata):

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

Pseudocodice all'interno della mappa:

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

Pyth, 12 byte

me+_1f!%dTSt

Provalo qui

Spiegazione

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 byte

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

Provalo online!

Per ogni numero n prendi invece il massimo di (n, 1).
Aggiungi il numero negato all'elenco dei suoi fattori primi (elenco vuoto per 1) e dividi il numero per il primo elemento nell'elenco.

Anche 14 byte

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

Provalo online!

Dividi ogni numero per il primo dei suoi fattori primi. 0 genera un errore di dominio con q:e cerchiamo l'elemento 0 in un elenco vuoto per 1 - anche questo è un errore. Per qualsiasi numero che presenti errori, restituire −1.

Japt , 14 11 8 byte

®/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).

Provalo online!

Rasato quei tre fastidiosi byte grazie a Shaggy .

JavaScript (Node.js) , 61 55 byte

-6 byte grazie a @shaggy

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

Provalo online!

Spiegazione :

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

Questo è ancora per il vecchio codice non ho aggiornato questo.

Anche ES5 amichevole:

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

Utilità Bash + GNU, 49

• 9 byte salvati grazie a @Cowsquack

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

Spiegazione

• factor legge i numeri di input da STDIN, uno per riga e output nel formato <input number>: <space-separated list of prime factors (ascending)>
• sed elabora questo come segue:
  • /:$/c-1 I numeri di input 0 e 1 non hanno fattori primi e vengono sostituiti con -1
  • /: \w+$/c1I numeri con un fattore primo (essi stessi) sono primi. Sostituiscili con1
  • s%: %/%Sostituisci :con /. Questo crea un'espressione aritmetica per dividere il numero di input (non primo) per il suo fattore primo più piccolo per dare il fattore più grande
  • y/ /#/ Rimuovi l'elenco di altri fattori (non necessari) (commentando)
• bc Aritmeticamente valutare e visualizzare

Provalo online!

Python 2 , 61 59 byte

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

Provalo online!

miglioramenti

• 61 a 59 byte di Dennis .

JavaScript (Node.js) , 37 byte

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

Provalo online!

Ricorsivo, overflow dello stack per input di grandi dimensioni

JavaScript (Node.js) , 41 byte

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

Provalo online!

Pari / GP , 37 byte

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

Provalo online!

Racchetta , 105 byte

(λ(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)))))

Provalo online!

Befunge-98 (FBBI) , 39 byte

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

Provalo online!

Termina con il &quando non ci sono più numeri. Ciò causa l'arresto del programma per 60 secondi fino a quando TIO non termina il programma. Questo è inevitabile per Befunge-98, almeno su TIO perché entrambi gli interpreti lo fanno. Dopo aver toccato il gioco, puoi fermare il programma dopo un po 'per vedere cosa verrebbe emesso se attendi il minuto.

In sostanza, per ogni nuovo numero, se è 0, lo trasforma in un 1. Quindi mette un -1 nello stack seguito da un numero che inizia da 1 e conta fino a raggiungere il numero di input, nel qual caso stampa il secondo numero nello stack (-1 per un input di 0 o 1 e il fattore più alto per gli altri). Ogni volta che attraverso il ciclo, aggiungiamo il valore dell'iteratore allo stack dietro di esso if ( input % iterator == 0). Ciò significa che quando arriviamo all'input, non ci resta che buttare via l'iteratore e stampare. Quindi, cancelliamo lo stack con ne torniamo alla funzione di input di lettura.

Potrei espandere la spiegazione in seguito, vedremo ...

Retina 0.8.2 , 33 byte

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

Provalo online! Il link include quei casi di test che non sono troppo lenti. Spiegazione:

%(`

Passa sopra ogni numero di input.

^0|^1$
-1

Casi speciali 0 e 1.

\d+
$*

Converti in unario (non influisce su -1).

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

Sostituisci ogni numero con il suo massimo fattore decimale.

tinylisp , 75 byte

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

Provalo online!(Contiene 4 byte extra per dare un nome alla funzione anonima in modo che possiamo chiamarla nel piè di pagina.)

Ungolfed / spiegazione

Osserva che restituisce 1 come numero primo $n$ e il fattore più grande inferiore a $n$ per composito $n$ può essere combinato per tornare $n/p$ dove $p$ è il più piccolo fattore primo di $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