Главный или самый высокий фактор


14

Вызов:

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


2
Я настоятельно рекомендую использовать Песочницу для будущих вопросов, чтобы оставить отзыв по вопросам перед их публикацией
Джо Кинг,

@Joking: для бесконечности вы должны вывести все числа до бесконечности. Это только для вас, и вы также должны убедиться, что это не время или что-то еще. JK: ошибка времени ожидания является наиболее вероятной вещью, которую вы получите за бесконечность

4
просто хотел отметить, что в «Если это простое число больше 1», больше 1 действительно не нужно, потому что простые числа всегда больше 1
Иво Беккерс

5
Определите самый высокий коэффициент. Должен ли я вернуть сам номер? Высшее делимое простое число? Самый высокий фактор, который не сам по себе?
Nissa

2
Я предполагаю, что наши программы должны работать только для целых чисел вплоть до максимального целочисленного размера выбранного языка (для тех, которые не поддерживают произвольно большие целые числа)
JDL

Ответы:


9

Желе ,  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]

8

Желе , 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)

3
Вы не использовали JavaScript в этот раз? хороший ответ кстати

3
Мне очень нравится ~~. :ÆfṂ€$~~сохраняет байт, удаляя вспомогательную ссылку.
Деннис

@ Денис Ах! $это то, что я искал. :) Благодарность!
Арно

7

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 байта.



хорошо - не думал инициализировать с!
JDL

6

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]

1
Dd<+должен работать вместо ©d1-®+. Вам также не нужно, так ïкак они все еще целые. Вы могли бы иметь это в нижнем колонтитуле для более приятного взгляда, хотя.
Эминья

@ Emigna Ах, 1-вместо того , чтобы быть <довольно глупым .. Спасибо за Dвместо ©...®! И я действительно поместил ïнижний колонтитул сейчас.
Кевин Круйссен

1
Или еще лучше:Ñε¨àDd<+
Emigna

Гораздо лучше, чем мой 12-байт.
Волшебная Урна Осьминога


4

Japt , 6 байт

После игры в гольф он оказался почти таким же коротким, как и решение Джонатана.

®â¬ÌªJ

Попытайся


объяснение

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

Сохранить байт с-m
Оливер

3

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

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


3

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)

3

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


3

Атташе , 23 байта

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

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

29 байт, pointfree: @(Max&-1@Last@ProperDivisors)

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

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



2

R + numbers, 88 79 байт

Спасибо за комментарии за некоторые советы, в основном о том, как делать представления.

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

Использует произведение всех простых факторов, кроме наименьшего, и тот факт, что произведение элементов пустого вектора определено как 1 .

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


1
сохраняет байты, чтобы пропустить libraryвызов и использовать numbers::primeFactorsнапрямую.
JDL

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

2

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


2
«Возможно, есть какая-то очевидная причина - здесь не сработает, но я не знаю, что это такое» -> Вы можете использовать .∨вместо |∧(я полагаю, вы забыли .), но это тот же счетчик байтов. Добро пожаловать в PPCG (и Brachylog, что более важно: р), кстати!
Роковая

Ах, конечно! Благодарю.
Несвязанная Строка

Вы можете задать такие вопросы о Brachylog в чате Brachylog
Fatalize

1

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

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.

1

J , 14 байт

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

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

Для каждого числа n возьмите максимум (n, 1).
Добавьте отрицательный номер к списку его простых факторов (пустой список для 1) и разделите число на первый элемент в списке.

Также 14 байтов

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

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

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

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

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


Вам не нужно фильтровать простые числа - kвозвращает основные факторы N- так что это становится 8 байтов:®/k v)ªÉ
Shaggy

@ Shaggy Спасибо, я не знал, что он возвращает только основные факторы, так как методические документы не говорят этого.
Нить

1
Ах да, забыл это. Имел в виду, чтобы представить PR для этого на некоторое время; сделаю это в ближайшее время.
Лохматый

1

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


@Shaggy: спасибо
Мухаммед Салман

1

Утилиты 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 Арифметическая оценка и отображение

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


1
Возможно, вы сможете отбросить -r, и для первых двух sвы можете использовать /regex/cvalueдля игры в гольф байт, дальнейшее упрощение этого регулярного выражения может сэкономить больше, и вы можете сохранить байт в последних двух регулярных выражениях, только заменив их :на /, и затем комментируя нежелательную часть, вот так, tio.run/##JYlBCoMwFET3c4qABhdSfuZ/…
Kritixi Lithos

@ Cowsquack очень хорошо - спасибо!
Цифровая травма





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.

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


0

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.


0

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
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.