Основний чи найвищий чинник


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:

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

Щоб переконатися, що ваша відповідь відображається, будь ласка, почніть свою відповідь із заголовка, використовуючи наступний шаблон 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


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

@ Joking: для нескінченності потрібно виводити всі числа до нескінченності. Це тільки для вас, і ви також повинні переконатися, що він не вичерпується і нічого. JK: Помилка тайм-ауту - це найвірогідніша річ, яку ви отримаєте за нескінченність

4
просто хотів зазначити, що в "Якщо це просте число більше 1", більше 1 дійсно не потрібно, тому що прості числа завжди перевищують 1
Іво Бекерс

5
Визначте найвищий коефіцієнт. Чи повинен я повернути сам номер? Найвищий дільний прайм? Найвищий фактор, який не є сам собою?
Нісса

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

Відповіді:


9

Желе ,  7 6 байт

ÆḌṪ€o-

Монадічне посилання, що приймає список невід’ємних цілих чисел та отримує список цілих чисел, більший або рівний -1.

Спробуйте в Інтернеті!

Як?

Зауважте, що:

  • Усі праймери мають один власний дільник (один)
  • Усі композити мають кілька правильних дільників (один плюс інші)
  • Жодне число не є власним дільником
  • Атом Jelly's get-pravil-divisors ÆḌ, дає список правильних дільників у порядку зростання
  • Нуль і один не мають належних дільників (вони не є простими, ні складовими)
  • Застосовуючи хвостовий атом Джеллі , до порожнього списку дається нуль
  • Жодне число не має належного дільника нуля (не кажучи вже про максимальне)
  • Усі ненульові числа є верними в желе, тоді як нульові - фальси

ÆḌṪ€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в Jelly, коли побітно НЕ застосовується до них.

:Æ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? приємна відповідь btw

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

@Денніс Ах! $це те, що я шукав. :) Спасибі!
Арнольд

7

R, 68 62 байт

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<+
Емінья

Набагато краще, ніж мій 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

Attache , 23 байти

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

Спробуйте в Інтернеті!

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

24 байти, також безкоштовно: @(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.

Я вирішив дізнатися Брахілог, щоб я міг повеселитися з кодовим гольфом, сподіваючись дізнатися про поведінку фактичного Прологу через осмос, і мені це дуже подобається поки що, навіть якщо я не зовсім впевнений, як робота символів управління виконанням.


2
"Мабуть, є якась очевидна причина ∨ тут не працюватиме, але я не знаю, що це" -> Ви можете використовувати .∨замість |∧(я здогадуюсь, що ви забули .), але це те саме число байтів. Ласкаво просимо до PPCG (а Брахілог важливіше: p) до речі!
Фаталізувати

Ah, of course! Thanks.
Unrelated String

You can ask these kinds of questions on Brachylog in the Brachylog chat room
Fatalize

1

Stax, 14 13 bytes

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

Run and debug it

Explanation (unpacked):

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

Pseudocode inside map:

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

1

Pyth, 12 bytes

me+_1f!%dTSt

Try it here

Explanation

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 bytes

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

Try it online!

For every number n take the maximum of (n,1) instead.
Append the negated number to the list of its prime factors (empty list for 1), and divide the number by the first item in the list.

Also 14 bytes

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

Try it online!

Divide every number by the first of its prime factors. 0 raises a domain error with q:, and we look for the 0th item in an empty list for 1 — that’s an error as well. For any number that errors, return −1.


Very nice solutions!
Galen Ivanov

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

Try it online!

Shaved off those three pesky bytes thanks to Shaggy.


You don't need to filter the primes - k returns the prime factors of N - so this becomes 8 bytes: ®/k v)ªÉ
Shaggy

@Shaggy Thanks, didn't know it only returns the prime factors since the method docs don't say that.
Nit

1
Oh, yeah, forgot that. Been meaning to submit a PR for that for a while; will do so shortly.
Shaggy

1

JavaScript (Node.js), 6155 bytes

-6 bytes thanks to @shaggy

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

Try it online!


Explanation :

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

This is still for old code haven't updated this.

ES5 friendly as well:

 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 : thanks
Muhammad Salman

1

Bash + GNU utilities, 49

  • 9 bytes saved thanks to @Cowsquack
factor|sed '/:$/c-1
/: \w+$/c1
s%: %/%
y/ /#/'|bc

Explanation

  • factor reads input numbers from STDIN, one per line and outputs in the format <input number>: <space-separated list of prime factors (ascending)>
  • sed processes this as follows:
    • /:$/c-1 The input numbers 0 and 1 have no prime factors and are replaced with -1
    • /: \w+$/c1 Numbers with one prime factor (themselves) are prime. Replace these with 1
    • s%: %/% Replace : with /. This builds an arithmetic expression to divide the (non-prime) input number by its smallest prime factor to give the largest factor
    • y/ /#/ Remove the list of other (unneeded) factors (by commenting out)
  • bc Arithmetically evaluate and display

Try it online!


1
You might be able to drop the -r, and for the first two s's you can use /regex/cvalue to golf a byte, simplifying this regex further can save more, and you can save a byte in the last two regex's by only replacing the : with the /, and then commenting out the unwanted part, like so, tio.run/##JYlBCoMwFET3c4qABhdSfuZ/…
user41805

@Cowsquack very good - thanks!
Digital Trauma





1

Befunge-98 (FBBI), 39 bytes

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

Try it online!

Ends with the & 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.


Essentially, for every new number, if it is 0, it turns it into a 1. Then it puts a -1 onto the stack followed by a number that starts from 1 and counts up until it reaches the input number, in which case it prints out the second number on the stack (-1 for an input of 0 or 1, and the highest factor for others). Every time through the loop, we add the value of the iterator to the stack behind it if (input % iterator == 0). This means that when we get to the input, we just have to throw away the iterator and print. Then, we clear the stack with n and return to the read input function.

I may expand of the explanation later, we'll see...


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.