Desafío:

Dada una matriz de números enteros no negativos en el rango de0 to Infinity , Verifique si todos son números primos o no. (También puede tomar la entrada como una cadena si lo desea)

Entrada:

Entrada: una matriz de números

Salida: la matriz con cada elemento reemplazado por uno de estos:

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

Devuelve -1 (0, 1), 1 (para números primos> = 2) o el factor más alto del número dado (para números no primos)

Ejemplos:

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

La entrada siempre será válida, es decir, consistirá solo en números y no se probarán los decimales. La matriz puede estar vacía, de ser así, devuelva la matriz vacía.

Restricción:

Este es el código de golf, por lo que gana el código más corto en bytes para cada idioma.

LeaderBoard:

Aquí hay un fragmento de pila para generar una tabla de clasificación regular y una descripción general de los ganadores por idioma.

Para asegurarse de que su respuesta se muestre, comience con un título, usando la siguiente plantilla de Markdown:

# Language Name, N bytes

¿Dónde Nestá el tamaño de su envío? Si mejora su puntaje, puede mantener los puntajes antiguos en el título, tachándolos. Por ejemplo:

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

Si desea incluir varios números en su encabezado (por ejemplo, porque su puntaje es la suma de dos archivos o desea enumerar las penalizaciones de la bandera del intérprete por separado), asegúrese de que el puntaje real sea el último número en el encabezado:

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

También puede hacer que el nombre del idioma sea un enlace que luego aparecerá en el fragmento de la tabla de clasificación:

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

ÆḌṪ€o-

Un enlace monádico que acepta una lista de enteros no negativos y retiene una lista de enteros mayores o iguales a -1.

Pruébalo en línea!

¿Cómo?

Tenga en cuenta que:

• Todos los números primos tienen un solo divisor propio (uno)
• Todos los compuestos tienen múltiples divisores propios (uno más los otros)
• Ningún número se tiene como divisor propio
• El átomo de los divisores propios de Jelly ÆḌproduce una lista de divisores propios en orden ascendente
• Cero y uno no tienen divisores propios (no son primos ni compuestos)
• Aplicando el átomo de la cola de Jelly Ṫ, a una lista vacía, se obtiene cero
• Ningún número tiene un divisor propio de cero (y mucho menos ser el máximo)
• Todos los números distintos de cero son verdaderos en Jelly, mientras que cero es 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]

Jalea , 9 8 bytes

Guardado 1 byte gracias a @Dennis

:ÆfṂ€$~~

Pruébalo en línea! o ejecutar todos los casos de prueba

Comentado

Aprovechamos el hecho de que ambos nany nos infconvertimos 0en Jelly cuando NO se les aplica un 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 bytes

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

¡Una solución que usa solo base R, sin bibliotecas! Gracias a Giuseppe por jugar al golf 6 bytes.

Utiliza scanpara leer en una lista de números separados por espacios, %%para identificar cuáles son los factores. vluego contiene un vector de todos los factores en orden ascendente (incluidos 1 yn). Esto tiene la buena propiedad de que cuando revescribimos v, el número que queremos estará en segundo lugar, evitando una llamada costosa lengtho tail(si nera primo, vcontiene n 1, de lo contrario contiene n (factors in descending order) 1).

Ejemplo de salida (enlace TIO aquí ):

> 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 cree que una lista no es un tipo de retorno aceptable, entonces intercambiar Mappor sapplyy añadir 3 bytes.

05AB1E , 11 9 8 bytes

Ñε¨àDd<+

-3 bytes gracias a @Emigna , cambiando ©d1-®+a Dd<+y ۬ۈpara ε¨à.

Solo mi segunda respuesta 05AB1E, por lo que definitivamente se puede jugar al golf .

Pruébalo en línea.

Explicación:

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

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

Pruébalo en línea!

Explicación:

(>&1)"0 ¿Es cada número mayor que 1?

@. si no, regrese _1:

(%{.@q:)si es 2 o mayor, divida %el número por el primero {.de los factores primosq:

Japt , 6 bytes

Después de jugar al golf, terminó siendo casi idéntico y tan corto como la solución de Jonathan.

®â¬ÌªJ

Intentalo

Explicación

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

Python 3 , 62 bytes

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

Pruébalo en línea!

Para 0y 1 range(1,n)está vacío, por lo tanto, el código se evalúa como max([]+[-1]) = -1. Para los números primos, el único divisor en [1, n) es 1, que es la salida deseada.

Coco , 50 bytes

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

Pruébalo en línea!

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

Modifica la matriz de entrada en lugar de devolver una nueva para guardar bytes.

Pruébalo en línea.

Explicación:

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 bytes

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

Pruébalo en línea!

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

Casco , 8 bytes

m(|_1→hḊ

Pruébalo en línea!

Explicación

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]

Adjunto , 23 bytes

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

Pruébalo en línea!

29 bytes, sin puntos: @(Max&-1@Last@ProperDivisors)

24 bytes, también sin puntos: @(Max&-1@`@&-2@Divisors)

Esto simplemente obtiene el penúltimo divisor de, nluego toma el máximo de él y -1. El penúltimo elemento de una matriz con menos de dos elementos es nily Max[-1, nil]es -1. @simplemente vectoriza esta función, haciendo que se aplique a cada átomo.

Wolfram Language (Mathematica) , 33 bytes

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

Pruébalo en línea!

R + numbers, 88 79 bytes

Gracias a los comentarios por algunos consejos principalmente sobre cómo hacer presentaciones.

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

Utiliza el producto de todos los factores primos, excepto el más pequeño, y el hecho de que el producto de los elementos de un vector vacío se define como ser 1.

Pruébalo en línea!

Brachylog , 10 bytes

{fkt|∧_1}ˢ

Pruébalo en línea!

La siguiente explicación se formula principalmente en aras de la brevedad, y no refleja con precisión la naturaleza declarativa 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.

Decidí que aprendería Brachylog para poder divertirme con el golf de código mientras esperaba aprender algo del comportamiento de Prolog real a través de la ósmosis, y realmente lo estoy disfrutando hasta ahora, incluso si no estoy completamente seguro de cómo Los personajes de control de ejecución funcionan.

Stax , 14 13 bytes

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

Ejecutar y depurarlo

Explicación (sin embalaje):

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

Pseudocódigo dentro del mapa:

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

Pyth, 12 bytes

me+_1f!%dTSt

Pruébalo aquí

Explicación

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 bytes

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

Pruébalo en línea!

Por cada número n tome el máximo de (n, 1) en su lugar.
Agregue el número negado a la lista de sus factores primos (lista vacía para 1) y divida el número por el primer elemento de la lista.

También 14 bytes

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

Pruébalo en línea!

Divide cada número por el primero de sus factores primos. 0 genera un error de dominio con q:, y buscamos el elemento 0 en una lista vacía para 1; eso también es un error. Para cualquier número que tenga errores, devuelve -1.

Japt , 14 11 8 bytes

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

Pruébalo en línea!

Afeitó esos tres molestos bytes gracias a Shaggy .

JavaScript (Node.js) , 61 55 bytes

-6 bytes gracias a @shaggy

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

Pruébalo en línea!

Explicación

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

Esto todavía es para el código antiguo que no ha actualizado esto.

ES5 amigable también:

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

Bash + utilidades GNU, 49

• 9 bytes guardados gracias a @Cowsquack

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

Explicación

• factor lee números de entrada de STDIN, uno por línea y salidas en el formato <input number>: <space-separated list of prime factors (ascending)>
• sed procesa esto de la siguiente manera:
  • /:$/c-1 Los números de entrada 0 y 1 no tienen factores primos y se reemplazan con -1
  • /: \w+$/c1Los números con un factor primo (ellos mismos) son primos. Reemplace estos con1
  • s%: %/%Reemplazar :con/ . Esto crea una expresión aritmética para dividir el número de entrada (no primo) por su factor primo más pequeño para dar el factor más grande
  • y/ /#/ Elimine la lista de otros factores (innecesarios) (comentando)
• bc Evaluar y mostrar aritméticamente

Pruébalo en línea!

Python 2 , 61 59 bytes

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

Pruébalo en línea!

Mejoras

• 61 a 59 bytes por Dennis .

JavaScript (Node.js) , 37 bytes

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

Pruébalo en línea!

Recursivo, desbordamiento de pila para entrada grande

JavaScript (Node.js) , 41 bytes

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

Pruébalo en línea!

Pari / GP , 37 bytes

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

Pruébalo en línea!

Raqueta , 105 bytes

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

Pruébalo en línea!

Befunge-98 (FBBI) , 39 bytes

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

Pruébalo en línea!

Termina con el &cuando no hay más números. Esto hace que el programa se detenga durante 60 segundos hasta que TIO finalice el programa. Esto es inevitable para Befunge-98, al menos en TIO porque ambos intérpretes hacen esto. Después de presionar play, puede detener el programa después de un momento para ver qué se generaría si esperara el minuto.

Esencialmente, para cada número nuevo, si es 0, lo convierte en 1. Luego pone un -1 en la pila seguido de un número que comienza desde 1 y cuenta hasta que alcanza el número de entrada, en cuyo caso imprime el segundo número en la pila (-1 para una entrada de 0 o 1, y el factor más alto para otros). Cada vez a través del ciclo, agregamos el valor del iterador a la pila detrás de él if ( input % iterator == 0). Esto significa que cuando lleguemos a la entrada, solo tenemos que tirar el iterador e imprimir. Luego, limpiamos la pila conn y volvemos a la función de entrada de lectura.

Puedo ampliar la explicación más tarde, ya veremos ...

Retina 0.8.2 , 33 bytes

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

Pruébalo en línea! Link incluye aquellos casos de prueba que no son demasiado lentos. Explicación:

%(`

Pase sobre cada número de entrada.

^0|^1$
-1

Caso especial 0 y 1.

\d+
$*

Convierte a unario (no afecta a -1).

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

Reemplace cada número con su mayor factor propio en decimal.

tinylisp , 75 bytes

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

Pruébalo en línea! (Contiene 4 bytes adicionales para dar un nombre a la función anónima para que podamos llamarla en el pie de página).

Ungolfed / explicación

Observe que devolver 1 para primo $n$ y el mayor factor menor que $n$ para composite $n$ se puede combinar para volver $n/p$ dónde $p$ es el factor primo más pequeño 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