_{( sohbet yoluyla )}

OEIS girişi A123321 , yedi farklı asalın ürünü olan sayı dizisini listeler. Kısacası, buna 7DP numarası diyeceğiz . İlk birkaç sayı ve karşılık gelen bölücüler aşağıdadır:

510510 = 2 * 3 * 5 * 7 * 11 * 13 * 17
570570 = 2 * 3 * 5 * 7 * 11 * 13 * 19
690690 = 2 * 3 * 5 * 7 * 11 * 13 * 23
746130 = 2 * 3 * 5 * 7 * 11 * 17 * 19

Buradaki zorluk, belirli bir girdiden mutlak mesafe açısından en yakın 7DP numarasını bulmak olacaktır.

Giriş

Herhangi bir uygun formatta tek bir pozitif tamsayı n .

Çıktı

Herhangi bir uygun formatta n'ye en yakın 7DP numarası . En yakın iki 7DP numarası bağlıysa, bunlardan birini veya her ikisini birden verebilirsiniz.

kurallar

• Sayıların dilinizin varsayılan [int]veri türüne (veya eşdeğerine) uyduğu varsayılabilir .
• Tam bir program veya bir işlev kabul edilebilir.
• Standart boşluklar yasaktır.
• Bu kod golf , bu nedenle her zamanki golf kuralları geçerlidir ve en kısa kod kazanır.

Örnekler

5 -> 510510
860782 -> 870870
1425060 -> 1438710 (or 1411410, or both)

Python, 89 86 85 bayt

f=lambda n,k=0:126^sum(1>>n%i<<7*(n/i%i<1)for i in range(2,n))and f(n+k,k%2*2+~k)or n

Algoritma başlamak için O (korkutucu) ve özyineleme gerçekten yardımcı olmuyor, ancak n 7DP numarasına yeterince yakın olduğu sürece iyi çalışıyor .

3 bayt golf için @xnor sayesinde!

Repl.it üzerinde test edin .

Nasıl çalışır

Python'da öncelik veya çarpanlara ayırma yerleşikleri yoktur, ancak 7DP sayılarını bölenlerinin miktarına ve doğasına göre belirleyebiliriz.

Çarpma ilkesi ile, bir tamsayının bölenlerinin sayısı, asal çarpanlarına ayırma işleminin artan üslerinin ürünü olarak hesaplanabilir. Bu nedenle, n bir mDP sayısı olduğunda σ ₀ (n) ( bölücü işlevi ) 2 ^m'dir .

σ ₀ (n) = 128 bu nedenle gerekli bir durumdur, fakat yeterli değildir; örneğin, σ ₀ (2 ¹²⁷ ) = 128 , ancak 2 ¹²⁷ açıkça bir 7DP numarası değildir. Bununla birlikte, hem σ ₀ (n) = 128 hem de mükemmel kare n'yi eşit olarak bölmezse, n bir 7DP sayısıdır.

N girişi için , algoritma n , n - 1 , n + 1 , n - 2 , n + 2 vb . Tamsayıların incelenmesinden ve 7DP sayı olan ilkinin döndürülmesinden oluşur.

Ne zaman f argümanı ile çağrılır n başladığında:

• Kod

  126^sum(1>>n%i<<7*(n/i%i<1)for i in range(2,n))

  Testler eğer n olduğu değil şöyle bir 7DP numarası.

  Tüm tamsayılar için ben öyle ki 1 <i <n , 1>>n%i<<7*(n/i%i<1)değerlendirilir alır.

  • Eğer , n bölünemeyen i tarafından değil ı ² , 1>>n%iverim 1 ve (n/i%i<1)verimleri 0 ile sonuçlanan,
    1 · 2 ^{7 · 0} = 1 .

  • Eğer , n bölünebilen i ² , 1>>n%ive (n/i%i<1)her ikisi de verimle 1 ile sonuçlanan, 1 · 2 ^{7 · 1} = 128 .

  • Eğer , n bölünebilir değil i , 1>>n%iverim 0 sonuçlanan · 2 0 ^{7 ax} = 0 .

  
  Elde edilen tam sayı toplamı olacaktır 2 ^m - 2 ise , n , bir MDP numarası (kendi olan 2 ^m bölenler hariç 1 ve n ) ve daha büyük bir sayı 127 , eğer , n , bir tam kare faktör vardır. Dolayısıyla, toplam n sadece 7DP bir sayı ise 126 olacaktır .

• 7DP numaraları için, toplamı 126 çok ile xoring, 126 verim 0 falsy olup,. Böylece, lambda veya bir kısmı yürütülür ve f n'nin geçerli değerini döndürür .

