En Pürüzsüz Numarayı Bul


59

Buradaki zorluk verilen bir aralıktaki en yumuşak sayıyı bulmak. Başka bir deyişle, en büyük asal çarpan en küçük sayıyı bulun.

Bir pürüzsüz sayı olan büyük asal çarpan küçük biridir. Bu tür sayılar hızlı Fourier dönüşüm algoritması, kriptanaliz ve diğer uygulamalar için kullanışlıdır.

Örneğin 5, 6, 7, 8, 9, 10, 8 aralığında en düzgün sayıdır, çünkü 8'in en büyük asal çarpanı 2'dir, diğer tüm sayıların asal çarpanı 3 ya da daha büyüktür.

Giriş: Giriş , bir aralık tanımlayan iki pozitif tam sayı olacaktır. Aralıktaki izin verilen minimum tam sayı 2'dir. İstediğiniz aralık, dilinizin sınırları dahilinde belirtilebildiği sürece, kapsayıcı, özel, yarı özel vb. Olup olmadığını seçebilirsiniz. Numaraları fonksiyon girişi, stdin, komut satırı argümanı veya kendi diliniz için herhangi bir eşdeğer yöntemle alabilirsiniz. Girişte ek kodlama bilgisi yok.

Çıktı: Girdi aralığındaki maksimal olarak pürüzsüz (minimum en büyük faktör) olan bir veya daha fazla tam sayıyı döndürün, yazdırın veya eşdeğeri. Birden fazla sonuç döndürmek isteğe bağlıdır, ancak bunu seçerseniz sonuçların net bir şekilde sınırlandırılması gerekir. Yerel çıktı formatı çoklu sonuçlar için gayet iyi.

Lütfen cevabınıza nasıl girdi aldığınızı ve çıktı verdiğinizi yazınız.

Puanlama: Kod golf. ASCII ile yazılmışsa, veya ASCII ile yazılmamışsa 8 * byte / 7 olan karakterleri sayınız.

Test durumları:

Not: Bunlar, alçak son da dahil olmak üzere, yüksek son da dahil olmak üzere Python tarzı aralıklardır. Programınıza uygun şekilde değiştirin. Sadece bir sonuç gerekli.

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

(Başlangıç, bitiş) yerine (başlangıç, uzunluk) olarak belirtilen aralıklar kabul edilebilir mi?
CodesInChaos 21:14

1
@CodesInChaos Tabii. “Ya da her neyse” maddesi altında ele alınmıştır.
isaacg

3
ASCII dışı cevapların cezalandırılmasının ne olduğunu görmüyorum. Her durumda sadece bayt saymak daha kolay olacaktır.
nyuszika7h

1
@ nyuszika7h Ascii bir bayttan çok daha küçük - sadece 7 bit kullanır. Bu nedenle, bir karakteri 7 bit gösterir ve diğer dilleri buna göre ölçeklendiririm. Ancak, eğer dil ASCII değilse fakat bütün karakterlerini 7 bit olarak paketleyebiliyorsa, bu ek ücreti uygulamam. Bkz. J / K ve APL. dr Bytes daha basittir, ancak APL et. ark. ince fakat haksız bir avantaj.
isaacg,

3
@isaacg, daha küçük karakter kümeleri kullanarak sahte dillerin oluşturulmasını teşvik ediyorsunuz. 8 bitlik karakter kümelerinden farklı 7 bitlik karakter kümelerini puanlarsak, birileri en modern dilleri 6 bitte toplayabilir (64 karakter AZ, 0-9, bir miktar beyaz boşluk, 20 noktalama işareti ve bir kaçını boşa çıkarır) .
Sparr

Yanıtlar:


99

CJam - 13

q~,>{mfW=}$0=

Http://cjam.aditsu.net/ adresinde deneyin

Örnek giriş: 2001 2014
Örnek çıktı:2002

Açıklama:

q~girişi okur ve değerlendirir, yığındaki 2 sayıyı iterek (en az ve en fazla)
,dize [0 1 ... max-1] bir dizi yapar
>, [min ... max-1] ile sonuçlanır.
{…}$Sıralama anahtarını hesaplamak için bloğu kullanarak diziyi sıralar, dizinin son elemanını (W = -1) elde etmek için
mfsayının tüm asal çarpanlarını içeren bir dizi
W=alır, böylece en büyük asal çarpanı elde eder. sıralama anahtarı
0=(sıralanmış) dizinin ilk öğesini alır


38
Sanırım bu o.
Eric Tressler

5
Pyth'e bir factorize işlevi eklemem gerekiyor.
isaacg 19:14

