Faktor prima atau tertinggi


14

Tantangan:

Diberikan larik angka bilangan bulat non-negatif dalam kisaran0 to Infinity , Periksa apakah semuanya bilangan prima atau tidak. (Anda dapat mengambil input sebagai string juga jika Anda mau)

Memasukkan:

Input: Array angka

Output: Array dengan setiap elemen diganti oleh salah satu dari ini:

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

Mengembalikan -1 (0, 1), 1 (untuk bilangan prima> = 2) atau faktor tertinggi dari angka yang diberikan (untuk bukan bilangan prima)

Contoh:

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

catatan:

Input akan selalu valid, yaitu hanya terdiri dari angka dan desimal yang tidak diuji. Array dapat kosong, jika demikian, kembalikan array kosong.

Larangan:

Ini adalah sehingga kode terpendek dalam byte untuk setiap bahasa menang.

Papan Kepemimpinan:

Berikut ini adalah Stack Snippet untuk menghasilkan leaderboard biasa dan gambaran umum pemenang berdasarkan bahasa.

Untuk memastikan bahwa jawaban Anda muncul, silakan mulai jawaban Anda dengan tajuk utama, menggunakan templat Penurunan harga berikut:

# Language Name, N bytes

di mana Nukuran kiriman Anda. Jika Anda meningkatkan skor Anda, Anda dapat menyimpan skor lama di headline, dengan mencoretnya. Contohnya:

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

Jika Anda ingin memasukkan beberapa angka dalam tajuk Anda (mis. Karena skor Anda adalah jumlah dari dua file atau Anda ingin membuat daftar hukuman penterjemah secara terpisah), pastikan bahwa skor sebenarnya adalah angka terakhir di tajuk:

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

Anda juga dapat membuat tautan nama bahasa yang kemudian akan muncul di cuplikan papan peringkat:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes


2
Saya sangat merekomendasikan menggunakan Sandbox untuk pertanyaan di masa mendatang, untuk memberikan umpan balik tentang pertanyaan sebelum mempostingnya
Jo King

@ Bercanda: untuk tak terhingga Anda harus menampilkan semua angka hingga tak terhingga. Ini hanya untuk Anda dan Anda juga harus memastikan tidak ada waktu habis atau apa pun. JK: kesalahan waktu habis adalah hal yang paling mungkin Anda dapatkan untuk infinity

4
hanya ingin mencatat bahwa dalam "Jika bilangan prima lebih besar dari 1" lebih besar dari 1 sebenarnya tidak perlu karena bilangan prima selalu lebih besar dari 1
Ivo Beckers

5
Tentukan faktor tertinggi. Haruskah saya mengembalikan nomor itu sendiri? Perdana dibagi tertinggi? Faktor tertinggi yang bukan dirinya sendiri?
Nissa

2
Saya menganggapnya sebagai program kami hanya diharuskan untuk bekerja untuk bilangan bulat hingga ukuran bilangan bulat maks bahasa yang kami pilih (bagi mereka yang tidak memiliki dukungan untuk bilangan bulat besar yang sewenang-wenang)
JDL

Jawaban:


9

Jelly ,  7 6 byte

ÆḌṪ€o-

Tautan monadik yang menerima daftar bilangan bulat non-negatif dan menyimpan daftar bilangan bulat yang lebih besar dari atau sama dengan -1.

Cobalah online!

Bagaimana?

Perhatikan bahwa:

  • Semua bilangan prima memiliki pembagi tunggal yang tepat (satu)
  • Semua komposit memiliki beberapa pembagi yang tepat (satu ditambah yang lain)
  • Tidak ada angka yang memiliki dirinya sebagai pembagi yang tepat
  • Atom pembagi get-proper-Jelly ÆḌ,, menghasilkan daftar pembagi yang tepat dalam urutan menaik
  • Zero dan satu tidak memiliki pembagi yang tepat (mereka bukan prima, maupun komposit)
  • Menerapkan atom ekor Jelly, ,, ke daftar kosong menghasilkan nol
  • Tidak ada angka yang memiliki pembagi nol yang tepat (apalagi yang maksimal)
  • Semua angka bukan nol adalah benar di Jelly, sedangkan nol adalah palsu

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