• Eğer n, bir 7DP sayı değil, XOR sıfır olmayan, truthy değerini döndürür. Böylece, lambda ve kısmı yürütülür.

  f(n+k,k%2*2+~k)

  tekrarlayan n değerini (bir sonraki potansiyel 7DP numarası) ve k (yeni aday ile bundan sonraki aday arasındaki fark ) güncellenmiş f ile çağırır .

  Eğer k eşit, negatif olmayan bir tamsayıdır, k%2*2verimleri 0 ve ~kverimler (k + 1) - . Her iki sonucun toplamı - (k + 1) 'dir ; bu, mutlak değerde k'den 1 daha büyük olan tek, negatif bir tamsayıdır .

  Eğer k bir tek, pozitif bir tamsayıdır, k%2*2verimleri 2 ve ~kverimler (k + 1) - . Her iki sonucun toplamı 2 - (k + 1) = - (k - 1) 'dir ; bu, mutlak değerde k'den 1 birim daha büyük olan eşit, negatif olmayan bir tamsayıdır .

  Bu, k'nin 0, -1, 2, -3, 4, values değerlerini aldığı anlamına gelir .

  Kümülatif olarak ilave zaman n ₀ (başlangıç değeri n ), elde edilen tamsayılardır

  • n ₀ + 0
  • ( N, ₀ + 0) - 1 = n- ₀ - 1
  • ( n _0-1 ) + 2 = n ₀ + 1
  • ( n ₀ + 1) - 3 = n ₀ - 2
  • ( n _0-2 ) + 4 = n ₀ + 2
  • vb.

  
  yapım emin Karşılaştığımız ilk 7DP numarası için yakın gibidir n ₀ olabildiğince.

Brachylog , 44 40 16 bayt

_{Çarpılan 44 hala düzenli 44;}

:I=+.>0,.$pPdPl7

Misal:

?- run_from_atom(':I=+.>0,.$pPdPl7',1425060,Z).
Z = 1438710 .

Bu dil her zaman berbat olmayabilir mi? Jelly ve MATL'i yendim!

Test durumu 5en uzundur ve makinemde yaklaşık 10 saniye sürer.

Eğer $phata değildi bu 12 bayt olurdu (biz >0,.parçası gerekmez )

açıklama

Brachylog, tüm tamsayı aritmetikleri için varsayılan olarak kısıtlama mantığı programlamasını kullanır. Dahası, etiketleme yerleşik =olarak muhtemelen sonsuz alanlarda çalışır.

Bu arka arkaya herhangi bir kısıtlar (yani bir değişken birleştiren (-inf, inf)gibi): 0, 1, -1, 2, -2, 3, ….

Bu nedenle, 7DP numarası olan Ibirleştirilmiş (-inf, inf)(otomatik geri izleme özelliğini kullanarak) ilk sayıyı arayarak en yakın 7DP numarasını elde edebiliriz Input + I.

:I=                Label variables in [Input, I]. I has no constraints and Input is known
   +.              Unify Output with Input + I
     >0,           Output > 0 (wouldn't be needed if $p failed for numbers less than 1)
        .$pP       Unify P with the list of prime factors of Output
            dP     Check that P with duplicates removed is still P
              l7   Check that the length of P is 7

Jöle, 17 bayt

Pµạ³,
×⁹ÆRœc7Ç€ṂṪ

Teoride çalışır, ancak tamamlanması yıllar alır.

Verilen girdiler için gerçekten çalışan ancak teorik olarak büyük girdiler için başarısız olan bir sürüm:

Pµạ³,
50ÆRœc7Ç€ṂṪ

Burada deneyin. Bu, 50'ye kadar tüm primerleri üretir, daha sonra bu listedeki 7 primin kombinasyonunu ve ardından tüm ürünlerini bulur. Son olarak, bu listeden verilen argümana en yakın elemanı bulur.

Tabii ki, 7DP'lerimiz 50'den yüksek primler içerdiğinde, bu başarısız olacaktır. Teorik sürüm , bir giriş n için 256n'ye kadar olan tüm primerleri üretir , ancak aksi takdirde aynı şekilde çalışır.

Kanıt

Let p(x)sonraki asal göstermektedirler x. X'e en yakın 7DP ürünü için (aşırı gevşek) bir üst sınır:

p(x) * p(p(x)) * p(p(p(x))) * ... * p(p(p(p(p(p(p(x)))))))

Bu yüzden sadece [2… p (p (p (p (p (p (p (x)))))))]] içindeki primerleri kontrol etmemiz gerekir . Bertrand'ın postüla söylüyor p (x) ≤ 2x bunun için Tüm asal kontrol etmek yeterli böylece, 128x .