6
Bu dil sihirbazlıktır.
Brobin

8
Bu, sadece HQ9 + s ** 'leri çekmeye, deliksiz kalmadan olabildiğince çekmeye yakındır. Korku veren!
Ingo Bürk

25
ノ ༼ ຈ ل͜ ຈ ༽ ノmfWbiri 13 karakterde çözdü.
internets teh'de 19:14

66

Regex ( .NET PCRE lezzet), 183 129 bayt

Bunu evde denemeyin!

Bu gerçekten kazanmak için bir rakip değil. Fakat Eric Tressler, bu sorunu bir regex dışında hiçbir şey olmadan çözmeyi önerdi ve ben de buna izin veremedim. Bu PCRE'de de mümkün olabilir (ve hatta daha kısa, aşağıya bakınız), ancak çözümümün isteğe bağlı uzunlukta görünmelere ihtiyacı olduğu için .NET'i seçtim. İşte başlıyoruz:

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

Giriş, her iki sayının 1s kullanılarak unary notasyonunda verildiği, virgülle ayrılmış bir aralık olarak kodlanmıştır . Maç sondaki olacak Sburada 1s Saralığında yumuşak sayıdır. En küçük sayı lehine bağlar koptu.

Dolayısıyla, sorudan ikinci örnek aşağıdaki dize olacaktır (altı çizili eşleşme).

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

Varyasyonları oraya 6 kez gömülü olan (şimdiye kadar oldukça iyi bilinen) prime kontrol eden regex'e dayanır .

İşte neler olup bittiğini bilmek isteyenler için boşluğu ve yorumları kullanan bir versiyon.

# 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

Buradan çevrimiçi olarak test edebilirsiniz . Yine de çok büyük girdiler denemeyin, bu canavarın performansı hakkında hiçbir garanti vermiyorum.

Düzenle:

Bunu PCRE'ye aktardım (sadece iki adım gerektirir) ve regex'i neredeyse üçte bir oranında kısaltdım. İşte yeni sürüm:

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

Bu aslında iki değişiklikle aynı:

  • PCRE keyfi MINgruba bakmayı desteklemiyor (ki bu gruba girerdim 1). Ancak, eşleşmenin başlangıcını geçerli imleç konumuna sıfırlayan PCREdesteği destekliyor \K. Dolayısıyla , zaten iki bayttan tasarruf sağlayan (?<=^(1+),.*)olur ^(1+),.*?\K.
  • Gerçek tasarruf PCRE'nin özyinelemesinden kaynaklanıyor. Aslında özyineleme kullanmıyorum, ancak alt rutin bir aramaya benzer şekilde (?n)grubu nyeniden eşleştirmek için kullanabilirsiniz . Orijinal regex, bir sayının en büyük asal çarpanını iki kez bulma kodunu içerdiğinden, ikincisinin tüm kütlesini basit bir şekilde değiştirebildim (?2).

37
Tanrının kutsal annesi
Newb

1
@Timwi En büyük asal çarpanın (grup 3veya 7asıl) asal olduğunu kontrol etmem gerekiyor . Bu, ilk yakalamadan sonra faktörün başka bir kopyasının olmasını gerektirir; bu, asal sayılar için geçerli olmaz. Bu konuda .NET'te bir yerlere bir göz atıp oraya bir göz atmak için biraz daha geriye bakabildiğim için çalışırken, değişken uzunluktaki gözlerin bulunmamasından dolayı bu kısa PCRE sürümünde mümkün olmazdı. Muhtemelen olduğunu o biraz kısaltmak mümkün, ama sadece değişen sanmıyorum +için *işler.
Martin Ender

2
@MartinEnder Merhaba! Uzun zamandır bu zorluğun üstesinden geldiğinizi hayal ediyorum, ancak yeni gezindim, bir regex çözümü gördüm ve yardım edemedim ama bu yazının tepesindeki uyarınızı tamamen görmezden geldim :) regex'inize baktığımda ve kafam karıştığında, sıfırdan başladım ve şunu buldum: (.*),.*?\K(?=(..+)((?=((?(R)\6|\2))*$).*(?=\4$)(?!(..+)\5+$)))(?!.+(?=\1)(?=(..+)(?3)).*(?!\2)\6).+ PCRE'de 99 bayt. Ayrıca, bu sitede çalışmalarınızın çoğuna rastladım ve büyük bir hayranıyım: D Gelecekte bir regex savaşı yapmayı dört gözle bekliyorum!
jaytea