Jelly , 9 8 byte

Disimpan 1 byte berkat @Dennis

:ÆfṂ€$~~

Cobalah online! atau jalankan semua test case

Berkomentar

Kami mengambil keuntungan dari kenyataan bahwa keduanya nandan infmenjadi 0di Jelly ketika bitwise TIDAK diterapkan pada mereka.

:Æ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
Anda tidak menggunakan JavaScript saat ini? jawaban bagus btw

3
Saya sangat suka ~~. :ÆfṂ€$~~menghemat satu byte dengan menghilangkan tautan pembantu.
Dennis

@Dennis Ah! $adalah apa yang saya cari. :) terima kasih!
Arnauld

7

R, 68 62 byte

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

Solusi yang hanya menggunakan basis R, tanpa perpustakaan! Terima kasih kepada Giuseppe untuk bermain golf 6 byte.

Penggunaan scanmembaca dalam daftar angka yang dipisahkan ruang, %%untuk mengidentifikasi faktor-faktor mana. vkemudian berisi vektor semua faktor dalam urutan menaik (termasuk 1 dan n). Ini memiliki properti bagus yang ketika kita reversev , nomor yang kita inginkan akan berada di tempat kedua, menghindari panggilan mahal ke lengthatau tail(jika nprime, vberisi n 1, selain itu berisin (factors in descending order) 1 ).

Contoh output (tautan TIO di sini ):

> 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

Jika menurut Anda suatu daftar bukan tipe pengembalian yang dapat diterima, maka tukar Mapuntuksapply dan tambahkan 3 byte.



bagus - tidak berpikir untuk memulai dengan!
JDL

6

05AB1E , 11 9 8 byte

Ñε¨àDd<+

-3 byte terima kasih kepada @Emigna , ubah ©d1-®+ke Dd<+dan€¨€à ke ε¨à.

Hanya jawaban 05AB1E kedua saya, jadi pasti bisa .

Cobalah online.

Penjelasan:

Ñ           # 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<+harus bekerja ©d1-®+. Anda juga tidak perlu ïkarena mereka masih int. Anda bisa memilikinya di footer untuk hasil yang terlihat lebih bagus.
Emigna

@Emigna Ah, 1-bukannya <itu sangat bodoh .. Terima kasih untuk Dbukan ©...®! Dan saya memang sudah memasukkan ïfooter sekarang.
Kevin Cruijssen

1
Atau bahkan lebih baik:Ñε¨àDd<+
Emigna

Jauh lebih baik daripada 12-byter saya.
Magic Gurita Guci

5

J , 21 byte

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

Cobalah online!

Penjelasan:

(>&1)"0 Apakah setiap angka lebih besar dari 1?

@. jika tidak, kembali _1:

(%{.@q:)jika 2 atau lebih besar, bagi %angkanya dengan {.faktor prima pertamaq:


4

Japt , 6 byte

Setelah bermain golf, akhirnya hampir identik dengan, dan sesingkat, solusi Jonathan.

®â¬ÌªJ

Cobalah


Penjelasan

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

Simpan satu byte dengan-m
Oliver

3

Python 3 , 62 byte

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

Cobalah online!

Karena 0dan 1 range(1,n)kosong, maka kode akan dievaluasi max([]+[-1]) = -1. Untuk bilangan prima, satu-satunya pembagi dalam [1, n) adalah 1, yang merupakan output yang diinginkan.


Kelapa , 50 byte

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

Cobalah online!


3

Java 8, 105 103 87 byte

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

Memodifikasi input-array alih-alih mengembalikan yang baru untuk menghemat byte.

Cobalah online.

Penjelasan:

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 byte

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

Cobalah 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

3

Sekam , 8 byte

m(|_1→hḊ

Cobalah online!

Penjelasan

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]

3

Attache , 23 byte

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

Cobalah online!

29 byte, pointfree: @(Max&-1@Last@ProperDivisors)

24 byte, juga pointfree: @(Max&-1@`@&-2@Divisors)

Ini hanya mendapatkan pembagi kedua ke terakhir nkemudian mengambil maks dan -1. Elemen kedua-untuk-terakhir dalam array dengan kurang dari dua elemen adalah nil, dan Max[-1, nil]ini -1. @cukup mengubah fungsi ini menjadi vektor, membuatnya berlaku untuk setiap atom.



2

R + numbers, 88 79 byte

Berkat komentar untuk beberapa saran terutama tentang cara membuat pengiriman.

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

Menggunakan produk dari semua faktor utama kecuali yang terkecil, dan fakta bahwa produk elemen vektor kosong didefinisikan sebagai 1 .

Cobalah online!


1
menyimpan byte untuk menghilangkan librarypanggilan dan menggunakan numbers::primeFactorssecara langsung.
JDL

1
inilah tautan TIO untuk melihat apa yang disarankan JDL, serta menukarnya dengan fungsi anonim.
Giuseppe

2

Brachylog , 10 byte

{fkt|∧_1}ˢ

Cobalah online!

Penjelasan berikut sebagian besar diutarakan secara imperatif demi singkatnya, dan tidak secara akurat mencerminkan sifat deklaratif 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.

Saya memutuskan untuk belajar Brachylog sehingga saya bisa bersenang-senang dengan kode golf sambil berharap untuk mempelajari beberapa perilaku Prolog aktual melalui osmosis, dan saya sangat menikmatinya sejauh ini, bahkan jika saya tidak sepenuhnya yakin bagaimana caranya. karakter kontrol eksekusi bekerja.


2
"mungkin ada beberapa alasan yang jelas ∨ tidak akan bekerja di sini, tetapi saya tidak tahu apa itu" -> Anda dapat menggunakan .∨alih-alih |∧(saya kira Anda lupa .), tetapi itu adalah jumlah byte yang sama. Selamat datang di PPCG (dan Brachylog yang lebih penting: p)!
Fatalkan

Ah, tentu saja! Terima kasih.
String Tidak Terkait

Anda dapat mengajukan pertanyaan semacam ini di Brachylog di ruang obrolan
Brachylog

1

Stax , 14 13 byte

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

Jalankan dan debug itu

Penjelasan (tidak dikemas):

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 di dalam peta:

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

1

Pyth, 12 byte

me+_1f!%dTSt

Coba di sini

Penjelasan

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 byte

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

Cobalah online!

Untuk setiap angka, ganti maksimum (n, 1).
Tambahkan nomor yang dinegasikan ke daftar faktor prima (daftar kosong untuk 1), dan bagi nomor dengan item pertama dalam daftar.

Juga 14 byte

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

Cobalah online!

Bagilah setiap angka dengan faktor prima pertama. 0 menimbulkan kesalahan domain q:, dan kami mencari item ke-0 dalam daftar kosong untuk 1 - itu juga kesalahan. Untuk nomor yang salah, kembalikan −1.


Solusi yang sangat bagus!
Galen Ivanov

1

Japt , 14 11 8 byte

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

Cobalah online!

Mencukur tiga byte sial itu berkat Shaggy .


Anda tidak perlu memfilter bilangan prima - kmengembalikan faktor primaN - jadi ini menjadi 8 byte:®/k v)ªÉ
Shaggy

@Shaggy Terima kasih, tidak tahu itu hanya mengembalikan faktor utama karena metode docs tidak mengatakan itu.
Nit

1
Oh, ya, lupakan itu. Berarti untuk menyerahkan PR untuk sementara waktu; akan segera melakukannya.
Shaggy

1

JavaScript (Node.js) , 61 55 byte

-6 byte terima kasih kepada @shaggy

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

Cobalah online!


Penjelasan:

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

Ini masih untuk kode lama belum perbarui ini.

Ramah ES5 juga:

 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: terima kasih
Muhammad Salman

1

Utilitas Bash + GNU, 49

  • 9 byte disimpan berkat @Cowsquack
factor|sed '/:$/c-1
/: \w+$/c1
s%: %/%
y/ /#/'|bc

Penjelasan

  • factor membaca angka input dari STDIN, satu per baris dan output dalam format <input number>: <space-separated list of prime factors (ascending)>
  • sed memproses ini sebagai berikut:
    • /:$/c-1 Angka input 0 dan 1 tidak memiliki faktor prima dan diganti dengan -1
    • /: \w+$/c1Angka dengan satu faktor prima (sendiri) prima. Ganti ini dengan1
    • s%: %/%Ganti :dengan/ . Ini membangun ekspresi aritmatika untuk membagi nomor input (non-prima) dengan faktor prima terkecil untuk memberikan faktor terbesar
    • y/ /#/ Hapus daftar faktor (tidak dibutuhkan) lainnya (dengan berkomentar)
  • bc Mengevaluasi dan menampilkan secara hitung

Cobalah online!


1
Anda mungkin dapat menghapus -r, dan untuk dua yang pertama sdapat Anda gunakan /regex/cvalueuntuk golf satu byte, menyederhanakan regex ini lebih lanjut dapat menghemat lebih banyak, dan Anda dapat menyimpan byte dalam dua regex terakhir dengan hanya mengganti :dengan /, dan kemudian mengomentari bagian yang tidak diinginkan, seperti itu, tio.run/##JYlBCoMwFET3c4qABhdSfuZ/…
Kritixi Lithos

@Cowsquack sangat bagus - terima kasih!
Trauma Digital





1

Befunge-98 (FBBI) , 39 byte

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

Cobalah online!

Berakhir dengan & ketika tidak ada lagi angka. Hal ini menyebabkan program berhenti selama 60 detik hingga TIO mengakhiri program. Ini tidak dapat dihindari untuk Befunge-98, setidaknya di TIO karena kedua penerjemah melakukan ini. Setelah bermain, Anda dapat menghentikan program setelah sedikit untuk melihat apa yang akan dihasilkan jika Anda menunggu sebentar.


Pada dasarnya, untuk setiap angka baru, jika angka 0, itu mengubahnya menjadi 1. Kemudian menempatkan -1 ke tumpukan diikuti oleh angka yang dimulai dari 1 dan menghitung hingga mencapai nomor input, dalam hal ini mencetak angka kedua pada tumpukan (-1 untuk input 0 atau 1, dan faktor tertinggi untuk yang lain). Setiap kali melalui loop, kami menambahkan nilai iterator ke stack di belakangnya jika ( input % iterator == 0). Ini berarti bahwa ketika kita mendapatkan input, kita hanya perlu membuang iterator dan mencetak. Kemudian, kami menghapus tumpukan dengan ndan kembali ke fungsi input baca.

Saya dapat memperluas penjelasan nanti, kita akan melihat ...


0

Retina 0.8.2 , 33 byte

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

Cobalah online!Tautan termasuk kasus uji yang tidak terlalu lambat. Penjelasan:

%(`

Ulangi setiap nomor input.

^0|^1$
-1

Kasus khusus 0 dan 1.

\d+
$*

Konversi ke unary (tidak mempengaruhi -1).

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

Ganti setiap angka dengan faktor layak terbesarnya dalam desimal.


0

tinylisp , 75 byte

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

Cobalah online!(Berisi 4 byte tambahan untuk memberikan fungsi anonim nama sehingga kita dapat menyebutnya di footer.)

Tidak dikelompokkan / penjelasan

Perhatikan bahwa mengembalikan 1 untuk prime n dan faktor terbesar kurang dari n untuk komposit n dapat digabungkan menjadi kembali n/hal dimana hal adalah faktor utama terkecil 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
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.