Temukan Nomor Paling Halus

59

Tantangan Anda adalah menemukan angka paling halus pada rentang tertentu. Dengan kata lain, cari nomor yang faktor prima terbesarnya paling kecil.

Angka yang lancar adalah faktor yang faktor prima terbesarnya kecil. Bilangan jenis ini berguna untuk algoritma transformasi Fourier cepat, pembacaan sandi, dan aplikasi lainnya.

Misalnya, pada rentang 5, 6, 7, 8, 9, 10, 8 adalah angka paling halus, karena faktor prima 8 terbesar adalah 2, sedangkan semua angka lainnya memiliki faktor prima 3 atau lebih besar.

Input: Input akan berupa dua bilangan bulat positif, yang menentukan rentang. Bilangan bulat minimum yang diperbolehkan dalam rentang adalah 2. Anda dapat memilih apakah rentang inklusif, eksklusif, semi-eksklusif, dll, selama rentang arbitrer dapat ditentukan dalam batas-batas bahasa Anda. Anda dapat mengambil angka-angka melalui input fungsi, stdin, argumen baris perintah, atau metode apa pun yang setara untuk bahasa Anda. Tidak ada penyandian informasi tambahan dalam input.

Output: Mengembalikan, mencetak, atau menyamakan satu atau lebih bilangan bulat dalam kisaran input yang maksimal mulus (faktor terbesar minimal). Mengembalikan banyak hasil adalah opsional, tetapi jika Anda memilih untuk melakukannya, hasilnya harus dibatasi dengan jelas. Format output asli baik untuk beberapa hasil.

Silakan sebutkan jawaban Anda bagaimana Anda mengambil input dan memberikan output.

Penilaian: Golf kode. Hitung berdasarkan karakter jika ditulis dalam ASCII, atau 8 * byte / 7 jika tidak dalam ASCII.

Kasus uji:

Catatan: Ini adalah rentang gaya Python, termasuk ujung rendah tetapi bukan ujung tinggi. Ubah seperlunya untuk program Anda. Hanya satu hasil yang diperlukan.

smooth_range(5,11)
8
smooth_range(9,16)
9, 12
smooth_range(9,17)
16
smooth_range(157, 249)
162, 192, 216, 243
smooth_range(2001, 2014)
2002
isaacg
sumber
Apakah rentang yang ditentukan sebagai (mulai, panjang) bukan (mulai, berakhir) dapat diterima?
CodesInChaos
1
@CodesInChaos Tentu. Itu tercakup dalam klausa "atau apa pun".
isaacg
3
Saya tidak melihat gunanya menghukum jawaban non-ASCII. Akan lebih mudah untuk hanya menghitung byte dalam semua kasus.
nyuszika7h
1
@ nyuszika7h Ascii secara signifikan lebih kecil dari satu byte - hanya menggunakan 7 bit. Oleh karena itu, saya menunjukkan satu karakter dengan 7 bit, dan skala bahasa lain sesuai. Namun, jika bahasanya non-ASCII tetapi dapat mengemas semua karakternya menjadi 7 bit, saya tidak akan menerapkan biaya tambahan. Lihat J / K vs. APL. tl; dr Bytes lebih sederhana, tetapi memberikan APL et. Al. keuntungan halus tapi tidak adil.
isaacg
3
@isaacg Anda mendorong penciptaan bahasa semu menggunakan set karakter yang lebih kecil. jika kita mencetak set karakter 7-bit berbeda dari set karakter 8-bit, seseorang dapat mengemas sebagian besar bahasa modern menjadi 6 bit (64 karakter memberi kita AZ, 0-9, beberapa spasi, 20 tanda baca, dan beberapa untuk cadangan) .
Sparr

Jawaban:

99

CJam - 13

q~,>{mfW=}$0=

Cobalah di http://cjam.aditsu.net/

Input contoh: 2001 2014
Contoh output:2002

Penjelasan:

q~membaca dan mengevaluasi input, mendorong 2 angka pada stack (mis. min dan maks)
,membuat array [0 1 ... maks-1]
>mengiris array mulai dari min, menghasilkan [min ... maks-1]
{…}$mengurutkan array menggunakan blok untuk menghitung kunci pengurutan
mfmendapatkan array dengan semua faktor prima dari suatu bilangan, untuk
W=mendapatkan elemen terakhir dari array (W = -1), sehingga memperoleh faktor prima terbesar untuk digunakan sebagai kunci pengurutan
0=mendapatkan elemen pertama dari array (diurutkan)

aditsu
sumber
38
Yah, kurasa itu saja.
Eric Tressler
5
Saya perlu menambahkan fungsi faktorisasi ke pyth.
isaacg
6
Bahasa ini adalah sihir.
Brobin
8
Ini hampir sama dengan hanya menarik beberapa HQ9 + s ** t sebagaimana adanya tanpa menjadi celah. Luar biasa!
Ingo Bürk
25
ヽ ༼ ຈ لヽ ͜ ༽ ノmfWseseorang memecahkannya dalam 13 karakter.
Internet dibuat dari catz
66

Regex ( .NET PCRE flavor), 183 129 byte

Jangan coba ini di rumah!

Ini sebenarnya bukan pesaing untuk menang. Tetapi Eric Tressler menyarankan untuk menyelesaikan masalah ini hanya dengan regex, dan saya tidak tahan untuk tidak mencobanya. Ini mungkin juga dapat dilakukan di PCRE (dan bahkan lebih pendek, lihat di bawah), tetapi saya memilih .NET karena solusi saya memerlukan tampilan yang sewenang-wenang. Kita mulai:

(?<=^(1+),.*)(?=\1)(?=((11+)(?=.*(?=\3$)(?!(11+?)\4+$))(?=\3+$)|(?!(11+)\5+$)1+))(?!.+(?=\1)(?:(?!\2)|(?=((11+)(?=.*(?=\7$)(?!(11+?)\8+$))(?=\7+$)|(?!(11+)\9+$)1+)).*(?=\2$)(?=\6)))1+

Input dikodekan sebagai rentang dipisahkan koma inklusif, di mana kedua angka diberikan dalam notasi notaris menggunakan 1s. Pertandingan akan menjadi S1 yang tertinggal di mana Sadalah angka paling halus dalam kisaran. Ikatan rusak demi jumlah terkecil.

Jadi contoh kedua dari pertanyaan adalah string berikut (pertandingan digarisbawahi)

111111111,1111111111111111
                 =========

Ini didasarkan pada regex pengecekan prima (yang sekarang sudah terkenal) , variasi yang tertanam di sana 6 kali.