1
Bu yorumla kod golf oynuyordum, bu yüzden eki buraya koyacağım: \4$4b'yi, gözlerden dışarı alarak ve negatif gözlerden sonra yapışarak atabilirsiniz, ancak bu, performansı ciddi şekilde etkiler (her alt basamak grubu <= \ 4, yalnızca \ 4'ten ziyade kompozit olup olmadığını kontrol eder) ve daha uzun girdilerde başarısız olur.
jaytea

1
@ jaytea Sonsuza dek bu konuda size geri almak için özür dilerim. O şeyi sıfırdan yazdığına göre, ayrı bir cevap vermelisin. Bu harika bir puan ve bunun için kredi hak ediyor. :)
Martin Ender

16

Regex (PCRE lezzet), 66 (65🐌) bayt

İki regex dehası olan Martin Ender ve jaytea'nın bu kod golfüne regex çözümleri yazdığını görünce ilham aldım, kendimi sıfırdan yazdım. Ünlü prime-kontrol regex benim çözümümde hiçbir yerde görünmüyor.

Sizin için şımarık bazı regex sihri istemiyorsanız bunu okumayın. Bu sihri kendiniz bulmaya bir göz atmak istiyorsanız, ECMAScript regex’te bazı sorunları çözerek başlamanızı şiddetle tavsiye ederim:

  1. Asal sayıları eşleştir (bunu regex'te yapma konusunda henüz bilginiz yoksa)
  2. 2 kişilik güçlerin eşleştirilmesi (henüz yapmadıysanız). Ya da sadece Prime ve Powers'ı içeren Regex Golf ile çalışın . Hem Klasik hem de Teukon problem setlerini yaptığınızdan emin olun.
  3. Kompozit olabilen (ancak olması gerekmeyen) N'nin sabit olduğu (yani regex'te, girişin değil) belirtilen N güçlerine uymanın en kısa yolunu bulun. Örneğin, 6'nın yetkileri.

  4. N'in güçlerini eşleştirme yolunu bulun; burada N, sabit bir değerdir> = 2. Örneğin, mükemmel kareleri eşleştirin. (Isınma için, asal güçleri eşleştirin .)

  5. Doğru çarpım ifadelerini eşleştirin. Üçgen sayıları eşleştirin.

  6. Fibonacci sayılarıyla eşleşin (benim kadar deliyseniz) veya daha kısa bir şeye bağlı kalmak istiyorsanız, doğru üstelif ifadeleriyle eşleştirin (ısınma için, 2 değerinin gücünün 2. üssündeki logaritma ile eşleşin) bonus, herhangi bir sayı, istediğiniz şekilde yuvarlama) veya faktoring sayıları (ısınma, eşleştirme için ilkel sayılar ) için aynı işlemi yapın.

  7. Bol sayıları eşleştir (benim kadar deliysen)

  8. İstenen kesinlik için irrasyonel bir sayı hesaplayın (örneğin, girişi yuvarlanmış sonucu bir eşleşme olarak döndürerek 2'nin karekökü ile bölün)

( Yazdığım regex motoru yardımcı olabilir, çünkü sıradan matematik regex'lerinde çok hızlıdır ve doğal sayı aralıklarını test edebilen tek bir sayısal mod içerir (fakat aynı zamanda unary regex'leri veya unary sınırlayıcılarla) Varsayılan olarak ECMAScript uyumludur, ancak isteğe bağlı uzantıları vardır (seçmeli olarak PCRE'nin altkümelerini veya hatta başka bir regex motorunun sahip olmadığı bir moleküler görünüşü ekleyebilir).

Aksi halde, okumaya devam et ve ayrıca artan zorluktaki doğal sayı fonksiyonlarını (teukon'un bulmaca setinden başlayarak, bunların hepsini matematiğe çeviren, matematiksel olarak değil) başlatan ECMAScript regex'i zorlama yolunu zorlayan bu GitHub Gist'i (uyarı, birçok spoiler) okuyunuz. seyahat).

Bu sorunun diğer regex çözümlerinde olduğu gibi, girdi, bijektif unary'de virgülle ayrılmış ve kapsayıcı bir aralığı temsil eden iki sayı olarak verilir. Sadece bir numara döndürülür. Regex, aynı en küçük en büyük asal çarpanı paylaşan, aynı eşleşmeler olarak aynı sayıları döndüren tüm sayıları döndürecek şekilde değiştirilebilir, ancak değişken uzunluktaki göz kamaştırmasını gerektirir ve ya \Kbir göz kafasına yerleştirilir ya da sonucu eşleşme yerine bir yakalama olarak döndürür.

Burada, en küçük ana faktör tarafından tekrarlanan örtülü bölme işleminde kullanılan teknik , bir süre önce gönderdiğim uzunluğu dördüncü güç cevabı olan Maç dizelerinde kullanılan ile aynıdır .

Daha fazla uzatmadan: ((.+).*),(?!.*(?=\1)(((?=(..+)(\5+$))\6)*)(?!\2)).*(?=\1)\K(?3)\2$

Burada deneyebilirsiniz.

Ve boşluğu olan yorum, yorumlarla:

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

Algoritma, alt rutin çağrısını alt rutinin bir kopyasıyla değiştirerek ve eşleşmeyi \ K kullanmak yerine bir yakalama grubu olarak döndürerek ECMAScript'e kolayca aktarılabilir. Sonuç 80 bayt uzunluğundadır:

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

Çevrimiçi deneyin!

Doğru işlevsellik kaybı olmadan boyutu 1 bayt (66'dan 65 bayta ) düşürerek ((.+).*)değiştirilebileceğini unutmayın; ancak regex katlanarak yavaşça patlar.((.+)+)

Çevrimiçi deneyin! (79 bayt ECMAScript üstel yavaşlama sürümü)


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

Sayıların düzgünlüğünü, sayı 1 olana kadar deneme bölünmesiyle bulur. iBugüne kadarki en küçük düzgünlüğü kaydeder j, bu düzgünlüğü veren sayıyı saklar.

Golf için @xnor'a teşekkürler.


1
Bu if/elsekısaltılabilir olmalı. Benim ilk düşüncem b=a%p<1;p+=1-b;a/=p**b. Veya interleaved dizgide ikisinden birini çalıştıran bir uygulayıcı. Ayrıca, belki while~-açalışır.
xnor

isaacg - Bu cevabı seviyorum! En büyük ana faktörü aramanın mükemmel bir yolu! Metodunuzu ödünç almanız için cevabımı güncelledim.
Todd Lehman

Harika çözüm! , @ Xnor'ın fikirlerini kullanmak s,p=a,2, i,j=p,sgereksiz girintiyi kaldırmak ve while blokunu bir satıra koymak 95 karakter verir. Nasıl 98 ile geldiğinden emin değilim ...
Falko

bu kod ifadelerin dolu, :)
Rosenthal

@Falko bu iki değişiklik karakter kaydetmez. 7-> 7.
isaacg

10

J, 22 20 19 karakter

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

Örneğin

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

(İki argüman alan işlevler J'de eklenmiştir)


Ayrıca bir çatlağım oldu, bu cevap kadar kısa sürmedi. Yine:(#~ (= <./)@:(i:"1&1)@:*@:(_&q:))@:([ + i.@-~)
ɐɔıʇǝɥʇuʎs

İşte {:aynı >./ve 1 bayt kaydeder.
randomra

@randomra Haklısın - iyi görüşme!
FireFly

Güzel. TIO eklemek isterseniz: Çevrimiçi deneyin!
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]

GHCi (bir Haskell kabuğu) ile kullanım:

>5 # 9
8
>9 # 15
9

EDIT: şimdi çok daha basit bir algoritma.

Bu çözeltiye aralığında iki numaralarını içerir (çok 8 # 9ve 7 # 8her ikisi de 8 olan)

açıklama:

(%) işlevi iki parametre alır, x ve y. y 2 olduğunda, işlev x'in düzgünlüğünü döndürür.

Buradan algoritma basittir - Girdideki sayıların tüm düzgünlüklerinin bir listesini, her bir düzgünlükle birlikte orijinal numarasına bir referans saklayarak, sırayla en küçük olanı almak ve sıralanan numarayı döndürmek için bir araya getirin.


Burada aynı algoritma ile bir ungolfed javascript sürümü:

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

Daha kısa bir şeye minimum takma ad vermek mümkün müdür? Bazı karakterleri koruyacak gibi görünüyor.
isaacg

Denedim, fakat monomorfizm kısıtlama aslında bir karakter maliyeti
gururlu haskeller

Sadece yapamaz m = minimum? Haskell hala bir gizemdir.
isaacg

1
@isaacg Monomorfizm kısıtlamasını aşmak için bir yazmak zorunda kalacaktınızm l=minimum l
gururlu haskeller

2
Eksik versiyonumu bile yenen seninkini görene kadar Haskell çözümü
yayınlayacaktım

9

Mathematica, 61 45 39 karakter

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

Adlandırılmamış bir işlev olarak belirtimin çok basit bir şekilde uygulanması.

  • Aralığı (dahil) alın.
  • Tüm tam sayıların faktörü.
  • En büyük asal çarpana göre sıralanmış en düşük değeri bulun.

8

Lua - 166 karakter

Ben yok yorumlamak (! Henüz) yeterince itibar yoktu AndoDaan çözümüyle , ama burada onun kod üzerinde bazı iyileştirmeler vardır

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)

Değişiklikler:

  • n%d==0Tarafından n%d<1, bu durumda eşdeğerdir
  • Boşluk kaldırıldı
  • table.insert(f,d)Tarafından değiştirilir f[#f+1]=d ( #ff'nin element sayısıdır)

Ah, buraya baktığım için memnunum. Ah, ilk ikisini kontrol etmeli ve yakalamalıydım, ama üçüncü gelişiminiz benim için yeni (demek istediğimden farklı olarak). Bu bana golf.shinh.com adresinde ve daha fazlası için çok yardımcı olacak. Teşekkürler!
AndoDaan

8

Bash + coreutils, 56 bayt

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

Girdi tam olarak iki komut satırı argümanından (Thanks @ nyuszika7h !!!). Çıktı, STDOUT'a basılan tekil bir sonuçtur.

  • seq komut satırı argümanlarından, her satıra bir tane olmak üzere sayı aralığını sağlar.
  • factorbu sayıları okur ve her sayının ardından bir iki nokta üst üste ve o sayının asal çarpanlarının sıralanmış listesini okur. Bu yüzden en büyük ana faktör, her satırın sonundadır.
  • Birincisi sed, kolonu ve son / en büyük asal çarpan hariç hepsini kaldırır, böylece her sayının (sütun 1) ve en büyük asal çarpanın (sütun 2) bir listesini bırakır.
  • sort Sayısal olarak sütun 2 ile artan düzende.
  • Son sedeşleşme satırı 1 (en büyük asal çarpanı, listedeki en küçük sayıdır), ilk boşluk ve sonrasındaki her şeyi kaldırır, sonra çıkar. sedçıkmadan önce bu ikamenin sonucunu otomatik olarak yazdırır.

Çıktı:

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

Bu bağlamda Not aralıklarıdır dahil her iki uç noktası arasında.


1
seq $@İki bayt daha kısa, sadece iki argüman olduğunu varsayabilirsin.
nyuszika7h

@ nyuszika7h Güzel fikir - teşekkürler!
Dijital Travma,

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)

Başka bir golf hakkında düşünmek düzgünlüğü kontrol etmek için yeni bir algoritma için bir fikir verdi, bu yüzden geç cevap.

Faktörlerin temel çarpanlara i!ayırması en fazla tam olarak asal sayıları içerir i. Yani, eğer nfarklı asal bir ürünüdür, onun düzgünlük (en büyük asal faktör) küçüğüdür ihangi nbir bölen bir i!. İçinde tekrarlanan ana faktörleri hesaba katmak için n, bunun yerine yeterince yüksek bir güç kullanabiliriz i!. Özellikle, (i!)**nyeter.

Kod art F=i!arda güncellenen, artımlı yüzdeleri dener . FGirdi aralığındaki bölenleri filtreler , varsa varsa çıktılar ve başka yollara gideriz (i+1)!.

Test durumu:

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

4

C,  149   95

Düzenlenmiş cevap:

Bu çözüm için kredi talep edemiyorum. Bu güncellenmiş cevap, isaacg tarafından Python çözümünde kullanılan güzel yöntemi ödünç alıyor . C'de küme parantezi olmayan bir iç içe for/ whiledöngü olarak yazmanın mümkün olup olmadığını görmek istedim ve öyle!

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

Açıklama:

  • Fonksiyon R(a,b,n,q,p,m)aralığını tarar aiçin b-1ve bulunan ilk akıcı numarasını döndürür. Çağırma aşağıdaki forma uygun olarak yapılmalıdır: R(a,b,a,b,2,0)işlevi içinde değişkenlerin etkili bir şekilde aşağıdaki şekilde başlatılır, böylece: n=a;q=b;p=2;m=0;.

Orijinal cevap :

Bu benim orijinal cevabımdı ...

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

Açıklama:

  • İşlev asallık P(n,f,p)değerini test eder nve nasal ise sıfır (sıfır) , asal değilse yanlış (sıfır) döndürür n. fve pher ikisi de 1 olarak geçirilmelidir.
  • İşlev G(n,f), en büyük asal çarpanını döndürür n. folarak geçirilmeli n.
  • Fonksiyon R(a,b,p,n)aralığını tarar aiçin b-1ve bulunan ilk akıcı numarasını döndürür. Herhangi bir değer olabilir p1. olarak geçirilmesi gerekir n.

Test sürücüsü:

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

Çıktı:

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

Bunun, "Girişte kodlamada fazla bilgi yok" cümlesi "ne düştüğünü iddia ediyorum.
Simyacı

@Alchymist - Haklı olabilirsin ... ama sözde tartışmalarda gerçek bir fazla bilgi olmadığını sanmıyorum. En azından cevabı herhangi bir ipucu olan hiçbir bilgi.
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)

Örnek kullanım:

> 5 ! 10
8
> 9 ! 15
9
> 9 ! 16
16
> 157 ! 248
162
> 2001 ! 2013
2002

1
Kullanmak Could <1yerine ==0?
dfeuer

Evet, bu iyi bir gelişme olur. Daha iyi yapılabilecek birçok küçük şey var. Neyse ki bu cevap zaten hepsini yapıyor: 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 muhtemelen bir düzine karakter tıraş eder

düzenleme: gerçekten, bu kez üst sınır sınırsız olarak kabul

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

4

Not: Bu cevaba izin verilmiyor.

Bu cevap, meydan okuma istendikten sonra eklenen Pyth'in çoklu özelliklerini kullanır.

2 elemanlı bir bağlantıya unary aralığı çağırarak, çözümü iki karakterle kısaltan yeni bir özellik daha ekledim:

Pyth , 7

hoePNUQ

Giriş şimdi virgülle ayrılmış olarak alınmıştır. Gerisi aynı.


Bu cevap, özellikle @ aditsu'nun harika CJam çözümünü gördükten sonra, bu soru sorulduktan sonra eklenen Pyth özelliğini kullanıyor. Olduğu söyleniyor, bu özelliği ne eklemenin mümkün olduğunu göstermek istedim. Bu özellik, Ptamsayı girişinde girişin tüm asal çarpanlarının bir listesini döndüren, en küçüğünden en büyüğe sıralanan bir arity-1 işlevidir.

Pyth , 9

hoePNrQvw

STDIN'de ayrılmış yeni satır olan Python stili aralıkları kullanır. STDOUT'a en küçük çözümü sunar.

Açıklama:

      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.

Testler:

$ 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

@ MartinBüttner Yep, CJam çözümü hakkındaki yorumunda önerildiği gibi
Adriweb

@ MartinBüttner Evet, P, yeni özellik. Bunu cevaba koyacağım.
isaacg

1
İzin verilebilir veya değil, sadece hoşuma gitmiyor, aynı zamanda dikkat ederseniz bu kısa "makroların" okunabilir olduğunu düşünüyorum - sonuçta basit Python'a dönüşüyorlar. Bir golf dili için, golf için iyi olan ancak zorunlu olarak şaşırtmayan bir şey söylenmesi gerekir.
Kuba Ober

@KubaOber Teşekkürler, Kuba. Bu her zaman Pyth yazma, mümkün olduğunca golf oynamaya ve okunabilir hale getirme niyetim olmuştur. Çalışmasına sevindim.
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)

Lua'da golf oynamayı bırakmalıyım. Anlamı yok.


14
IMHO, kod golf oynamak boks gibidir: ağırlık sınıfları vardır. Belirli bir dil tam olarak kazanamayabilir, ancak bu sınıf / dil içinde golf oynamak eğlenceli ve aydınlatıcıdır.
Michael Easter,

3

Clojure - 173 170 karakter

Ben bir Clojure acemiyim. golfed:

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

Örnek çalışır:

Aralıklar alt uç içerir, üst uç hariç: [a, b) Birden çok gerçekleşirse, yalnızca en yumuşak sayılardan birini yazdırır.

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

verim:

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

Ungolfed:

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

1
Düşük ucu içeren ve yüksek ucu hariç tutan bir aralık genellikle yazılır [a, b).
murgatroid99

evet, not için teşekkürler
Michael Easter

3

Ruby, 65 62

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

Https://codegolf.stackexchange.com/a/36484/6828 adresinden özür dileriz , bu onun golf (ve biraz basitleştirilmiş) versiyonudur. Karakter kısa olduğundan, kapsamlı bir aralık kullanır.

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 

Ve üç karakter tasarrufu için YenTheFirst'e teşekkürler.


1
Gerçekten de [0] olmadan kurtulabilirsiniz, çünkü dizi karşılaştırması yine de ilk öğeye öncelik verecektir. Bu, farklı fakat yine de doğru sonuçlar verecektir.
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;}}

Ungolfed:

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

Komut satırından başlar ve uzunluğu alır ve en büyük düzgün sayıyı döndürür.

Cevabımı vermek için buradan ve buradan cevaplar kullandım .

Düzeltme ve 12 byte tıraş için VisualMelon'a teşekkürler! Ayrıca 2 bayt kurtarırken parantezden kurtuldum ve CodeInChaos kaçırdığım bazı belirgin şeylere dikkat çekti (tekrar teşekkürler).


Genel amaçlı küçük şeyler birkaç, m yanında Ftanımlayarak 4 bayt tasarruf edebilirsiniz int b. Yerlerde bir çift olarak size karşılaştırma yapmak a%b==0ve ave bher zaman 1'den az ise kontrol ederek her biri için bir bayt kesebilir olumludur a%b<1. Ayrıca bir bayt'ı, yerine 1 yerine bbaşlayarak a%++b<0yerine if'in durumunda artırarak kaydedebilirsiniz. Ayrıca, bu durumda System.Console.WriteLine, namespacemaddeyi tamamen nitelemek ve bundan kaçınmanın daha ucuz olduğunu düşünüyorum .
VisualMelon

@VisualMelon Teşekkürler, fikirlerinizle güncellendi :)
ldam