MATL , 21 17 16 14 13 bayt

4 bayt ve 1 bayt tasarruf sağlayan bir öneri için Dennis'e teşekkürler!

t17*Zq7XN!pYk

Bu teoride çalışır, ancak yukarıdaki girdiler için bellek tükenir 6(çevrimiçi derleyici).

Daha verimli bir sürüm 21 bayt kullanır ve tüm test senaryolarını yaklaşık bir saniye içinde hesaplar:

t3e4/k16+_YqZq7XN!pYk

Çevrimiçi deneyin!

• Bellek yetersiz sürümü
• Bellek tasarruflu sürüm
• Bellek tasarruflu versiyon, tüm test senaryoları

açıklama

Bellek tasarruflu sürüm

Örnek olarak N = girişini ele 860782alalım. N ile çarpılan ilk asal olan M = 'e kadar olan primleri dikkate almak yeterlidir . Bu örnekte ,. Bir sonraki başbakan . Bu prime veya daha büyük bir ürünü içeren herhangi bir ürün en azından olacaktır ve bu nedenle çözüm olmadığı garanti edilir, çünkü N'yi aşan aşar .292*3*5*7*11*132*3*5*7*11*13*29 = 870870312*3*5*7*11*13*31 = 930930870870

M , ilk asıldan büyük olarak hesaplanır max(N/(2*3*5*7*11*13), 16). maxFonksiyonu, en azından sağlamak için kullanılan 17alınır. Birkaç bayt kod yerine geçer kaydetmek için 2*3*5*7*11*13 = 30030tarafından 30000ve işlevini maxilavesiyle. Bu değişiklikler daha büyük bir değer verdikleri için geçerlidir.

t      % Take input implicitly. Duplicate
3e4/k  % Divide input by 30000 and round down (rounding here is only needed
       % due to a bug in the "next prime" function)
16+    % Add 16
_Yq    % Next prime
Zq     % Prime numbers up to that value
7XN    % Combinations of those primes taken 7 at a time. Gives a 2D array
       % with each combination on a different row
!p     % Product of each row
Yk     % Output product that is closest to the input. Implicitly display

Bellek yetersiz sürümü

