सभी


13

परिचय

संख्या सिद्धांत में, हम कहते हैं कि एक संख्या k -smooth है जब इसके प्रमुख कारक सभी k पर होते हैं । उदाहरण के लिए, 2940 7-चिकनी वजह से है 2940=223572

यहाँ, हम एक परिभाषित k में लगातार दो पूर्णांकों जो दोनों कर रहे हैं के रूप में -Smooth जोड़ी k -Smooth। 7-चिकनी जोड़ी का एक उदाहरण हो जाएगा (4374,4375) क्योंकि 4374=237 और 4375=547मजेदार तथ्य: यह वास्तव में 7-चिकनी जोड़ी है

Stormer 1897 में साबित कर दिया कि हर के लिए k , ऐसे केवल सीमित कई हैं k -Smooth जोड़े , और इस तथ्य के रूप में जाना जाता है stormer की प्रमेय

चुनौती

आपका कार्य एक प्रोग्राम या फ़ंक्शन लिखना है, जिसे एक प्राइम नंबर इनपुट k , आउटपुट या रिटर्न के बिना सभी k -ooth जोड़े जोड़े देता है (जोड़ी के भीतर ऑर्डर कोई फर्क नहीं पड़ता) जो आप चाहते हैं।

कृपया ध्यान दें कि अभाज्य संख्याओं के लिए p और q , p<q मानते हुए , सभी p -smooth जोड़े भी q -smooth जोड़े हैं।

नमूना I / O

Input: 2
Output: (1, 2)

Input: 3
Output: (1, 2), (2, 3), (3, 4), (8, 9)

Input: 5
Output: (1, 2), (2, 3), (3, 4), (4, 5), (5, 6), (8, 9), (9, 10), (15, 16), (24, 25), (80, 81)

Input: 7
Output: (1, 2), (2, 3), (3, 4), (4, 5), (5, 6), (6, 7), (7, 8), (8, 9), (9, 10), (14, 15),
        (15, 16), (20, 21), (24, 25), (27, 28), (35, 36), (48, 49), (49, 50), (63, 64),
        (80, 81), (125, 126), (224, 225), (2400, 2401), (4374, 4375)

बंधन

कार्यक्रम या फ़ंक्शन को सैद्धांतिक रूप से सभी इनपुट के लिए परिमित समय में समाप्त करना चाहिए। मानक कमियां डिफ़ॉल्ट रूप से अस्वीकृत हो जाती हैं।

जीत का मानदंड

जैसा कि यह एक चुनौती है, प्रत्येक भाषा की जीत के लिए सबसे कम वैध जमा।


2
क्या आप कृपया 2, 3 और 5 के लिए परीक्षण मामले जोड़ सकते हैं?
जोनाथन एलन

@ जोनाथनअल्लन 2-, 3- और 5- चिकनी जोड़ियों को 7-चिकनी जोड़ियों में शामिल किया गया है, लेकिन मैं स्पष्टता के लिए मामले जोड़
दूंगा

1
चल रहा है (1, 2)उत्पादन अनिवार्य का हिस्सा ..?
केविन Cruijssen

@KevinCruijssen हाँ, सभी आउटपुट में (1, 2)जोड़ी होनी चाहिए ।
शायरु असकोतो

जवाबों:


10

जावास्क्रिप्ट (ईएस 7),  234  232 बाइट्स

प्रपत्र x22qy2=1 Pell समीकरणों को हल करके हल ढूंढता है , जहाँ q एक P -smooth वर्ग मुक्त संख्या है।

यह डेरिक हेनरी लेहमर की प्रक्रिया का एक कार्यान्वयन है , जो स्टॉर्मर की मूल प्रक्रिया से लिया गया है।

एक ऐसी वस्तु लौटाता है जिसकी कुंजी और मान P -ooth जोड़े का वर्णन करते हैं ।

P=>[...Array(P**P)].map((_,n)=>(s=(n,i=0,k=2)=>k>P?n<2:n%k?s(n,i,k+1):s(n/k,i,k+i))(n,1)&&(_=>{for(x=1;(y=((++x*x-1)/n)**.5)%1;);(h=(x,y)=>k--&&h(X*x+n*Y*y,X*y+Y*x,x&s(x=~-x/2)&s(x+1)?r[x]=x+1:0))(X=x,Y=y,k=P<5?3:-~P/2)})(),r={})&&r

इसे ऑनलाइन आज़माएं!

कैसे?

सहायक समारोह s एक दिया पूर्णांक है कि क्या परीक्षण n एक है P -Smooth संख्या जब यह कहा जाता है के साथ i=0 , या एक वर्ग मुक्त 1 P -Smooth संख्या जब यह कहा जाता है के साथ i=1

s = (
  n,
  i = 0,
  k = 2
) =>
  k > P ?
    n < 2
  :
    n % k ?
      s(n, i, k + 1)
    :
      s(n / k, i, k + i)

