Desafio:

Dada uma matriz de números inteiros não negativos no intervalo de0 to Infinity , verifique se todos são primos ou não. (Você pode receber a entrada como uma string também, se desejar)

Entrada:

Entrada: uma matriz de números

Saída: a matriz com todos os elementos substituídos por um destes:

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

Retorne -1 (0, 1), 1 (para números primos> = 2) ou o fator mais alto do número fornecido (para números não primos)

Exemplos:

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

A entrada sempre será válida, ou seja, consistirá apenas de números e decimais não testados. A matriz pode estar vazia; nesse caso, retorne a matriz vazia.

Restrição:

Este é o código-golfe, pelo que o código mais curto em bytes para cada idioma vence.

Entre os melhores :

Aqui está um snippet de pilha para gerar uma classificação regular e uma visão geral dos vencedores por idioma.

Para garantir que sua resposta seja exibida, inicie-a com um título, usando o seguinte modelo de remarcação:

# Language Name, N bytes

onde Nestá o tamanho do seu envio. Se você melhorar sua pontuação, poderá manter as pontuações antigas no título, identificando-as. Por exemplo:

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

Se você quiser incluir vários números no cabeçalho (por exemplo, porque sua pontuação é a soma de dois arquivos ou você deseja listar as penalidades do sinalizador de intérpretes separadamente), verifique se a pontuação real é o último número no cabeçalho:

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

Você também pode transformar o nome do idioma em um link que será exibido no snippet do placar de líderes:

# [><>](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éia ,  7 6 bytes

ÆḌṪ€o-

Um link monádico que aceita uma lista de números inteiros não negativos e retura uma lista de números inteiros maior ou igual a -1.

Experimente online!

Quão?

Observe que:

• Todos os números primos têm um único divisor próprio (um)
• Todos os compósitos têm vários divisores adequados (um mais os outros)
• Nenhum número tem como divisor próprio
• O átomo de divisores apropriados de Jelly ÆḌproduz uma lista de divisores adequados em ordem crescente
• Zero e um não possuem divisores adequados (eles não são primos nem compostos)
• A aplicação do átomo de cauda de Jelly,, Ṫem uma lista vazia gera zero
• Nenhum número possui um divisor adequado de zero (e muito menos o máximo)
• Todos os números diferentes de zero são verdadeiros em Jelly, enquanto zero é 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éia , 9 8 bytes

Guardado 1 byte graças a @Dennis

:ÆfṂ€$~~

Experimente online! ou execute todos os casos de teste

Comentado

Aproveitamos o fato de que ambos nane nos inftornamos 0em Jelly quando um NOT bit a bit é aplicado a eles.

:Æ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 bytes de 62

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

Uma solução usando apenas a base R, sem bibliotecas! Agradecimentos a Giuseppe por jogar fora 6 bytes.

Usa scanpara ler em uma lista de números separados por espaço, %%para identificar quais são os fatores. ventão contém um vetor de todos os fatores em ordem crescente (incluindo 1 e n). Isso tem a propriedade legal de que, quando revinvertemos v, o número que queremos estará em segundo lugar, evitando uma ligação cara a lengthou tail(se nera primo, vcontém n 1, ou então contém n (factors in descending order) 1).

Exemplo de saída (link TIO aqui ):

> 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 você acha que uma lista não é um tipo de retorno aceitável, troque Mappor sapplye adicione 3 bytes.

05AB1E , 11 9 8 bytes

Ñε¨àDd<+

-3 bytes graças a @Emigna , alterando ©d1-®+para Dd<+e ۬ۈpara ε¨à.

Somente minha segunda resposta 05AB1E, então definitivamente pode ser jogada no golfe .

Experimente online.

Explicação:

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

Experimente online!

Explicação:

(>&1)"0 cada número é maior que 1?

@. caso contrário, retorne _1:

(%{.@q:)se for 2 ou maior, divida %o número pelo primeiro {.dos fatores primosq:

Japonês , 6 bytes

Depois de jogar golfe, acabou sendo quase idêntico à solução de Jonathan e tão curta quanto ela.

®â¬ÌªJ

Tente

Explicação

®          :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]

Experimente online!

Para 0e 1 range(1,n)está vazio, o código é avaliado como max([]+[-1]) = -1. Para números primos, o único divisor em [1, n) é 1qual é a saída desejada.

Coco , 50 bytes

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

Experimente online!

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 a matriz de entrada em vez de retornar uma nova para salvar bytes.

Experimente online.

Explicação:

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

Experimente 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

Casca , 8 bytes

m(|_1→hḊ

Experimente online!

Explicação

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]

Anexo , 23 bytes

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

Experimente online!

29 bytes, sem ponto: @(Max&-1@Last@ProperDivisors)

24 bytes, também sem ponto: @(Max&-1@`@&-2@Divisors)

Isso simplesmente obtém o penúltimo divisor de nentão leva o máximo dele e -1. O penúltimo elemento em uma matriz com menos de dois elementos é nile Max[-1, nil]é -1. @simplesmente vectoriza essa função, aplicando-a a cada átomo.

Wolfram Language (Mathematica) , 33 bytes

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

Experimente online!

R + numbers, 88 bytes

Obrigado aos comentários de alguns conselhos, principalmente sobre como fazer envios.

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

Usa o produto de todos os fatores primos, exceto o menor, e o fato de que o produto dos elementos de um vetor vazio é definido como sendo 1.

Experimente online!

Braquilog , 10 bytes

{fkt|∧_1}ˢ

Experimente online!

A explicação a seguir é redigida principalmente de modo imperativo por questões de brevidade e não reflete com precisão a natureza 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.

Decidi aprender o Brachylog para me divertir um pouco com o código-golfe, na esperança de aprender um pouco do comportamento do Prolog real por osmose, e estou gostando muito até agora, mesmo que não tenha certeza de como caracteres de controle de execução funcionam.

Stax , 14 13 bytes

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

Execute e depure

Explicação (sem embalagem):

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 do mapa:

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

Pitão, 12 bytes

me+_1f!%dTSt

Experimente aqui

Explicação

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:,-)@>.]

Experimente online!

Para cada número n, use o máximo de (n, 1).
Anexe o número negado à lista de seus fatores primos (lista vazia para 1) e divida o número pelo primeiro item da lista.

Também 14 bytes

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

Experimente online!

Divida cada número pelo primeiro de seus fatores primos. 0 gera um erro de domínio com q:, e procuramos o 0º item em uma lista vazia para 1 - isso também é um erro. Para qualquer número que erros, retorne -1.

Japonês , 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).

Experimente online!

Raspou esses três bytes traquinas graças a Shaggy .

JavaScript (Node.js) , 61 55 bytes

-6 bytes graças a @shaggy

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

Experimente online!

Explicação:

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

Ainda é para código antigo que não atualizou isso.

ES5 amigável também:

 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ários Bash + GNU, 49

• 9 bytes salvos graças a @Cowsquack

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

Explicação

• factor lê os números de entrada do STDIN, um por linha e sai no formato <input number>: <space-separated list of prime factors (ascending)>
• sed processa da seguinte maneira:
  • /:$/c-1 Os números de entrada 0 e 1 não possuem fatores primos e são substituídos por -1
  • /: \w+$/c1Números com um fator primo (eles mesmos) são primos. Substitua-os por1
  • s%: %/%Substitua :por /. Isso cria uma expressão aritmética para dividir o número de entrada (não primo) pelo menor fator primo para gerar o maior fator
  • y/ /#/ Remova a lista de outros fatores (desnecessários) (comentando)
• bc Avaliar e exibir aritmeticamente

Experimente online!

Python 2 , 61 59 bytes

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

Experimente online!

Melhorias

• 61 a 59 bytes de Dennis .

JavaScript (Node.js) , 37 bytes

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

Experimente online!

Excesso de pilha recursivo para entrada grande

JavaScript (Node.js) , 41 bytes

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

Experimente online!

Pari / GP , 37 bytes

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

Experimente online!

Raquete , 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)))))

Experimente online!

Befunge-98 (FBBI) , 39 bytes

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

Experimente online!

Termina com &quando não houver mais números. Isso faz com que o programa pare por 60 segundos até que o TIO termine o programa. Isso é inevitável para o Befunge-98, pelo menos no TIO, porque ambos os intérpretes fazem isso. Depois de pressionar o play, você pode parar o programa depois de um pouco para ver o que seria produzido se você esperasse um minuto.

Essencialmente, para cada novo número, se for 0, ele o transforma em 1. Em seguida, coloca -1 na pilha, seguido por um número que começa em 1 e conta até atingir o número de entrada; nesse caso, ele imprime o segundo número na pilha (-1 para uma entrada de 0 ou 1 e o fator mais alto para outras). Sempre que o loop é adicionado, adicionamos o valor do iterador à pilha atrás dele, se ( input % iterator == 0). Isso significa que, quando chegamos à entrada, precisamos apenas jogar fora o iterador e imprimir. Em seguida, limpamos a pilha comn e retornamos à função de entrada de leitura.

Posso expandir a explicação mais tarde, veremos ...

Retina 0.8.2 , 33 bytes

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

Experimente online! O link inclui os casos de teste que não são muito lentos. Explicação:

%(`

Faça um loop sobre cada número de entrada.

^0|^1$
-1

Caso especial 0 e 1.

\d+
$*

Converter em unário (não afeta -1).

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

Substitua cada número pelo maior fator adequado em decimal.

tinylisp , 75 bytes

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

Experimente online!(Contém 4 bytes extras para dar um nome à função anônima, para que possamos chamá-la no rodapé.)

Ungolfed / explicação

Observe que retornando 1 para prime $n$ e o maior fator menor que $n$ para compósito $n$ pode ser combinado em retornar $n/p$ Onde $p$ é o menor fator primordial 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