挑战：

给定一系列非负整数，范围为0 to Infinity，则检查所有数字是否都是质数。（如果需要，您也可以将输入作为字符串输入）

输入：

输入：数字数组

输出：每个元素替换为以下元素之一的数组：

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

返回-1（0，1），1（对于素数> = 2）或给定数的最高因数（对于非素数）

例子：

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

注意：

输入将始终是有效的，即它将仅由数字和未经测试的小数组成。该数组可以为空，如果是，则返回空数组。

限制：

这是代码高尔夫球，因此每种语言的最短代码（以字节为单位）获胜。

排行榜：

这是一个堆栈片段，用于按语言生成常规排行榜和获胜者概述。

为了确保您的答案显示出来，请使用以下Markdown模板以标题开头。

# Language Name, N bytes

N您提交的文件大小在哪里。如果您提高了分数，可以将旧分数保留在标题中，方法是将它们打掉。例如：

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

如果您想在标头中包含多个数字（例如，因为您的分数是两个文件的总和，或者您想单独列出解释器标志罚分），请确保实际分数是标头中的最后一个数字：

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

您还可以将语言名称设置为链接，然后该链接将显示在页首横幅代码段中：

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

果冻， 7 6 字节

ÆḌṪ€o-

单链链接，该列表接受非负整数列表并重现大于或等于-1的整数列表。

在线尝试！

怎么样？

注意：

• 所有素数都有一个适当的除数（一个）
• 所有复合材料都具有多个适当的除数（一个除数外）
• 没有数字本身可以作为适当的除数
• Jelly的get-proper-divisors原子，ÆḌ以升序产生一系列适当的除数
• 零和一没有适当的除数（它们既不是素数，也不是复合数）
• 将Jelly的尾原子（Ṫ）应用于空列表将产生零
• 没有数字具有零的适当除数（更不用说是最大的除数）
• 在Jelly中，所有非零数字都是真实的，而零是虚假的

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

果冻，9 8字节

@Dennis节省了1个字节

:ÆfṂ€$~~

在线尝试！或运行所有测试用例

已评论

我们采取的事实上，这两个优势，nan并且inf成为0当按位非被应用到他们的果冻。

:Æ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字节

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

仅使用基本R，不使用库的解决方案！感谢Giuseppe高尔夫球了6个字节。

用于scan读取空格分隔的数字列表，%%以识别哪些因素。v然后包含所有因子按升序排列的向量（包括1和n）。它具有很好的属性，当我们reverse时v，我们想要的数字将排在第二位，从而避免了对lengthor 的昂贵调用tail（如果n是质数，则v包含n 1，否则包含n (factors in descending order) 1）。

输出示例（此处为 TIO链接）：

> 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

如果你认为一个列表不是一个可接受的返回类型，然后换出Map的sapply，并添加3个字节。

05AB1E，11 9 8 字节

Ñε¨àDd<+

-3字节由于@Emigna，改变©d1-®+到Dd<+和۬ۈ到ε¨à。

只有我的第二个05AB1E答案，因此绝对可以打高尔夫球。

在线尝试。

说明：

Ñ           # 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个字节

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

在线尝试！

说明：

(>&1)"0 每个数字都大于1吗？

@. 如果没有，返回 _1:

(%{.@q:)如果等于或大于2，%则将数字除以第一个{.素数q:

Japt，6个字节

打完高尔夫球后，结果几乎和乔纳森的解决方案一样短。

®â¬ÌªJ

尝试一下

说明

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

Python 3，62个字节

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

在线尝试！

对于0和1 range(1,n)为空，因此代码的计算结果为max([]+[-1]) = -1。对于质数，[1，n）中唯一的除数是1，这是所需的输出。

椰子，50字节

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

在线尝试！

爪哇8，105个 103 87字节

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

修改输入数组，而不是返回新的数组以节省字节。

在线尝试。

说明：

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字节

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

在线尝试！

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

外壳，8字节

m(|_1→hḊ

在线尝试！

说明

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]

随员，23字节

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

在线尝试！

29个字节，无点： @(Max&-1@Last@ProperDivisors)

24个字节，也没有点： @(Max&-1@`@&-2@Divisors)

这仅获得倒数第二的除数，n然后取其最大值和-1。少于两个元件的第二到最后一个元素中的阵列是nil，和Max[-1, nil]是-1。@只需向量化此函数，使其适用于每个原子。

Wolfram语言（Mathematica），33个字节

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

在线尝试！

R + numbers，88 79字节

感谢这些评论，这些评论主要是关于如何提交的一些建议。

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

使用除最小因子以外的所有素因子的乘积，以及将空向量的元素乘积定义为 1。

在线尝试！

Brachylog，10个字节

{fkt|∧_1}ˢ

在线尝试！

为了简洁起见，以下解释主要是命令式的，不能准确反映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.

我决定学习Brachylog，这样我就可以通过代码高尔夫获得一些乐趣，同时希望通过渗透学习一些实际Prolog的行为，到目前为止，我还是很享受的，即使我不确定如何执行控制字符起作用。

Stax，14 13 字节

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

运行并调试

说明（未包装）：

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

映射内的伪代码：

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

Pyth，12个字节

me+_1f!%dTSt

在这里尝试

说明

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个字节

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

在线尝试！

对于每个数字n取最大值（n，1）代替。
将负数添加到其主要因子列表（空列表为1），然后将其除以列表中的第一项。

也是14个字节

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

在线尝试！

将每个数字除以第一个素数。0引发域错误q:，我们在空列表中寻找1的第0个项目-这也是一个错误。对于任何错误的数字，返回-1。

Japt，14 11 8字节

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

在线尝试！

多亏Shaggy才把这三个讨厌的字节切掉了。

JavaScript（Node.js），61 55字节

-6个字节，感谢@shaggy

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

在线尝试！

说明：

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

这仍然是针对旧代码的，尚未更新。

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

Bash + GNU实用程序，49

• @Cowsquack节省了9个字节

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

说明

• factor 从STDIN读取输入数字，每行一个，并以以下格式输出 <input number>: <space-separated list of prime factors (ascending)>
• sed 处理如下：
  • /:$/c-1 输入数字0和1没有素数，并被替换为 -1
  • /: \w+$/c1具有一个质数因子（本身）的数字是质数。替换为1
  • s%: %/%替换:为/。这将构建一个算术表达式，以将（非素数）输入数除以最小的素数因子得到最大的因子
  • y/ /#/ 删除其他（不需要）因素的列表（通过注释掉）
• bc 算术评估和显示

在线尝试！

Python 2， 61 59个字节

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

在线尝试！

改进之处

• Dennis的 61到59字节。

JavaScript（Node.js），37字节

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

在线尝试！

递归，堆栈溢出，用于大输入

JavaScript（Node.js），41字节

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

在线尝试！

Pari / GP，37个字节

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

在线尝试！

球拍，105字节

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

在线尝试！

Befunge-98（FBBI），39个字节

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

在线尝试！

以结束 &当没有更多数字时，以。这将导致程序停顿60秒，直到TIO结束程序。对于Befunge-98来说，这是不可避免的，至少在TIO上是这样，因为两个口译员都这样做。按下播放键后，您可以稍稍停止该程序，以查看如果等待一分钟会输出什么。

本质上，对于每个新数字，如果为0，则将其变为1。然后将-1放入堆栈，然后是一个从1开始并一直计数到输入数字的数字，在这种情况下，它将打印出堆栈中的第二个数字（-1表示输入0或1，其他表示最大的因数）。每次循环时，如果（input % iterator == 0），我们都会将迭代器的值添加到它后面的堆栈中。这意味着当我们进入输入时，我们只需要丢弃迭代器并打印即可。然后，我们用n并返回读取输入功能。

稍后我会扩展解释，我们将看到...

视网膜0.8.2，33字节

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

在线尝试！链接包括那些不太慢的测试用例。说明：

%(`

遍历每个输入数字。

^0|^1$
-1

特殊情况0和1。

\d+
$*

转换为一元制（不影响-1）。

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

将每个数字替换为其最大的适当系数（十进制）。

tinylisp，75个字节

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

在线尝试！（包含4个额外的字节来为匿名函数命名，以便我们可以在页脚中对其进行调用。）

松开/解释

观察返回1为素数 $n$ 最大的因素小于 $n$ 用于复合材料 $n$ 可以合并成返回 $n/p$ 哪里 $p$ 是...的最小素数 $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