Ini adalah versi yang menggunakan spasi bebas dan komentar untuk mereka yang ingin tahu apa yang terjadi.

# Note that the beginning of the match we're looking for is somewhere
# in the second part of the input.
(?<=^(1+),.*)          # Pick up the minimum range MIN in group 1
(?=\1)                 # Make sure there are at least MIN 1s ahead

                       # Now there will be N 1s ahead of the cursor
                       # where MIN <= N <= MAX.


(?=(                   # Find the largest prime factor of this number
                       # store it in group 2.
  (11+)                # Capture a potential prime factor P in group 3
  (?=                  # Check that it's prime
    .*(?=\3$)          # Move to a position where there are exactly 
                       # P 1s ahead
    (?!(11+?)\4+$)     # Check that the remaining 1s are not composite
  )
  (?=\3+$)             # Now check that P is a divisor of N.
|                      # This does not work for prime N, so we need a 
                       # separate check
  (?!(11+)\5+$)        # Make sure that N is prime.
  1+                   # Match N
))

(?!                    # Now we need to make sure that here is not 
                       # another (smaller) number M with a smaller 
                       # largest prime factor

  .+                   # Backtrack through all remaining positions
  (?=\1)               # Make sure there are still MIN 1s ahead

  (?:
    (?!\2)             # If M is itself less than P we fail 
                       # unconditionally.
  |                    # Else we compare the largest prime factors.
    (?=(               # This is the same as above, but it puts the
                       # prime factor Q in group 6.
      (11+)
      (?=
        .*(?=\7$)
        (?!(11+?)\8+$)
      )
      (?=\7+$)
    |
      (?!(11+)\9+$)
      1+
    ))
    .*(?=\2$)          # Move to a position where there are exactly 
                       # P 1s ahead
    (?=\6)             # Try to still match Q (which means that Q is
                       # less than P)
  )
)
1+                     # Grab all digits for the match

Anda dapat mengujinya secara online di sini . Jangan mencoba input terlalu besar, saya tidak membuat jaminan tentang kinerja monster ini.

Sunting:

Saya akhirnya porting ini ke PCRE (yang hanya membutuhkan dua langkah), dan memperpendek regex hampir sepertiga. Ini versi baru:

^(1+),.*?\K(?=\1)(?=((11+)(?=.*(?=\3$)(?!(11+?)\4+$))(?=\3+$)|(?!(11+)\5+$)1+))(?!.+(?=\1)(?:(?!\2)|(?=((?2))).*(?=\2$)(?=\6)))1+

Ini pada dasarnya sama, dengan dua perubahan:

  • PCRE tidak mendukung tampilan sewenang-wenang di belakang (yang saya gunakan untuk masuk MINke grup 1). Namun, PCREapakah dukungan \Kyang me-reset awal pertandingan ke posisi kursor saat ini. Karenanya (?<=^(1+),.*)menjadi ^(1+),.*?\K, yang sudah menyimpan dua byte.
  • Penghematan nyata berasal dari fitur rekursi PCRE. Saya sebenarnya tidak menggunakan rekursi, tetapi Anda dapat menggunakan (?n)untuk mencocokkan grup nlagi, mirip dengan panggilan subrutin. Karena regex asli berisi kode untuk menemukan faktor prima terbesar nomor dua kali, saya bisa mengganti seluruh sebagian besar yang kedua dengan sederhana (?2).
Martin Ender
sumber
37
Bunda Suci allah
Newb
1
@Timwi Saya perlu memeriksa bahwa faktor prima terbesar (grup 3atau 7) sebenarnya prima. Ini mensyaratkan bahwa ada salinan faktor lain setelah pertama kali menangkapnya, yang tidak akan berlaku untuk bilangan prima. Sementara saya mengatasinya di .NET dengan meletakkan tampilan di belakang sana sehingga saya bisa mundur sedikit untuk memeriksa, ini tidak akan mungkin dalam versi PCRE yang lebih pendek karena kurangnya tampilan panjang variabel. Mungkin ini mungkin untuk mempersingkat sedikit itu, tapi saya tidak berpikir hanya mengubah +ke *karya.
Martin Ender
2
@MartinEnder Hai! Saya membayangkan Anda sudah lama mengatasi tantangan ini, tetapi saya hanya berselancar masuk, melihat solusi regex, dan tidak bisa tidak mengabaikan peringatan Anda di bagian atas posting ini :) Saya merasa sulit untuk melihat kode orang lain, jadi setelah melihat regex Anda dan menjadi bingung, saya mencobanya dari awal dan menghasilkan ini: (.*),.*?\K(?=(..+)((?=((?(R)\6|\2))*$).*(?=\4$)(?!(..+)\5+$)))(?!.+(?=\1)(?=(..+)(?3)).*(?!\2)\6).+ 99 byte di PCRE. Juga, saya telah menemukan banyak pekerjaan Anda di situs ini dan saya penggemar: D Menantikan pertarungan regex di masa depan!
jaytea
1
Saya bermain golf kode dengan komentar itu jadi saya hanya akan meletakkan addendum di sini: Anda dapat mematikan 4b dengan \4$mengeluarkan lookahead dan menempelkannya setelah lookahead negatif, tetapi ini sangat memengaruhi kinerja (setiap subkelompok angka <= \ 4 diperiksa untuk komposit daripada hanya \ 4 itu sendiri) dan gagal pada input yang lebih lama.
jaytea
1
@ jaytea Maaf telah mengambil selamanya untuk kembali kepada Anda tentang hal ini. Karena Anda menulisnya dari awal, saya pikir Anda harus mengirim jawaban yang terpisah. Itu skor yang bagus dan Anda layak mendapatkan penghargaan untuk itu. :)
Martin Ender
16

Regex (rasa PCRE), 66 (65🐌) byte

Terinspirasi dengan melihat bahwa baik Martin Ender dan jaytea , dua jenius regex, menulis solusi regex untuk golf kode ini, saya menulis sendiri dari awal. Regex pengecekan prime yang terkenal tidak muncul di solusi saya.