हम सभी वर्ग मुक्त करने के लिए लग रही है 1 P में -Smooth संख्या [1..PP1] , जहां PP एक ऊपरी के लिए बाध्य के रूप में प्रयोग किया जाता है P!

P=>[...Array(P ** P)].map((_, n) => s(n, 1) && (...))

nx2ny2=1

(_ => {
  for(x = 1; (y = ((++x * x - 1) / n) ** .5) % 1;);
  ...
})()

(उपरोक्त कोड इस अन्य चुनौती के लिए मेरे उत्तर का गैर-पुनरावर्ती संस्करण है )

(x1,y1)(xk,yk)kmax(3,(P+1)/2)

xk+1=x1xk+ny1ykyk+1=x1yk+y1xk

xkxk(xk1)/2(xk+1)/2Pr

( h = (x, y) =>
  k-- &&
  h(
    X * x + n * Y * y,
    X * y + Y * x,
    x &
    s(x = ~-x / 2) &
    s(x + 1) ?
      r[x] = x + 1
    :
      0
  )
)(X = x, Y = y, k = P < 5 ? 3 : -~P / 2)

si=1


हाय अरनुलद! मैं सिर्फ इन दोनों के चारों ओर अपना सिर नहीं लपेट सकता: x = ~-x / 2और क्या -~P / 2ये किसी तरह की गोलाई में हैं ...
राहुल वर्मा

1
~x-(x+1)~-x-(-x+1)x-1-~x-(-(x+1))x+1xP

4

जेली , 16 14 बाइट्स

4*ÆfṀ<ɗƇ‘rƝLÐṂ

इसे ऑनलाइन आज़माएं!

4kk

1 बाइट बचाने के लिए @JonathanAllan को धन्यवाद!

व्याख्या

4*ÆfṀ<ɗƇ‘rƝLÐṂ  | Monadic link, input k

4*              | 4**k, call this n
      ɗƇ        | For each number from 1..n filter those where:
  Æf            |   - Prime factors
    Ṁ           |   - Maximum
     <  ‘       |   - Less than k+1
         rƝ     | Inclusive range between neighbouring values
           LÐṂ  | Keep only those of minimum length (i.e. adjacent values)

1
4kk!24k

1
शीघ्र जवाब देने के लिए ध्न्यवाद। मैं भी ऐसा ही सोच रहा था, लेकिन अधिक मोटे तौर पर: "फैक्टरियल बहुत जल्दी उच्च हो जाता है, यह शायद काफी बड़ा है।" (यह पता चला है जब तक मैं इसे चुकता नहीं था)। छोटे और अधिक कुशल गोल्फ के लिए बधाई, आपके पास मेरा उत्थान है।
कॉमरेड स्पार्कलेपनी

1
नोट ( oeis.org/A002072 से ) "(n) <10 ^ n / n को छोड़कर n = 4 (प्रयोगात्मक डेटा से।) - एमएफ हस्लर, 16 जनवरी 2015"। मुझे लगता है कि जब तक हम अन्यथा साबित नहीं कर सकते, तब तक हमें projecteuclid.org/download/pdf_1/euclid.ijm/1256067456 (प्रमेय 7) में लेहमर के कमजोर बाउंड के साथ रहना होगा।
जोनाथन एलन

2
... वहाँ गणित एसई पर एक खुला सवाल है वास्तव में यह भी पूछ रहा है!
जोनाथन एलन

1
@PeterTaylor जोड़े की संख्या के लिए है, न कि अधिकतम संख्या के लिए। समस्या यह जानती है कि अधिकतम संख्या में जोड़े आपको खोज बंद नहीं करते हैं
निक केनेडी


2

जैली , 123 बाइट्स

¹©Æ½Ø.;µU×_ƭ/;²®_$÷2ị$}ʋ¥⁸;+®Æ½W¤:/$$µƬṪ€F¹;Ḋ$LḂ$?ṭ@ṫ-ṚZæ.ʋ¥ƒØ.,U¤-ịWµ1ịżU×®W¤Ɗ$æ.0ị$ṭµ³’H»3¤¡
ÆRŒPP€ḟ2ḤÇ€ẎḢ€+€Ø-HÆfṀ€<ẠʋƇ‘

इसे ऑनलाइन आज़माएं!

2×max(3,k+12)x12,x+12

एक पूर्ण कार्यक्रम जो एकल तर्क लेता है, और जोड़े की सूचियों की सूची लौटाता है। उपरोक्त कोड अंतिम आउटपुट को सॉर्ट नहीं करता है, लेकिन TIO लिंक करता है।k


2

हास्केल , 118 107 बाइट्स

-11 बाइट्स निमि के लिए धन्यवाद

