Вызов:

Учитывая массив неотрицательных целых чисел в диапазоне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]

Замечания:

Ввод всегда будет действительным, то есть он будет состоять только из цифр, а десятичные числа не проверяются. Массив может быть пустым, если так, вернуть пустой массив.

Ограничение:

Это код-гольф, поэтому выигрывает самый короткий код в байтах для каждого языка.

LeaderBoard:

Вот фрагмент стека, который генерирует как регулярную таблицу лидеров, так и обзор победителей по языкам.

Чтобы убедиться, что ваш ответ обнаружен, начните его с заголовка, используя следующий шаблон уценки:

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

Попробуйте онлайн!

Как?

Обратите внимание, что:

• Все простые числа имеют один правильный делитель (один)
• Все композиты имеют несколько правильных делителей (один плюс другие)
• Номер не имеет себя как собственно делителем
• Атом желе-делителя-делителя, ÆḌ выдает список правильных делителей в порядке возрастания
• У нуля и единицы нет собственных делителей (они не являются ни простыми, ни составными)
• Применяя атом хвоста желе, Ṫ к пустому списку дает ноль
• Ни у одного числа нет подходящего делителя нуля (не говоря уже о максимальном)
• Все ненулевые числа истинны в желе, в то время как ноль фальси

ÆḌṪ€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 байт

Сохранено 1 байт благодаря @Dennis

:Æ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 68 байт

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

Решение с использованием только базы R, без библиотек! Спасибо Джузеппе за игру в гольф 6 байтов.

Используется scanдля чтения в списке разделенных пробелами чисел, %%чтобы определить, какие факторы. vзатем содержит вектор всех факторов в порядке возрастания (включая 1 и n). Это имеет приятное свойство: когда мы revошибаемся v, номер, который мы хотим, будет на втором месте, избегая дорогого вызова lengthили 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]))

Попробуйте онлайн!

Java 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 байт, pointfree: @(Max&-1@Last@ProperDivisors)

24 байта, также pointfree: @(Max&-1@`@&-2@Divisors)

Это просто получает второй до последнего делитель, nзатем берет его максимум и -1. Вторым по порядку элементом в массиве с менее чем двумя элементами является nilи Max[-1, nil]есть -1. @просто векторизует эту функцию, применяя ее к каждому атому.

Wolfram Language (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 .

Попробуйте онлайн!

Брахилог , 10 байт

{fkt|∧_1}ˢ

Попробуйте онлайн!

Следующее объяснение в основном сформулировано для краткости и не совсем точно отражает декларативный характер Брахилога.

{          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, чтобы я мог немного поиграть с кодовым гольфом, в то же время надеясь изучить некоторые особенности реального Пролога с помощью осмоса, и я до сих пор наслаждаюсь им, даже если я не совсем уверен, как символы управления выполнением работы.

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:, и мы ищем 0-й элемент в пустом списке для 1 - это тоже ошибка. Для любого числа с ошибками верните -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).

Попробуйте онлайн!

Скинули эти три надоедливых байта благодаря Шегги .

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

• 9 байтов сохранено благодаря @Cowsquack

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]

Попробуйте онлайн!

улучшения

• От 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'))

Попробуйте онлайн!

Пари / ГП , 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

Попробуйте онлайн!

Заканчивается с & when there are no more numbers. This causes the program to stall for 60 seconds until TIO ends the program. This is unavoidable for Befunge-98, at least on TIO because both interpreters do this. After hitting play, you can stop the program after a bit in order to see what would be output if you did wait the minute.

По сути, для каждого нового числа, если оно равно 0, оно превращает его в 1. Затем оно помещает -1 в стек, за которым следует число, которое начинается с 1 и продолжается до тех пор, пока не достигнет входного числа, в этом случае печатает второе число в стеке (-1 для ввода 0 или 1 и самый высокий коэффициент для других). Каждый раз в цикле мы добавляем значение итератора в стек позади него if ( input % iterator == 0). Это означает, что когда мы попадаем на вход, нам просто нужно выбросить итератор и напечатать. Затем мы очищаем стекn and return to the read input function.

Я могу расширить объяснение позже, посмотрим ...

Retina 0.8.2, 33 bytes

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

Try it online! Link includes those test cases that aren't too slow. Explanation:

%(`

Loop over each input number.

^0|^1$
-1

Special-case 0 and 1.

\d+
$*

Convert to unary (doesn't affect -1).

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

Replace each number with its largest proper factor in decimal.

tinylisp, 75 bytes

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

Try it online! (Contains 4 extra bytes to give the anonymous function a name so we can call it in the footer.)

Ungolfed/explanation

Observe that returning 1 for prime $n$ and the largest factor less than $n$ for composite $n$ can be combined into returning $n/p$ where $p$ is the smallest prime factor of $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