Jangan membaca ini jika Anda tidak ingin beberapa sihir regex unary dimanjakan untuk Anda. Jika Anda ingin mencoba mencari tahu sendiri keajaiban ini, saya sangat menyarankan memulai dengan menyelesaikan beberapa masalah di ECMAScript regex:

  1. Cocokkan bilangan prima (jika Anda belum terbiasa melakukan ini di regex)
  2. Cocokkan kekuatan 2 (jika Anda belum melakukannya). Atau lakukan perjalanan Anda melalui Regex Golf , yang meliputi Prime dan Powers. Pastikan untuk melakukan set masalah Classic dan Teukon.
  3. Temukan cara terpendek untuk mencocokkan kekuatan N di mana N adalah beberapa konstanta (yaitu ditentukan dalam regex, bukan input) yang dapat menjadi komposit (tetapi tidak harus). Misalnya, mencocokkan kekuatan 6.

  4. Temukan cara untuk mencocokkan kekuatan Nth, di mana N adalah beberapa konstanta> = 2. Misalnya, cocokkan kuadrat sempurna. (Untuk pemanasan, cocokkan kekuatan utama .)

  5. Cocokkan pernyataan perkalian yang benar. Cocokkan angka segitiga.

  6. Cocokkan angka Fibonacci (jika Anda gila seperti saya), atau jika Anda ingin tetap pada sesuatu yang lebih pendek, cocokkan pernyataan eksponensial yang benar (untuk pemanasan, kembalikan sebagai pencocokan logaritma di dasar 2 dari kekuatan 2 - bonus, lakukan hal yang sama untuk nomor apa pun, membulatkannya sesuka Anda), atau nomor faktorial (untuk pemanasan, cocokkan nomor primorial ).

  7. Cocokkan angka melimpah (jika Anda gila seperti saya)

  8. Hitung bilangan irasional dengan presisi yang diminta (mis. Bagi input dengan akar kuadrat dari 2, kembalikan hasil yang dibulatkan sebagai kecocokan)

(Mesin regex yang saya tulis mungkin bisa membantu, karena sangat cepat di regex matematika unary dan termasuk mode numerik unary yang dapat menguji rentang bilangan alami (tetapi juga memiliki mode string yang dapat mengevaluasi regex non-unary, atau unary dengan pembatas). Secara default ECMAScript kompatibel, tetapi memiliki ekstensi opsional (yang secara selektif dapat menambahkan subset PCRE, atau bahkan pencarian molekuler, sesuatu yang tidak dimiliki oleh mesin regex lain).)

Kalau tidak, baca terus, dan baca juga GitHub Gist ini (peringatan, banyak spoiler) yang menceritakan perjalanan mendorong regex ECMAScript untuk menangani fungsi bilangan alami dari meningkatnya kesulitan (dimulai dengan serangkaian puzzle teukon, tidak semuanya matematika, yang memicu ini perjalanan).

Seperti halnya solusi regex lain untuk masalah ini, input diberikan sebagai dua angka dalam bijective unary, dipisahkan oleh koma, mewakili rentang inklusif. Hanya satu nomor yang dikembalikan. Regex dapat dimodifikasi untuk mengembalikan semua angka yang memiliki faktor prima terkecil terbesar yang sama, sebagai kecocokan terpisah, tetapi itu akan membutuhkan \Ktampilan panjang variabel di belakang dan baik menempatkan lookahead atau mengembalikan hasilnya sebagai tangkapan alih-alih pertandingan.

Teknik yang digunakan di sini dari pembagian implisit berulang dengan faktor prima terkecil identik dengan yang digunakan dalam string Match yang panjangnya adalah jawaban kekuatan keempat yang saya posting beberapa waktu lalu.

Tanpa basa-basi lagi: ((.+).*),(?!.*(?=\1)(((?=(..+)(\5+$))\6)*)(?!\2)).*(?=\1)\K(?3)\2$

Anda dapat mencobanya di sini.

Dan versi jarak bebas, dengan komentar:

                        # No ^ anchor needed, because this algorithm always returns a
                        # match for valid input (in which the first number is less than
                        # or equal to the second number), and even in /g mode only one
                        # match can be returned. You can add an anchor to make it reject
                        # invalid ranges.

((.+).*),               # \1 = low end of range; \2 = conjectured number that is the
                        # smallest number in the set of the largest prime factor of each
                        # number in the range; note, it is only in subsequent tests that
                        # this is implicitly confined to being prime.
                        # We shall do the rest of our work inside the "high end of range"
                        # number.

(?!                     # Assert that there is no number in the range whose largest prime
                        # factor is smaller than \2.
  .*(?=\1)              # Cycle tail through all numbers in the range, starting with \1.

  (                     # Subroutine (?3):
                        # Find the largest prime factor of tail, and leave it in tail.
                        # It will both be evaluated here as-is, and later as an atomic
                        # subroutine call. As used here, it is not wrapped in an atomic
                        # group. Thus after the return from group 3, backtracking back
                        # into it can increase the value of tail – but this won't mess
                        # with the final result, because only making tail smaller could
                        # change a non-match into a match.

    (                   # Repeatedly divide tail by its smallest prime factor, leaving
                        # only the largest prime factor at the end.

      (?=(..+)(\5+$))   # \6 = tool to make tail = \5 = largest nontrivial factor of
                        # current tail, which is implicitly the result of dividing it
                        # by its smallest prime factor.
      \6                # tail = \5
    )*
  )
  (?!\2)                # matches iff tail < \ 2
)

# now, pick a number in the range whose largest prime factor is \2
.*(?=\1)                # Cycle tail through all numbers in the range, starting with \1.
\K                      # Set us up to return tail as the match.
(?3)                    # tail = largest prime factor of tail
\2$                     # Match iff tail == \2, then return the number whose largest
                        # prime factor is \2 as the match.

Algoritme dapat dengan mudah dipindahkan ke ECMAScript dengan mengganti panggilan subrutin dengan salinan subrutin, dan mengembalikan pertandingan sebagai grup tangkap alih-alih menggunakan \ K. Hasilnya panjangnya 80 byte:

((x+)x*),(?!.*(?=\1)((?=(xx+)(\4+$))\5)*(?!\2)).*(?=\1)(((?=(xx+)(\8+$))\9)*\2$)

Cobalah online!

Catatan yang ((.+).*)dapat diubah menjadi ((.+)+), menjatuhkan ukuran dengan 1 byte (dari 66 ke 65 byte ) tanpa kehilangan fungsionalitas yang benar - tetapi regex secara eksponensial meledak dalam kelambatan.

Cobalah online! (79 byte ECMAScript versi eksponensial-perlambatan)

Kode mati
sumber
11

Python 2, 95

i=input()
for a in range(*i):
 s=a;p=2
 while~-a:b=a%p<1;p+=1-b;a/=p**b
 if p<i:i=p;j=s                                        
print j

Menemukan kelancaran angka dengan pembagian percobaan sampai jumlahnya 1. imenyimpan kelancaran terkecil sejauh ini, jmenyimpan angka yang memberikan kelancaran itu.