m=...:m;Zımbırtı ise döngü dışında kalıyor. Bu nedenle, bırakın m=0,ve değiştirme return m;ile return m=b>m?b:m;. Ardından, m=...:m;tamamen bırakabilirsiniz .
14'te

Kulağa garip gelebilir, ancak bu - benim için CJam ve J'den daha az okunaklı olabilir. Sanırım C # ayrıntılı olarak tasarlandı ve bunu daha az yapmayı deniyor, böylece okunamaz hale getiriyor? Hmm ....
Kuba Ober

Hayır, katılıyorum, LINQ burada ve orada gördüğünüzde ve aslında kendinizle oynamadığınızda bir iblis gibi görünüyor. Yine de kavradığınızda, gerçekten çok güzel :) Bununla birlikte, hala tam olarak nasıl Aggregateçalıştığını tam olarak anlamadım , sadece içindeki bir alan yerine yeni nesneme ulaşmak için başka bir cevapta gördükten sonra denedim ve Sadece mükemmel çalışması oldu :)
ldam

2

R, 83

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

giriş aralığının alt kısmının atandığı ave üst kısmının (dahil) olduğu konum b.

gmpCRAN'da mevcut olan bir pakettir. mfCJam’daki bu saçma işlevi görene kadar kirli hissettim . install.packages("gmp")Konsola yazarak yükleyin .