Bayt sayısını daha da azaltmak için bölüm çıkarılabilir; aslında, ile çarpmak yeterlidir 17(teşekkürler, @Dennis). Bu, bir sonraki asalın dahil edilmesini ( Bertrand'ın postülasına göre ) ve sonucun en azından olmasını sağlar 17. Bu teoride çalışır, ancak yaklaşık büyük girişler için bellek yetersiz kalır 6.

Kodda, bölüm

3e4/k  % Divide input by 30000 and round down (rounding here is only needed
       % due to a bug in the "next prime" function)
16+    % Add 16
_Yq    % Next prime

ile değiştirildi

17*    % Multiply by 17

Pyke, 32 bayt

#PDl 7q.ID}lRlqi*(#)DF-X,)R],She

Burada deneyin!

Bunun çevrimiçi çalışmadığını unutmayın - zaman aşımına uğradı. Bu Sürüm yalnızca 2 farklı asayı kontrol eder ve daha hızlı çalışmalıdır. Hedeften aynı uzaklıkta olan 2 sayı olduğunda, daha düşük olanı seçer.

Bu, girişten daha büyük olan ve 7DP olan birini bulana kadar tüm sayılardan geçer. Her sayı için, 7DP değilse ondan kurtulur. Daha sonra girişe kadar daha büyük olan 7DP'lik bir listeye sahiptir. Daha sonra girişe en yakın olanı seçer.

Julia, 59 bayt

!n=sort(map(prod,combinations(17n|>primes,7))-n,by=abs)[]+n

Bu çok verimsiz olmakla birlikte, uygulamadaki ilk test durumu ve teorik olarak diğerleri için çalışır.

5 baytlık bir maliyetle - toplam 64 bayt için - verimlilik önemli ölçüde artırılabilir.

!n=sort(map(prod,combinations(n>>14+17|>primes,7))-n,by=abs)[]+n

Çevrimiçi deneyin!

Arka fon

@ LuisMendo'nun cevabında belirtildiği gibi , en yakın 7DP sayısı için dikkate almamız gereken asal sayı seti oldukça azdır. Giriş daha büyük olan bir 7DP sayı içerir için bu dizi için yeterli n ve birinci sınıf bir içeriyorsa, eğer doğru olacaktır, p ≥ 17 bu şekilde 2 = 30300p · 3 · 5 · 7 · 11 · 13 · s ≥ n .

İçinde en az bir asal sayı içeren aralığı üzerinde aralık kanıtlamaktadır [x, 1,5 x) en az bir asal sayı her içerir x ≥ 8 . Yana 30030/16384 ≈ 1.83 , bu araç, bir birinci olmalıdır s olarak (n / 30030 N / 16384) her n> 8 · 30300 = 242400 .

Son olarak, n <510510 olduğunda , p = 17 açıkça yeterlidir, bu yüzden sadece n / 16384 + 17'ye kadar olan primerleri dikkate almamız gerekir .

Verimlilik pahasına, bunun yerine 17n'ye kadar olan primerleri düşünebiliriz . Bu eserler , n = 1 ve daha çok büyüktür n / 16384 + 17 daha büyük değerler için n .

Nasıl çalışır

17n|>primesve n>>14+17|>primes(bit kaydırma, 2 ¹⁴ = 16384'e bölünmeye eşittir ), önceki paragrafta belirtilen ana aralıkları hesaplar. Ardından, combinations(...,7)bu aralıktaki yedi farklı asal sayının tüm dizilerini hesaplar ve prodbunların üzerinde eşleme , ürünlerini, yani yanıtı seçeceğimiz 7DP sayılarını hesaplar.

Daha sonra, her 7DP numarasında n prom -nçıkarır , sonra bu farkları mutlak değerlerine göre sıralar. Son olarak, birinci fark seçmek ve eklenerek karşılık gelen 7DP sayısını hesaplayın n ile .sort(...,by=abs)[]+n

Pyth, 30 bayt

L&{IPbq7lPby#.W!syMH,hhZa0teZ,

Çevrimiçi deneyin!

Test odası.

(5'in çalışması çok uzun sürüyor)

açıklama

L&{IPbq7lPby#.W!syMH,hhZa0teZ,

L&{IPbq7lPb     Defines a function y, whose argument is b:
 &                  Return if both the following are true:
  {IPb                  the prime factorization contains no duplicate; and:
      q7lPb             the number of prime factors is 7

           y#.W!syMH,hhZa0teZ,   The main programme. Input as Q.
                             ,QQ Implicit arguments, yield [Q,Q].
             .W                  While
               !syMH                   both numbers do not satisfy y:
                    ,hhZ             increment the first number
                          teZ        and decrement the second number
                        a0           while making it non-negative.

Mathematica 136 80 75 bayt

Bu, dışa doğru çalışan basit bir yaklaşımdır n.

nasal faktör sayısı 7 ( PrimeNu@#==7) ise ve bu faktörlerin hiçbiri bir kereden fazla ( SquareFreeQ@#&) görünmüyorsa , 7 farklı prime ürünüdür .

g@n_:=(k=1;While[!(PrimeNu@#==7&&SquareFreeQ@#&)⌊z=n-⌊k/2](-1)^k⌋,k++];z)

Daha önceki gönderimim (136 bayt) hem yukarıdaki ilk 7 farklı ana ürünü nhem de varsa, aşağıdaki ilk 7 farklı ana ürünü buldu n. Daha sonra hangisine daha yakın olduğunu belirledi n. Ürünler eşit uzaklıkta olsaydı, her ikisini de geri verdi.

Mevcut sürüm, ilk 7 farklı ana ürüne ulaşıncaya kadar n-1, n + 1, n-2, n + 2 ... 'yi kontrol eder. Bu daha verimli versiyon Dennis'in benimsediği yaklaşımı benimser.

Anahtar ilerleme ⌊k/2](-1)^k⌋, 0, 1, -1, 2, -2 serilerini döndürmek için kullanılıyordu ... Sıfır n, kendisinin 7 farklı bir birincil ürün olup olmadığını kontrol etmek için kullanılır . Bu nedenle, Floor(yani ⌊...⌋) yerine kullanılır Ceiling.

g[5]
g[860782]
g[1425060]

510510

870870

1438710

05AB1E , 10 bayt

°Åp7.ÆPs.x

Çevrimiçi deneyin!

İlk 10 ** giriş primerinden 7'sinin tüm kombinasyonlarını dener. 1'den büyük girişler için bellek yetersiz.

Oldukça daha verimli 14 byte sürümü:

5°/7+Åp7.ÆPs.x

Çevrimiçi deneyin!

İlk (giriş / 100000 + 7) primerleri kullanır.