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

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)

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

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

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.

J, 22 20 19 karakter

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

Misalnya

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

(Fungsi mengambil dua argumen adalah infix dalam J.)

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

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.

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)

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.

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]

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

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

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

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

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.

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

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.

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

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.

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

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

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

Pyth , 7 byte

.mePbrF

Coba di sini!

$[a, b)$$[a, 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.

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.

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

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,$/.

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.

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

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

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