1
lapply3 kez kullanıyorsanız takma isimlendirmek isteyebilirsiniz (yani l=lapply, sonra kullanın l(...). Benzer şekilde factorize, paketten kullandığınız tek işlev olduğundan , kitaplığı yüklemek ve sonra gmpkullanmak gmp::factorizeyerine kullanabilirsiniz factorize. Böylece kodunuz l=lapply;n=a:b;n[which.min(l(l(l(n,gmp::factorize),max),as.numeric))]69 bayt olur.
plannapus

2

PowerShell - 85

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

Bu, her sayının maksimum asal çarpanına bağlı olarak bir sayıları sıralar (dahil). En düşük sıralı öğeyi döndürür.

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

2

J - 16 karakter

Yorumların izin verdiği şekilde ( başlangıç , uzunluk ) aralık stilini kullanma .

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

İkili fiil olarak kullanılmak üzere: sol argüman başlar , sağ uzunluktur .

   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

Bir ( başlangıç , son ) çözümü +2 karakterdir ve sonu hariç tutar; sonu da dahil olmak üzere +2 daha fazla. Ama parlak tarafta, tüm {parantezleri} eşleştirdiğimiz için çok hoş görünüyor.

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

2

Cidden, 8 * 14/7 = 16 (rekabetçi değil)

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

Bu zorluğun ardından ciddi bir şekilde yaratıldı, ancak bu cevabı göndermek istedim çünkü bu tür zorlukların örneklerini ciddiye alıyor.

Çevrimiçi deneyin!

Açıklama:

,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

2

Pyth , 7 bayt

.mePbrF

Burada dene!

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

1

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

Neden rahatsız ettiğimden bile emin değilim, kobra burada rekabet edemez.


1
Kobra python ile aynı görünüyor ... Farkları nelerdir?
Beta Çürümesi

@BetaDecay Cobra, Python'un C # sözdizimini verdiğinizde gerçekleşen şeydir. Cobra İnternet sitesi
Augurous

1

Yakut - 113 karakter

Stdlib'i kullanma. Bir sonuç döndürür. Yakut üzerinde test edilmiştir 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

1
Programlama Bulmacaları ve Kod Golf Yığın Değişimine Hoş Geldiniz. Sonucunuzu gönderdiğiniz için teşekkür ederiz. Bu bir kod golf sorusu olduğundan, lütfen cevabınıza karakter sayınızı da ekleyin. Bunun gibi bir araç kullanabilirsiniz: 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

(satır sonu kaldırılabilir). İki stdin çizgisinde ( <>erişimden daha ucuz olduğu için ARGV) kapsayıcı bir aralığın iki uç noktasını alır ve en yumuşak ila orta kesiti verir. En pürüzsüz bir kravat varsa, en küçük yazdırır. Bir karakter karşılığında en büyüğü basabilir.

Algoritma temelde bağımsız bir şekilde ortaya çıkmamıza rağmen, en büyük asal çarpanı bulma yoludur. Bu kısım perl'deki tek bir ifadeye göre güzelce golf oynuyor, gerisi sandığımdan daha fazla ek yüke sahip.

perl -EBir use 5.012başlangıç ile veya altında çalıştırılmalıdır . Bunu yapamıyorsanız, yerine say$rile print$r,$/.


1

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

@ isaacg'ın çözümü , ancak minaçık min-bulma yerine bir işlev tuşu ve yinelemenin rolünü oynayan özyinelemeli bir işlev.

Özyineleme sınırlarını önlemek için Stackless Python ile çalıştırın .

Parantez içindeki durumu kullanmak çok zararlı görünüyor (n%p<1), sonra paranthez'lerde de olumsuzluğunu tekrar ediyor (n%p>0), ama en iyisiydi. Bir sürü şey denedim ama daha da kötüye gitti.

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

Aklınıza gelebilecek herhangi bir gelişme bekliyoruz.


1

Java 8 - 422 454 karakter

Java 8'i öğreniyorum ve buna Java (ya da hatta Java 8 akışlarına) göre bir şans vermek istedim.

Diğer dillerle karşılaştırıldığında, bu acımasız ama ilginç bir alıştırma.

golfed:

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

Ungolfed:

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

Örnek kullanarak çalıştırmak:

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

192

1

MATL ( rekabetçi olmayan ), 20 bayt

Bu dil mücadeleden sonra tasarlandı

Her iki uçta da menzil dahil. Sayılar iki ayrı giriş olarak alınır.

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

Çevrimiçi deneyin!

açıklama

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

Sanırım bugün bu 17 bayt &:[]y"@YfX>h]&X<)veya belki 16 olur :[]y"@YfX>h]&X<). &Gerçekten harika bir fikir olduğunu (ve tahmin ediyorum yo zamanlar mevcut değildi?).
sundar