q 1=[1]
q n=(:)<*>q.div n$[x|x<-[2..n],mod n x==0]!!0
f k|let r=all(<=k).q=[(n,n+1)|n<-[1..4^k],r n,r(n+1)]

इसे ऑनलाइन आज़माएं!

  • q n के सभी प्रमुख कारकों की एक सूची की गणना करता है n
  • f k की सूची बनाता हैk

1
आप इसके [2..n]भीतर लूप कर सकते हैं pऔर इसे इनलाइन कर सकते हैं qइसे ऑनलाइन आज़माएं!
निमि

1

जेली , 24 बाइट्स

³!²R‘Ė
ÇÆFḢ€€€’<³FȦ$€Tị¢

इसे ऑनलाइन आज़माएं!

यह 7 के लिए एक लंबा समय लेता है, लेकिन यह बहुत तेजी से गणना करता है यदि आप फैक्टरियल के वर्ग को हटा दें: इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

³!²R‘Ė                Generates a list like [[1,2],[2,3],...]
³!²                  Take the square of the factorial of the input
   R                 Range 1 through through the above number.
    ‘Ė               Decrement and enumerate, yielding desired list


ÇÆFḢ€€€’<³FȦ$€Tị¢  
Ç                    Get the list of pairs  
 ÆF                  Get the prime factors of each number
   Ḣ€€€              Get the base of each
       ’<³           Is each base less than or equal to the input?
          FȦ$€       Check that all bases of a pair fit the above.
              T      Get a list of the truthy indexes
               ị¢    Index into the original list of pairs
                     Implicit output

-3 बाइट्स @JonathanAllen को धन्यवाद


1
मैं जेली नहीं पढ़ता, क्या आप इस पर एक स्पष्टीकरण दे सकते हैं कि यह कैसे काम करता है?
अज्ञानता का अवतार

(8,9)8=239=32

मुझे यकीन नहीं है कि यह है। क्या आपको लगता है कि पकड़ होगा?
जोनाथन एलन

@JonathanAllan Naive आशावाद और मेरे द्वारा देखे गए सभी उदाहरणों के लिए तथ्य (वास्तव में बहुत से नहीं), सबसे बड़ी जोड़ी k!(3 को छोड़कर, जिसकी छोटी संख्या है, क्योंकि यह एक छोटी संख्या है) से कम है।
कॉमरेड स्पार्कलेपनी

1
आप जिस ऊपरी बाउंड का उपयोग कर रहे हैं वह किसी जोड़े में उपयोग की जाने वाली अधिकतम संख्या पर है, न कि जोड़े की संख्या पर (आप इस तरह से जोड़े की संख्या पर एक ऊपरी बाध्य को लागू नहीं कर सकते हैं जैसा कि आप जानते हैं कि कब देखना बंद करना है!) सबसे बड़ी जोड़ी के उत्पाद पर ऊपरी सीमा के लिए प्रमेय 7 देखें।
जोनाथन एलन

1

पायथन 3 + सिम्पी, 116 बाइट्स

import sympy
def f(k):x=[i for i in range(2,4**k)if max(sympy.factorint(i))<=k];return[(y,y+1)for y in x if y+1in x]

इसे ऑनलाइन आज़माएं!

पायथन 3 + सिम्पी, 111 बाइट्स

from sympy import*
def f(k):
 b=1
 for i in range(2,4**k):
  x=max(factorint(i))<=k
  if x&b:print(i-1,i)
  b=x

इसे ऑनलाइन आज़माएं!

मेरे जेली उत्तर पर दो भिन्नताएँ लेकिन पायथन 3 में। वे दोनों एक फ़ंक्शन को परिभाषित करते हैं जो एक तर्क को स्वीकार करता है k। पहला उन मानदंडों के युग्मों की सूची देता है जो मानदंडों को पूरा करते हैं। दूसरा उन्हें स्टडआउट करने के लिए प्रिंट करता है।




1

05AB1E , 16 बाइट्स

°LʒfàI>‹}Xšü‚ʒ¥`

n>3

स्पष्टीकरण:

°                # Take 10 to the power of the (implicit) input
 L               # Create a list in the range [1, 10^input]
  ʒ              # Filter this list by:
   fà            #  Get the maximum prime factor
     I>‹         #  And check if it's smaller than or equal to the input
        }Xš      # After the filter: prepend 1 again
           ü‚    # Create pairs
             ʒ   # And filter these pairs by:
              ¥` #  Where the forward difference / delta is 1

0

स्टैक्स , 14 बाइट्स

Θ",²aÇu,á‼⌐çLB

इसे चलाएं और डीबग करें

यह कम से कम संभव कार्यक्रम नहीं है, लेकिन मिलान जोड़े मिलते ही इसका उत्पादन शुरू हो जाता है। यह अंततः समाप्त हो जाता है , लेकिन आउटपुट का उत्पादन ऐसा होता है जैसा कि यह पाया जाता है।


हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.