Terima kasih kepada @xnor untuk golfnya.

isaacg
sumber
1
Itu if/elseharus disingkat. Pikiran pertama saya adalah b=a%p<1;p+=1-b;a/=p**b. Atau eksekutif yang menjalankan salah satu dari keduanya dalam string yang disisipkan. Juga, mungkin while~-aberhasil.
xnor
isaacg - Saya suka jawaban ini! Betapa cara cemerlang yang Anda temukan untuk mencari faktor utama terbesar! Saya telah memperbarui jawaban saya untuk meminjam metode Anda, dengan kredit untuk Anda pada metode tersebut.
Todd Lehman
Solusi hebat! Menggunakan s,p=a,2, i,j=p,s, @ ide xnor ini, menghapus lekukan berlebihan dan menempatkan blok sementara ke dalam satu baris menghasilkan 95 karakter. Tidak yakin bagaimana Anda menghasilkan 98 ...
Falko
kode ini penuh dengan emotikon, :)
Rosenthal
@Falko kedua perubahan itu tidak menyimpan karakter. 7-> 7.
isaacg
10

J, 22 20 19 karakter

({.@/:{:@q:)@(}.i.)

Misalnya

   2001 ({.@/: {:@q:)@(}. i.) 2014
2002

(Fungsi mengambil dua argumen adalah infix dalam J.)

FireFly
sumber
Saya juga punya celah di itu, tidak mendapatkannya sesingkat jawaban ini. Tetap:(#~ (= <./)@:(i:"1&1)@:*@:(_&q:))@:([ + i.@-~)
Augı atu
Ini {:sama dengan >./dan menghemat 1 byte.
randomra
@randomra Anda benar — panggilan bagus!
FireFly
Cantik. TIO jika Anda ingin menambahkannya: Coba online!
Jonah
9

Haskell, 96 94 93 86 80 karakter

x%y|x<2=y|mod x y<1=div x y%y|0<1=x%(y+1)
a#b=snd$minimum$map(\x->(x%2,x))[a..b]

penggunaan melalui GHCi (cangkang Haskell):

>5 # 9
8
>9 # 15
9

EDIT: sekarang algoritma yang jauh lebih sederhana.

solusi ini mencakup kedua angka dalam kisaran (jadi 8 # 9dan 7 # 8keduanya 8)

penjelasan:

fungsi (%) membutuhkan dua parameter, x dan y. ketika y adalah 2, fungsi mengembalikan kelancaran x.

algoritma dari sini sederhana - dapatkan daftar gabungan semua kelancaran angka dalam input dengan masing-masing kelancaran menyimpan referensi ke nomor aslinya, urutkan kemudian untuk mendapatkan yang terkecil, dan kembalikan nomor yang dirujuk itu.


di sini adalah versi javascript yang tidak dikenali dengan algoritma yang sama:

function smoothness(n,p)
{
    p = p || 2
    if (x == 1)
        return p
    if (x % p == 0)
        return smoothness(x/p, p)
    else
        return smoothness(x,p+1);
}
function smoothnessRange(a, b)
{
    var minSmoothness = smoothness(a);
    var min=a;
    for(var i=a+1;i <= b;i++)
        if(minSmoothness > smoothness(i))
        {
            minSmoothness = smoothness(i)
            min = i
        }
    return min;
}
haskeller bangga
sumber
Apakah mungkin untuk alias minimum untuk sesuatu yang lebih pendek? Sepertinya itu akan menghemat beberapa karakter.
isaacg
Saya mencobanya, tetapi karena pembatasan monomorfisme itu sebenarnya biaya satu karakter
bangga haskeller
Anda tidak bisa hanya melakukan m = minimum? Haskell masih merupakan misteri.
isaacg
1
@isaacg Untuk melewati pembatasan monomorfisme, kita harus menulism l=minimum l
bangga haskeller
2
Saya akan memposting solusi Haskell, sampai saya melihat milik Anda yang mengalahkan bahkan versi saya yang tidak lengkap ... +1
nyuszika7h
9

Mathematica, 61 45 39 karakter

Range@##~MinimalBy~Last@*FactorInteger&

Implementasi spesifikasi yang sangat mudah sebagai fungsi yang tidak disebutkan namanya.

  • Dapatkan rentang (inklusif).
  • Faktor semua bilangan bulat.
  • Temukan minimum, diurutkan berdasarkan faktor prima terbesar.
Martin Ender
sumber
8

Lua - 166 karakter

Saya tidak tidak memiliki (belum!) Reputasi yang cukup untuk mengomentari solusi AndoDaan ini , tapi di sini ada beberapa perbaikan pada kode-nya

a,b=io.read("*n","*n")s=b for i=a,b do f={}n=i d=2 while n>1 do while n%d<1 do f[#f+1]=d n=n/d end d=d+1 end p=math.max(unpack(f))if p<s then s=p c=i end end print(c)

Perubahan:

  • The n%d==0oleh n%d<1yang setara dalam hal ini
  • Menghapus spasi
  • Digantikan table.insert(f,d)oleh f[#f+1]=d ( #fadalah jumlah elemen dari f)
Adriweb
sumber
Ah, senang aku melirik ke sini. Ah, dua yang pertama saya harus periksa dan tangkap, tetapi peningkatan ketiga Anda baru bagi saya (maksud saya hanya berbeda dari yang biasa saya lakukan). Itu akan banyak membantu saya di sini dan di golf.shinh.com. Terima kasih!
AndoDaan
8

Bash + coreutils, 56 byte

seq $@|factor|sed 's/:.* / /'|sort -nk2|sed '1s/ .*//;q'

Input berasal dari tepat dua argumen baris perintah (Terima kasih @ nyuszika7h !!!). Output adalah hasil tunggal yang dicetak ke STDOUT.

  • seq menyediakan kisaran angka, satu per baris, dari argumen baris perintah.
  • factormembaca angka-angka itu dan mengeluarkan setiap angka diikuti dengan tanda titik dua dan daftar faktor prima dari angka itu. Jadi faktor prima terbesar adalah pada akhir setiap baris.
  • Yang pertama sedmenghilangkan titik dua dan semua kecuali faktor prima terakhir / terbesar, sehingga meninggalkan daftar setiap angka (kolom 1) dan faktor prima terbesarnya (kolom 2).
  • sort secara numerik dalam urutan meningkat dengan kolom 2.
  • Final sedcocok dengan baris 1 (angka yang faktor prima terbesarnya adalah yang terkecil dalam daftar), menghapus semuanya termasuk dan setelah spasi pertama, lalu berhenti. sedsecara otomatis mencetak hasil substitusi ini sebelum berhenti.

Keluaran:

$ ./smooth.sh 9 15
12
$ ./smooth.sh 9 16
16
$ ./smooth.sh 157 249
162
$ ./smooth.sh 2001 2014
2002
$ 

Rentang catatan dalam konteks ini termasuk kedua titik akhir.

Trauma Digital
sumber
1
seq $@lebih pendek 3 byte, jika Anda dapat berasumsi bahwa hanya ada dua argumen.
nyuszika7h
@ nyuszika7h Ide bagus - terima kasih!
Digital Trauma
5

Python 2, 67

f=lambda R,F=1,i=2:[n for n in range(*R)if F**n%n<1]or f(R,F*i,i+1)

Memikirkan golf lain memberi saya ide untuk algoritma baru untuk memeriksa kelancaran, maka jawabannya terlambat.

Faktorisasi utama faktorial i!meliputi persisnya bilangan prima paling banyak i. Jadi, jika nmerupakan produk dari bilangan prima yang berbeda, kehalusannya (faktor prima terbesar) adalah yang terkecil iyang nmerupakan pembagi i!. Untuk memperhitungkan faktor prima yang berulang n, kita dapat menggunakan daya yang cukup tinggi i!. Secara khusus, (i!)**nsudah cukup.

Kode mencoba meningkatkan faktorial F=i!, diperbarui secara rekursif. Kami memfilter untuk pembagi Fdalam rentang input, dan mengeluarkannya jika ada, dan sebaliknya beralih ke (i+1)!.

Kasus cobaan:

>> f([157, 249])
[162, 192, 216, 243]
Tidak
sumber
4

C,  149   95

Jawaban yang diedit:

Saya tidak dapat mengklaim kredit untuk solusi ini. Jawaban yang diperbarui ini meminjam metode indah yang digunakan oleh isaacg dalam solusi Python-nya. Saya ingin melihat apakah mungkin untuk menulisnya dalam C sebagai bersarang for/ whileloop tanpa kurung kurawal, dan itu!

R(a,b,n,q,p,m){for(;a<b;m=p<q?a:m,q=p<q?p:q,n=++a,p=2)while(n>1)if(n%p)p++;else n/=p;return m;}

Penjelasan:

  • Fungsi R(a,b,n,q,p,m)memindai rentang ake b-1dan mengembalikan nomor paling halus pertama yang ditemukan. Doa membutuhkan kepatuhan terhadap formulir berikut: R(a,b,a,b,2,0)sehingga variabel di dalam fungsi secara efektif diinisialisasi sebagai berikut: n=a;q=b;p=2;m=0;.

Jawaban asli :

Ini adalah jawaban asli saya ...

P(n,f,p){for(;++f<n;)p=p&&n%f;return p;}
G(n,f){for(;--f>1;)if(n%f==0&&P(f,1,1))return f;}
R(a,b,p,n){for(;++p;)for(n=a;n<b;n++)if(G(n,n)==p)return n;}

Penjelasan:

  • P(n,f,p)Nilai tes fungsi nuntuk primality dan mengembalikan true (bukan nol) jika nprime atau false (nol) jika nnon-prime. fdan pkeduanya harus disahkan sebagai 1.
  • Fungsi G(n,f)mengembalikan faktor prima terbesar n. fharus dilewati sebagai n.
  • Fungsi R(a,b,p,n)memindai rentang ake b-1dan mengembalikan nomor paling halus pertama yang ditemukan. pharus dilewati sebagai 1. ndapat berupa nilai apa pun.

Tes driver:

test(a,b){printf("smooth_range(%d, %d)\n%d\n",a,b,S(a,b,1,0));}
main(){test(5,11);test(9,16);test(9,17);test(157,249);test(2001,2014);}

Keluaran:

smooth_range(5, 11)
8
smooth_range(9, 16)
9
smooth_range(9, 17)
16
smooth_range(157, 249)
162
smooth_range(2001, 2014)
2002
Todd Lehman
sumber
Saya berpendapat ini jatuh dari klausa "Tidak ada pengkodean informasi tambahan dalam input".
Alchymist
@Alymymist - Anda mungkin benar ... tapi saya tidak berpikir ada informasi tambahan aktual dalam argumen semu. Setidaknya tidak ada informasi yang merupakan petunjuk apa pun untuk jawabannya.
Todd Lehman
4

Haskell - 120

import Data.List
import Data.Ord
x!y=(minimumBy(comparing(%2)))[x..y]
x%y|x<y=y|x`mod`y==0=(x`div`y)%y|otherwise=x%(y+1)

Contoh penggunaan:

> 5 ! 10
8
> 9 ! 15
9
> 9 ! 16
16
> 157 ! 248
162
> 2001 ! 2013
2002
Taylor Fausak
sumber
1
Tidak bisakah Anda menggunakan <1bukan ==0?
dfeuer
Ya, itu akan menjadi perbaikan yang bagus. Ada banyak hal kecil yang bisa dilakukan dengan lebih baik. Untungnya jawaban ini sudah melakukan semuanya: codegolf.stackexchange.com/a/36461
Taylor Fausak
4

Q, 91 karakter K, 78 karakter

{(x+{where x=min x}{(-2#{x div 2+(where 0=x mod 2_til x)@0}\[{x>0};x])@0}'[(x)_til y+1])@0}

k mungkin akan mencukur selusin karakter

sunting: memang, memperlakukan batas atas sebagai tidak inklusif saat ini

{*:x+{&:x=min x}{*:-2#{6h$x%2+*:&:x={y*6h$x%y}[x]'[2_!x]}\[{x>0};x]}'[(x)_!y]}
Arthur B
sumber
4

Catatan: Jawaban ini tidak diizinkan.

Jawaban ini menggunakan beberapa fitur Pyth yang ditambahkan setelah tantangan diajukan.

Saya menambahkan fitur baru lainnya, memanggil jangkauan unary pada tuple 2 elemen, yang mempersingkat solusi oleh dua karakter, untuk ini:

Pyth , 7

hoePNUQ

Input sekarang diambil dengan dipisahkan koma. Sisanya sama.


Jawaban ini menggunakan fitur Pyth yang ditambahkan setelah pertanyaan ini ditanyakan, khususnya setelah melihat solusi CJam @ aditsu yang luar biasa. Yang sedang berkata, saya ingin menunjukkan apa yang menambahkan fitur yang dimungkinkan. Fiturnya adalah P, yang merupakan fungsi arity-1 yang pada input integer mengembalikan daftar semua faktor utama input, diurutkan terkecil hingga terbesar.

Pyth , 9

hoePNrQvw

Menggunakan rentang gaya Python, baris baru dipisahkan pada STDIN. Menghasilkan solusi terkecil untuk STDOUT.

Penjelasan:

      Q = eval(input())                         Implicit, because Q is present.
h     head(                                     First element of
 o         order_by(                            Sort, using lambda expression as key.
                    lambda N:                   Implicit in o
  e                          end(               Last element of
   PN                            pfact(N)),     List containing all prime factors of N.
  r                 range(                      Python-style range, lower inc, upper exc.
   Q                      Q,                    A variable, initialized as shown above.
   vw                     eval(input()))))      The second entry of the range, same way.

Tes:

$ newline='
'

$ echo "9${newline}16" | ./pyth.py -c 'hoePNrQvw'
9

$ echo "9${newline}17" | ./pyth.py -c 'hoePNrQvw'
16

$ echo "157${newline}249" | ./pyth.py -c 'hoePNrQvw'
162

$ echo "2001${newline}2014" | ./pyth.py -c 'hoePNrQvw'
2002
isaacg
sumber
@ MartinBüttner Yep, seperti yang disarankan oleh komentarnya tentang solusi
CJam
@ MartinBüttner Ya, P, adalah fitur baru. Saya akan menjawabnya.
isaacg
1
Diijinkan atau tidak, tidak hanya saya suka, tapi saya juga berpikir bahwa "makro" pendek itu dapat dibaca jika Anda memperhatikan - mereka dikonversi ke Python langsung, setelah semua. Sesuatu harus dikatakan untuk bahasa golf yang baik untuk golf tetapi tidak selalu membingungkan.
Kuba Ober
@KubaOber Terima kasih, Kuba. Itu selalu menjadi niat saya dalam menulis Pyth, untuk menjadikan golf dan dibaca sebagai mungkin. Saya senang itu berhasil.
isaacg
3

Lua - 176 karakter

a,b=io.read("*n","*n")s=b for i=a,b do f={}n=i d=2 while n>1 do while n%d==0 do table.insert(f, d)n=n/d end d=d+1 end p=math.max(unpack(f))if p<s then s=p c=i end end print(c)

Saya benar-benar harus berhenti bermain golf di Lua. Tidak ada gunanya.

AndoDaan
sumber
14
IMHO, kode golf seperti tinju: ada kelas-berat. Bahasa yang diberikan mungkin tidak menang langsung, tetapi menyenangkan dan menyinari golf dalam kelas / bahasa itu.
Michael Easter
3

Clojure - 173 170 karakter

Saya seorang pemula Clojure. Golf:

(defn g[x,d](if(and(= 0(mod x d))(.isProbablePrime(biginteger d) 1))d 0))(defn f[i](apply max-key(partial g i)(range 2(inc i))))(defn s[a,b](first(sort-by f(range a b))))

Sampel berjalan:

Kisaran termasuk low-end, tidak termasuk high-end: [a, b) Hanya mencetak salah satu angka yang paling halus, jika banyak terjadi.

(println (s 5 11))
(println (s 9 16))
(println (s 9 17))
(println (s 157, 249))
(println (s 2001, 2014))

hasil:

bash$ java -jar clojure-1.6.0.jar range.clj
8
9
16
192
2002

Tidak Disatukan:

(defn g [x,d] (if (and (= 0(mod x d)) (.isProbablePrime (biginteger d) 1)) d 0))
(defn f [i] (apply max-key (partial g i) (range 2 (inc i))))
(defn s [a,b] (first (sort-by f (range a b))))
Michael Easter
sumber
1
Kisaran yang mencakup ujung bawah dan tidak termasuk ujung atas biasanya ditulis [a, b).
murgatroid99
ya, terima kasih atas catatannya
Michael Easter
3

Ruby, 65 62

require'prime'
s=->a,b{(a..b).min_by{|x|x.prime_division[-1]}}

Dengan permintaan maaf ke https://codegolf.stackexchange.com/a/36484/6828 , ini adalah versi golf (dan sedikit disederhanakan) dari itu. Menggunakan rentang inklusif karena karakternya lebih pendek.

1.9.3-p327 :004 > s[157,249]
 => 192 
1.9.3-p327 :005 > s[5,11]
 => 8 
1.9.3-p327 :006 > s[9,15]
 => 12 
1.9.3-p327 :007 > s[9,16]
 => 16 

Dan terima kasih kepada YenTheFirst karena telah menyelamatkan tiga karakter.

histokrat
sumber
1
Anda benar-benar dapat pergi tanpa [0], karena perbandingan array akan memprioritaskan elemen pertama. Ini akan memberikan hasil yang berbeda, tetapi tetap benar,.
YenTheFirst
3

C # LINQ: 317 303 289 262

using System.Linq;class P{static void Main(string[]a){System.Console.Write(Enumerable.Range(int.Parse(a[0]),int.Parse(a[1])).Select(i=>new{i,F=F(i)}).Aggregate((i,j)=>i.F<j.F?i:j).i);}static int F(int a){int b=1;for(;a>1;)if(a%++b<1)while(a%b<1)a/=b;return b;}}

Tidak Disatukan:

using System.Linq;

class P
{
  static void Main(string[]a)
  {
    System.Console.Write(
      Enumerable.Range(int.Parse(a[0]), int.Parse(a[1])) //create an enumerable of numbers containing our range (start, length)
        .Select(i => new { i, F = F(i) }) //make a sort of key value pair, with the key (i) being the number in question and the value (F) being the lowest prime factor
        .Aggregate((i, j) => i.F < j.F ? i : j).i); //somehow sort the array, I'm still not entirely sure how this works
  }
  static int F(int a)
  {
    int b=1;
    for(;a>1;)
      if(a%++b<1)
        while(a%b<1)
          a/=b;
    return b;
  }
}

Dibutuhkan pada awal dan panjang dari baris perintah dan akan mengembalikan nomor halus terbesar.

Saya menggunakan jawaban dari sini dan sini untuk membuat jawaban saya.

Terima kasih kepada VisualMelon untuk mengubahnya dan mencukur 12 byte! Saya juga menyingkirkan kawat gigi di if menghemat 2 byte, dan CodeInChaos menunjukkan beberapa hal yang jelas saya lewatkan (terima kasih lagi).

ldam
sumber
Beberapa hal kecil untuk keperluan umum, Anda dapat menyimpan 4 byte Fdengan mendefinisikan di int bsebelah m. Di beberapa tempat Anda melakukan perbandingan a%b==0, dan adan bselalu positif Anda dapat memotong satu byte untuk masing-masing dengan memeriksa apakah kurang dari 1 a%b<1. Anda juga dapat menyimpan byte dengan menambahkan bdalam kondisi if a%++b<0daripada dalam untuk dengan menginisialisasi ke 1. Saya juga berpikir dalam hal ini lebih murah untuk hanya memenuhi syarat sepenuhnya System.Console.WriteLinedan menghindari namespaceklausa.
VisualMelon
@VisualMelon Terima kasih, diperbarui dengan ide-ide Anda :)
ldam
Benda itu m=...:m;berada di luar loop sementara. Karena itu, Anda dapat menjatuhkan m=0,dan mengganti return m;dengan return m=b>m?b:m;. Kemudian, Anda bisa menjatuhkan m=...:m;seluruhnya.
tomsmeding
Mungkin kedengarannya aneh, tapi ini - untuk saya tidak dapat redable daripada CJam dan J. Saya kira C # dirancang untuk menjadi verbose, dan upaya membuatnya kurang sehingga membuatnya tidak dapat dibaca? Hmm ....
Kuba Ober
Tidak, saya setuju, LINQ terlihat seperti setan ketika Anda hanya melihatnya di sana-sini dan tidak pernah benar-benar bermain dengannya sendiri. Setelah Anda menangkapnya, itu benar-benar keren :) Dengan itu, saya masih belum sepenuhnya mengerti cara Aggregatekerjanya, saya hanya mencobanya setelah melihatnya di jawaban lain untuk sampai ke objek baru saya, bukan hanya satu bidang di dalamnya, dan kebetulan bekerja dengan sempurna :)
ldam
2

R, 83

library(gmp)
n=a:b
n[which.min(lapply(lapply(lapply(n,factorize),max),as.numeric))]

di mana bagian bawah rentang input ditetapkan adan bagian atas (inklusif) ditugaskan b.

gmpadalah paket yang tersedia di CRAN. Rasanya kotor sampai saya melihat mffungsi absurd di CJam. Instal dengan mengetik install.packages("gmp")di konsol.

shadowtalker
sumber
1
Jika Anda menggunakan lapply3 kali Anda mungkin ingin alias itu (yaitu l=lapplydan kemudian gunakan l(...). Demikian pula karena factorizehanya fungsi yang Anda gunakan dari paket gmpyang dapat Anda gunakan gmp::factorizealih-alih memuat pustaka dan kemudian menggunakan factorize. Kode Anda akan menjadi l=lapply;n=a:b;n[which.min(l(l(l(n,gmp::factorize),max),as.numeric))]69 byte.
plannapus
2

PowerShell - 85

($args[0]..$args[1]|sort{$d=2
while($_-gt1){while(!($_%$d)){$m=$d;$_/=$d}$d++}$m})[0]

Ini akan mengurutkan rentang angka (inklusif) berdasarkan faktor prima maks masing-masing angka. Ini mengembalikan elemen diurutkan terendah.

> smooth 5 10
8
> smooth 9 15
12
> smooth 9 16
16
> smooth 157 248
243
> smooth 2001 2013
2002
Berasal
sumber
2

J - 16 char

Menggunakan gaya rentang ( mulai , panjang ), sebagaimana diizinkan oleh komentar.

(0{+/:{:@q:@+)i.

Untuk digunakan sebagai kata kerja diad: argumen kiri adalah awal , kanan adalah panjang .

   5 (+)i. 6              NB. range
5 6 7 8 9 10
   5 (q:@+)i. 6           NB. prime factorizations
5 0 0
2 3 0
7 0 0
2 2 2
3 3 0
2 5 0
   5 ({:@q:@+)i. 6        NB. largest prime factors
5 3 7 2 3 5
   5 (+/:{:@q:@+)i. 6     NB. sort range by smallest factors
8 6 9 5 10 7
   5 (0{+/:{:@q:@+)i. 6   NB. take first entry
8
   f=:(0{+/:{:@q:@+)i.    NB. can also be named
   2001 f 13
2002

Solusi ( mulai , akhir ) adalah +2 karakter, dan tidak termasuk akhirnya; termasuk akhirnya +2 ​​lagi. Tapi sisi baiknya, ini terlihat bagus karena kami cocok dengan semua {kurung kurawal}.

(0{}./:{:@q:@}.)i.    NB. excluding
(0{}./:{:@q:@}.)1+i.  NB. including
algoritme hiu
sumber
2

Serius, 8 * 14/7 = 16 (tidak kompetitif)

,x;`yM`M;m@í@E

Serius dibuat setelah tantangan ini, tetapi saya ingin memposting jawaban ini karena itu mencontohkan jenis tantangan yang Serius pandai lakukan.

Cobalah online!

Penjelasan:

,x;`yM`M;m@í@E
,x;             make two copies of range(a,b) (a,b = input())
   `  `M;       make two copies of the result of the map:
    yM            push maximum prime factor
         m@í    push index of minimum element from prime factors
            @E  push element from range with given index
Mego
sumber
2

Pyth , 7 byte

.mePbrF

Coba di sini!

[Sebuah,b)[Sebuah,b]}r

.mePbrF – Full program with arguments a and b.
     rF – Fold by half-inclusive range. Yields the integers in [a, b).
.m      – Values b in that list which give minimal results when applied f.
  ePb   – function / block f. 
   Pb   – Prime factors of b.
  e     – Last element. This is guaranteed to yield the largest, as they're sorted.
Tuan Xcoder
sumber
1

Cobra - 150

def f(r as vari int)
    x,y=r
    c,o=y,0
    for n in x:y,for m in n:0:-1
        p=1
        for l in 2:m,if m%l<1,p=0
        if n%m<=0<p
            if m<c,c,o=m,n
            break
    print o

Bahkan tidak yakin mengapa saya repot, ular kobra tidak bisa bersaing di sini.

Suram
sumber
1
Cobra terlihat identik dengan python ... Apa perbedaannya?
Beta Decay
@BetaDecay Cobra adalah apa yang terjadi ketika Anda memberikan C # sintaksis Python. The Cobra Situs Web
Οurous
1

Ruby - 113 karakter

Menggunakan stdlib. Mengembalikan satu hasil. Diuji pada ruby ​​2.1.2.

require 'prime'
def smooth_range(a,b)
  (a...b).sort_by{|e|e.prime_division.flat_map{|f,p|[f]*p}.uniq.max}[0]
end
John P. Terry
sumber
1
Selamat datang di Programing Puzzles dan Code Golf Stack Exchange. Terima kasih telah memposting hasil Anda. Karena ini adalah pertanyaan kode-golf, harap sertakan jumlah karakter Anda dalam jawaban Anda. Anda dapat menggunakan alat seperti ini: javascriptkit.com/script/script2/charcount.shtml
isaacg
1

Perl (5.10+), 83

for(<>..<>){$n=$_;$p=2;$_%$p&&$p++or$_/=$p while$_>1;$m=$p,$r=$n if$p<$m||!$m}
say$r

(linebreak dapat dihapus). Mengambil dua titik akhir dari rentang inklusif pada dua baris stdin (karena <>lebih murah daripada mengakses ARGV) dan mengeluarkan yang paling halus ke stdout. Jika ada dasi untuk yang paling halus, cetaklah yang terkecil. Bisa mencetak yang terbesar dengan biaya satu karakter.

Algoritme pada dasarnya adalah cara isaacg untuk menemukan faktor prima terhebat, meskipun kami mengatasinya secara mandiri. Bagian golf turun indah untuk satu pernyataan di perl, sisanya memiliki lebih banyak overhead daripada yang saya inginkan sekalipun.

Harus dijalankan di bawah perl -Eatau dengan use 5.012pembukaan. Jika Anda tidak dapat melakukannya, ganti say$rdengan print$r,$/.

hobbs
sumber
1

Python 2 (84)

f=lambda n,p=2:n>1and f(n/p**(n%p<1),p+(n%p>0))or p
print min(range(*input()),key=f)

Solusi @ isaacg , tetapi dengan mintombol fungsi menggantikan penemuan-min yang eksplisit, dan fungsi rekursif memainkan peran iterasi.

Jalankan di Stackless Python untuk menghindari batas rekursi.

Tampaknya boros untuk menggunakan kondisi yang diparantisasi (n%p<1), kemudian ulangi negasinya juga dalam paranthes (n%p>0), tapi itu yang terbaik yang saya dapatkan. Saya mencoba banyak hal, tetapi ternyata lebih buruk.

f(n/p**(n%p<1),p+(n%p>0))     # Current for comparison
f(*[n/p,n,p,p+1][n%p>0::2])
n%p and f(n,p+1)or f(n/p,p)
f(*n%p and[n,p+1]or[n/p,p])

Saya menyambut setiap perbaikan yang dapat Anda pikirkan.

Tidak
sumber
1

Java 8 - 422 454 karakter

Saya sedang belajar Java 8, dan ingin memberikan suntikan ini relatif terhadap Java (atau bahkan Java 8 stream).

Dibandingkan dengan bahasa lain, ini brutal tetapi latihan yang menarik.

Golf:

import java.util.stream.*;import java.math.*;
class F{int v;int i;public int getV() { return v; }
F(int i){this.i = i;v=IntStream.range(2,i+1).map(j->((i%j==0)&&new BigInteger(""+j).isProbablePrime(1))?j:0).max().getAsInt();}}
public class T{
int s(int a, int b){return IntStream.range(a,b+1).boxed().map(F::new).sorted(java.util.Comparator.comparingInt(F::getV)).collect(java.util.stream.Collectors.toList()).get(0).i;}}

Tidak Disatukan:

import java.util.stream.*;
import java.math.*;

class F {
    int v;
    int i;
    public int getV() { return v; }
    F (int i) { 
        this.i = i;
        v = IntStream.range(2,i+1)
                     .map( j -> ((i%j==0) && 
                           new BigInteger(""+j).isProbablePrime(1))?j:0)
                     .max()
                     .getAsInt();
    }
}

public class T {
    int s(int a, int b) {
        return IntStream.range(a,b+1)
                    .boxed()
                    .map(F::new)
                    .sorted(java.util.Comparator.comparingInt(F::getV))
                    .collect(java.util.stream.Collectors.toList())
                    .get(0).i;
    }
}

contoh jalankan menggunakan:

public static void main(String[] s) {
    System.out.println(new T().s(157,249));
}

192
Michael Easter
sumber
1

MATL ( non-kompetitif ), 20 byte

Bahasa ini dirancang setelah tantangan

Kisaran inklusif di kedua ujungnya. Angka diambil sebagai dua input terpisah.

2$:t[]w"@YfX>v]4#X<)

Cobalah online!

Penjelasan

2$:          % implicitly input two numbers. Inclusive range
t            % duplicate                      
[]           % empty array
w            % swap elements in stack         
"            % for each                  
  @          %   push loop variable
  Yf         %   prime factors                  
  X>         %   maximum value
  v          %   vertical concatenation         
]            % end for each                         
4#X<         % arg min 
)            % index with this arg min into initial range of numbers
Luis Mendo
sumber
Saya kira hari ini ini akan menjadi 17 byte &:[]y"@YfX>h]&X<)atau mungkin 16 :[]y"@YfX>h]&X<). Itu &benar - benar ide yang hebat (dan saya kira ytidak tersedia saat itu?).
Minggu
Dan sepertinya siaran Yfdengan awalan 1 akan berguna di sini juga, tapi itu mungkin tidak cukup untuk memutuskan itu ide yang baik secara umum. :)
sundar
Ya, ini adalah awalnya, jadi tidak yatau &. Kredit untuk Suever untuk semantik yang sangat berguna dari yang terakhir (ide awal saya membuatnya berarti "satu input lebih dari standar"). Jika kita melihat lebih banyak contoh di mana Yfdengan menambahkan yang akan berguna, mungkin benar-benar layak menambahkan fitur itu. Masalahnya adalah, ada sekitar 34 jawaban yang digunakan Yf(sesuai dengan skrip ini ), jadi sulit untuk mengatakannya
Luis Mendo
1

Jelly , 7 byte, skor = 7 ÷ 7 × 8 = 8, tantangan tanggal bahasa

rÆfṀ$ÐṂ

Cobalah online!

Mengambil titik akhir rentang bawah dan atas sebagai dua argumen terpisah. Menghasilkan daftar semua angka paling halus dalam kisaran. (Ini dapat dilihat sebagai fungsi, dalam hal ini outputnya adalah daftar Jelly, atau sebagai program lengkap, dalam hal ini output terjadi menggunakan representasi daftar yang sama seperti yang dilakukan JSON.)

Penjelasan

Saat-saat ketika program Jelly Anda hanyalah terjemahan harfiah dari spesifikasi ...

rÆfṀ$ÐṂ
r        Range from {first argument} to {second argument}
     ÐṂ  Return the elements which have the minimum
   Ṁ$      largest
 Æf          prime factor

sumber