Ön Yfek 1'lerle yayın burada da yararlı olurdu, ancak genel olarak iyi bir fikir olduğuna karar vermek için yeterli değil gibi görünüyor . :)
sundar

Evet, bu başlangıçtı, yani hayır yya da &. İkincisinin çok yararlı bir semantiği için Suever'e teşekkür edin (ilk fikrim "varsayılandan daha fazla bir giriş" anlamına gelmesiydi). Bunları Yfeklemenin yararlı olabileceği daha fazla örnek görürsek , bu özelliği eklemeye gerçekten değer olabilir. Sorun şu ki, Yf( bu betiğe göre ) kullanan yaklaşık 34 cevap var , bu yüzden söylemek zor
Luis Mendo

1

Jöle , 7 bayt, puan = 7 ÷ 7 × 8 = 8, dil kayıt sonrası mücadelesi

rÆfṀ$ÐṂ

Çevrimiçi deneyin!

Alt ve üst aralık uç noktalarını iki ayrı argüman olarak alır. Aralıktaki en düzgün sayıların listesini çıkarır. (Bu bir fonksiyon olarak görülebilir, bu durumda çıkış bir Jelly listesi veya tam bir program olarak, bu durumda çıkış JSON'un yaptığı aynı liste gösterimini kullanır.)

açıklama

Jelly programınız sadece spekülasyonların tam anlamıyla çevirisi olduğu zamanlar…

rÆfṀ$ÐṂ
r        Range from {first argument} to {second argument}
     ÐṂ  Return the elements which have the minimum
   Ṁ$      largest
 Æf          prime factor
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.