पूर्णांक लघुगणक

12

पूर्णांकों को देखते हुए N , P > 1, सबसे बड़ा पूर्णांक Mऐसा पाते हैं P ^ M ≤ N।

मैं / हे:

इनपुट 2 पूर्णांक Nऔर के रूप में दिया गया है P। आउटपुट पूर्णांक होगा M।

उदाहरण:

4, 5 -> 0
33, 5 -> 2
40, 20 -> 1
242, 3 -> 4 
243, 3 -> 5 
400, 2 -> 8
1000, 10 -> 3

टिप्पणियाँ:

इनपुट हमेशा मान्य होगा, अर्थात यह हमेशा 1 से अधिक पूर्णांक होगा।

क्रेडिट:

नाम का श्रेय @cairdcoinheringaahing को जाता है। अंतिम 3 उदाहरण @Nitrodon द्वारा हैं और विवरण को सुधारने का श्रेय @Giuseppe को जाता है।

code-golf  math  number  arithmetic 
— मुहम्मद सलमान
स्रोत
3
मुझे पता है कि हम (पीपीसीजी समुदाय) वास्तव में छोटे सामानों के बारे में अति-निति-योग्य लग सकते हैं, लेकिन मेरी तरह की टिप्पणियां वास्तव में, अच्छे विश्वास में, चुनौती को बेहतर बनाने के लिए हैं! अब इसका समाधान हो गया है, मैंने खुशी-खुशी मतदान किया है, और अपनी पिछली टिप्पणियों को हटा दिया है।
— Giuseppe
9
यही कारण है कि हम पहले सैंडबॉक्स में चुनौतियों को पोस्ट करने का सुझाव देते हैं , ताकि आप उपयोगी प्रतिक्रिया प्राप्त कर सकें, एक बड़ी चुनौती पोस्ट कर सकें, और बहुत अधिक उपद्रव उत्तर पा सकें, बहुत कम उपद्रव (जैसे करीब और नीचे-वोट)। :)
— Giuseppe
2
आप हमेशा सामान्य पीपीसीजी में पोस्ट कर सकते हैं अपने सैंडबॉक्स चुनौतियों पर प्रतिक्रिया के लिए पूछते हुए उन्हें थोड़ा और ध्यान दें।
— ग्यूसेप
12
फ्लोटिंग-पॉइंट गणित पर आधारित लगभग सभी मौजूदा उत्तर गोल चक्कर की त्रुटि के कारण (1000, 10) जैसे सरल मामलों के लिए भी गलत परिणाम देते हैं, इसलिए मैंने एक और परीक्षण मामला जोड़ा।
— nwellnhof
3
@MPW सभी प्रतिक्रियाओं को हटा दिया गया था, और मेरे द्वारा किए गए सुझावों को पोस्ट में संपादित किया गया था, इसलिए वे अब प्रासंगिक नहीं थे।
— ग्यूसेप

जवाबों:

8

ब्रेन-फ्लैक , 74 बाइट्स

(({}<>)[()])({()<(({})<({([{}]()({}))([{}]({}))}{})>){<>({}[()])}{}>}[()])

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

यह मानक ब्रेन-फ्लैक पॉजिटिव पूर्णांक विभाजन एल्गोरिथ्म के समान अवधारणा का उपयोग करता है।

# Push P and P-1 on other stack
(({}<>)[()])

# Count iterations until N reaches zero:
({()<

  # While keeping the current value (P-1)*(P^M) on the stack:
  (({})<

    # Multiply it by P for the next iteration
    ({([{}]()({}))([{}]({}))}{})

  >)

  # Subtract 1 from N and this (P-1)*(P^M) until one of these is zero
  {<>({}[()])}{}

# If (P-1)*(P^M) became zero, there is a nonzero value below it on the stack
>}

# Subtract 1 from number of iterations
[()])
— Nitrodon
स्रोत
6

एक्सेल, 18 बाइट्स

=TRUNC(LOG(A1,A2))

A2 पर "n" इनपुट लेता है, और A2 पर "p" इनपुट करता है।

— qoou
स्रोत
मुझे लगता है कि आप 2 बाइट्स को बचाने के INTबजाय फ़ंक्शन का उपयोग कर सकते हैं TRUNC।
— पजाकोंक
4

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

bḊL

यह फ्लोटिंग-पॉइंट अंकगणित का उपयोग नहीं करता है, इसलिए कोई सटीक मुद्दे नहीं हैं।

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

यह काम किस प्रकार करता है

bḊL  Main link. Left argument: n. Right argument: p

b    Convert n to base p.
 Ḋ   Dequeue; remove the first base-p digit.
  L  Take the length.
— डेनिस
स्रोत
3

रेटिना 0.8.2 , 35 बाइट्स

.+
$*
+r`1*(\2)+¶(1+)$
#$#1$*1¶$2
#

इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

.+
$*

तर्कों को एकात्मक में बदलें।

+r`1*(\2)+¶(1+)$
#$#1$*1¶$2

यदि दूसरा तर्क पहले को विभाजित करता है, तो पहले तर्क को #प्लस पूर्णांक परिणाम से बदलें , शेष को छोड़ दें। इसे तब तक दोहराएं जब तक कि पहला तर्क दूसरे से कम न हो।

#

लूप चलाने की संख्या की गणना करें।

— नील
स्रोत
3

जाप, 8 बाइट्स

@<Vp°X}a

कोशिश करो

— झबरा
स्रोत
यह वास्तव में साफ-सुथरा है, मैंने अभी तक जाप में फ़ंक्शन विधियों के लिए एक अच्छा उपयोग नहीं देखा है, यह एक अच्छा उदाहरण है।
— लीख
@ ठीक है, मुझे उनके साथ पकड़ पाने के लिए एक अच्छा समय लगा, वह भी - हाल ही में उनके लिए उपयोग की जाने लगी F.g()- लेकिन वे अविश्वसनीय रूप से उपयोगी हैं।
— झबरा
3

पर्ल 6 , 13 बाइट्स

&floor∘&log

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

कॉन्टेनेशन लॉग और फर्श की रचना, अंतर्निहित रूप से 2 तर्क हैं क्योंकि पहला फ़ंक्शन लॉग की अपेक्षा करता है 2. परिणाम एक फ़ंक्शन है।

— फिल एच
स्रोत
3
तर्कों के लिए 1000, 10यह प्रतिफल 2.
— सीन
@ सीन: हुह, दिलचस्प सटीक मुद्दा है
— फिल एच।
3

हास्केल , 16 बाइट्स

(floor.).logBase

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

हास्केल को गणितज्ञों द्वारा डिजाइन किया गया था, इसलिए इसमें प्राल्यूड में गणित से संबंधित कार्यों का एक अच्छा सेट है।

— totallyhuman
स्रोत
6
गोलाई त्रुटि के कारण (1000, 10) के लिए काम नहीं करता है।
— nwellnhof
3

आर , 25 बाइट्स

function(p,n)log(p,n)%/%1

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

Pआधार का लॉग लें Nऔर पूर्णांक विभाजन करें 1, क्योंकि यह इससे छोटा है floor()। यह संख्यात्मक परिशुद्धता से थोड़ा ग्रस्त है, इसलिए मैं नीचे दिए गए उत्तर को भी प्रस्तुत करता हूं, जो संभवतः पूर्णांक अतिप्रवाह के अलावा नहीं होना चाहिए।

आर , 31 बाइट्स

function(p,n)(x=p:0)[n^x<=p][1]

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

— ग्यूसेप
स्रोत
1
मुझे नहीं पता कि चुनौती देने के लिए हमें कितनी कड़ी मेहनत करनी पड़ती है, लेकिन उदाहरण के लिए, f (243,3) 4 के बराबर है, जब इसे 5 होना आवश्यक है।
— JDL
@JDL यह एक उचित बिंदु है; मेरा मानना ​​है कि एक बिल्कुल सटीक जवाब होगा ~ 31 बाइट्स।
— Giuseppe
1
मुझे लगता है कि आप की जगह ले सकता pसे p+.125 बाइट जवाब में और आप अभी भी, ठीक हो जाएगा 28 बाइट्स के लिए
— JDL
संख्यात्मक परिशुद्धता के मुद्दों के बिना एक और 28 बाइट समाधान ।
— रॉबिन राइडर
2

रूबी , 31 बाइट्स

ठीक है, इसलिए सभी लॉग-आधारित दृष्टिकोण राउंडिंग त्रुटियों से ग्रस्त हैं, इसलिए यहां एक और तरीका है जो पूर्णांक के साथ काम करता है और उन मुद्दों से मुक्त है:

->n,p{(0..n).find{|i|p**i>n}-1}

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

लेकिन लघुगणक पर वापस जाना, हालांकि यह स्पष्ट नहीं है कि हमें किस परिशुद्धता का इनपुट का समर्थन करना चाहिए, लेकिन मुझे लगता है कि यह छोटी चाल सभी या कम "यथार्थवादी" संख्याओं के लिए गोलाई समस्या को हल करेगी:

रूबी , 29 बाइट्स

->n,p{Math.log(n+0.1,p).to_i}

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

— किरिल एल।
स्रोत
2

सी (जीसीसी) + -lm, 24 बाइट्स

f(n,m){n=log(n)/log(m);}

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

— betseg
स्रोत
मुझे पता है long longलेकिन क्या है bytes bytes? : पी
— बिशुनमान
इसके अलावा झंडे अब आपकी बाइट गिनती में नहीं जुड़ते हैं, इसलिए मैंने इसे प्रतिबिंबित करने के लिए संपादन किया।
— अमानवीय
5
गोलाई त्रुटि के कारण (1000, 10) के लिए काम नहीं करता है।
— nwellnhof
f(n,m){n=(float)log(n)/log(m);}@ 31 बाइट्स काम करने लगता है
— GPS
2

एपीएल (डायलॉग यूनिकोड) , 2 बाइट्स

⌊⍟

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

बहुत सीधा।

⍟ लॉग

⌊ मंज़िल

— जे। सल्ल
स्रोत
एक बाइट को बचाने के लिए ⌊⍟
— डाइएडिक बनाएं
मैं थोड़ा शर्मिंदा हूं कि आपको वास्तव में मुझे यह बताना पड़ा कि>> धन्यवाद, हालांकि!
— जे। सले
2

05AB1E , 6 बाइट्स

Lm¹›_O

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

— Emigna
स्रोत
यह सिर्फ बाकी सभी के लिए अनुचित लगता है
— फ्लोरिस
1
@ फ़ोरिस प्रतियोगिताएँ प्रत्येक भाषा में प्रस्तुतिकरण के बीच होती हैं न कि भाषाओं के बीच?
— user202729
@ user202729 हाँ और नहीं। मेरे दिमाग में, अंत में, "सबसे छोटा कोड जीतता है"। लेकिन मैंने देखा कि नीचे एक 2-बाइट समाधान था ... इन गोल्फ भाषाओं ने मेरे दिमाग को उड़ा दिया।
— फ्लोरिस
1
@Floris "कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव उत्तर देने की कोशिश करें।"
— user202729
1
@ फ़्लोरिस भी ... यहां तक ​​कि एक्सेल भी इसे 2 बिल्डिंस में कर सकता है । गोल्फिंग भाषाएं इसे 2 बिल्ट-इन भी कर सकती हैं, बस बिल्टइन नाम छोटे हैं। आश्चर्य की कोई बात नहीं।
— user202729
2

जावास्क्रिप्ट , 40 33 बाइट्स

डैनियलइंडी को -3 बाइट्स धन्यवाद

करी सिंटैक्स में इनपुट लेता है।

a=>b=>(L=Math.log)(a)/L(b)+.001|0

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

— ओलिवर
स्रोत
— डैनियलइंडी
1
28 बाइट्स और शायद अगर आप करी विधि चाहते हैं
— डैनियलइंडी
— NoOneIsHere
(999, 10) के लिए काम नहीं करना चाहिए (2 आउटपुट चाहिए)
— हरमन एल
4
toStringसमाधान केवल 36. करने के लिए ठिकानों के लिए काम करता है
— nwellnhof
2

परी / जीपी, 6 बाइट्स

logint

(अंतर्निहित संस्करण 2.7, मार्च 2014 में जोड़ा गया। एक वैकल्पिक तीसरे संदर्भ के साथ दो तर्क लेता है, जो यदि मौजूद है, तो परिणाम के लिए उठाए गए आधार पर सेट है)

— DanaJ
स्रोत
Pari / GP और Perl / ntheory दोनों से @StewieGriffin logint (x, y) वर्तमान में दिखाए गए 7 उदाहरणों के लिए सही परिणाम देते हैं, जिनमें 1000 '10 'के लिए' 3 'भी शामिल है।
— दनाज
+1, लेकिन मैं इसे 6 बाइट्स के रूप में गिनूंगा।
— चार्ल्स
2
आपको हार्डकोड किए गए इनपुट का उपयोग करने की अनुमति नहीं है, इसलिए यह एक फ़ंक्शन होना चाहिए (जैसे। लैम्ब्डा या परिभाषा के रूप में)। हालाँकि आप बस उपयोग कर सकते हैं logintजो वैध है और 5 बाइट्स कम गिनता है।
— ।
2

पायथन 2, 3, 46 बाइट्स

-1 जोनाथन को धन्यवाद

def A(a,b,i=1):
 while b**i<=a:i+=1
 return~-i

पायथन 1, 47 बाइट्स

def A(a,b,i=1):
 while b**i<=a:i=i+1
 return~-i
— वेदांत कंदोई
स्रोत
n~-iएक बाइट से छोटा है n i-1।
— जोनाथन फ्रेच
इसके अलावा, कृपया अपने पायथन संस्करण को बताएं।
— जोनाथन फ्रेच
किसी भी संस्करण में काम करेंगे, है ना?
— वेदांत कंडोई
यह पायथन 1. में काम नहीं करेगा
— जोनाथन फ्रीच
2

जावास्क्रिप्ट (Node.js) , 22 बाइट्स

m=>f=n=>n<m?0:f(n/m)+1

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

करी पुनरावर्ती कार्य। के रूप में उपयोग करें g(P)(N)। उपयोगMath.log करने की तुलना में फ्लोटिंग-पॉइंट त्रुटियों के लिए कम संभावना है , और (मेरा मानना ​​है) कोड सही मान देता है जब तक कि दोनों इनपुट सुरक्षित पूर्णांक (अंडर 2**52) हैं।

— bubbler
स्रोत
1

वोल्फ्राम भाषा (गणितज्ञ) 15 10 बाइट्स

Floor@*Log

(इनपुट पर उल्टे आदेश की आवश्यकता है)

मूल प्रस्तुत करना

⌊#2~Log~#⌋&
— केली लोडर
स्रोत
⌊Log@##⌋&एक बाइट छोटी है
— लुकास लैंग
@ Mathe172, यह एक वर्ण छोटा है, लेकिन मैं उस पर 13 बाइट्स गिनता हूं। UTF-8 में बायीं मंजिल और दाएं तल की गिनती 3 बाइट्स के रूप में है।
— केली लोडर
@StewieGriffin% [10,1000] देता है। 3. इनपुट को मशीन नंबरों के बजाय पूर्णांक के रूप में माना जाता है जब तक कि आप उनके बाद एक दशमलव स्थान नहीं रखते हैं।
— केली लोडर
1

फोर्थ (gforth) , 35 बाइट्स

: f swap s>f flog s>f flog f/ f>s ;

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

अपेक्षित इनपुट मापदंडों को अदला-बदली करके 5 बाइट्स बचा सकता है, लेकिन प्रश्न निर्दिष्ट करता है कि एन को पहले होना चाहिए (एक तर्क दिया जा सकता है कि पोस्टफ़िक्स भाषा में "फ़र्स्ट" का मतलब टॉप-ऑफ़-स्टैक है, लेकिन मैं नियमों के पत्र से चिपका रहूंगा अभी)

व्याख्या

swap       \ swap the parameters to put N on top of the stack
s>f flog   \ move N to the floating-point stack and take the log(10) of N
s>f flog   \ move P to the floating-point stack and take the log(10) of P
f/         \ divide log10(N) by log10(P)
f>s        \ move the result back to the main (integer) stack, truncating in the process
— reffu
स्रोत
1

अजगर, 6 4 बाइट्स

s.lF

सहेजे गए 2 बाइट्स मेमनोमिक के लिए धन्यवाद
ऑनलाइन प्रयास करें

यह काम किस प्रकार करता है

.lis log B (A)
ईमानदार होने के लिए, मुझे नहीं पता कि कैसे Fकाम करता है। लेकिन अगर यह काम करता है, तो यह काम करता है।
sहमारे लिए उच्चतम पूर्णांक देने के लिए एक फ़्लोट को एक फ़्लोट में बदल देता है M।

— fortraan
स्रोत
2
इनपुट के रूप में 1000,10 आउटपुट के रूप में 2 देता है
— स्टीवी ग्रिफिन
इसी तरह का एक और उपाय है/FlM
— आर.के.
1

आश्चर्य है , 9 बाइट्स

|_.sS log

उदाहरण का उपयोग:

(|_.sS log)[1000 10]

व्याख्या

वर्बोज़ संस्करण:

floor . sS log

इसे पॉइंटफ्री स्टाइल लिखा जाता है। sSकिसी फ़ंक्शन (इस मामले में log) के तर्क के रूप में सूची आइटम पास करता है ।

— मामा फन रोल
स्रोत
1

Gforth , 31 बाइट्स

SWAP S>F FLOG S>F FLOG F/ F>S .

प्रयोग

242 3 SWAP S>F FLOG S>F FLOG F/ F>S . 4 OK

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

व्याख्या

दुर्भाग्य से FORTH एक समर्पित फ्लोटिंग-पॉइंट-स्टैक का उपयोग करता है। इसके लिए मुझे SWAPइनपुट मानों को (एक्सचेंज) करना होगा ताकि वे सही क्रम में फ्लोटिंग पॉइंट स्टैक पर पहुंचें। मुझे उस स्टैक के मान को भी स्थानांतरित करना है S>F। फ़्लोटिंग-पॉइंट परिणाम को पूर्णांक में वापस ले जाने पर ( F>S) मुझे मुफ्त में ट्रंकेशन प्राप्त करने का लाभ है।

छोटा संस्करण

आवश्यकताओं को बढ़ाते हुए और फ्लोट-प्रारूप और सही क्रम में इनपुट प्रदान करते हैं, 24 बाइट्स के साथ एक छोटा संस्करण होता है।

FLOG FSWAP FLOG F/ F>S .
3e0 242e0 FLOG FSWAP FLOG F/ F>S . 4 OK

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

— Kitana
स्रोत
आमतौर पर कोडगॉल्फ जवाब के लिए, स्निपेट्स को बंद कर दिया जाता है (जब तक कि अन्यथा चुनौती में संकेत नहीं दिया गया हो)। इस उत्तर को या तो एक फ़ंक्शन (वर्ड इन फोर्थ) के साथ लपेटा जाना चाहिए या : f .... ;एक प्रोग्राम में परिवर्तित करना चाहिए जो इनपुट का उपयोग करता है KEYयाACCEPT
— reffu
@reffu एक स्निपेट क्या है? मेरी राय में, कुछ दिखाने के लिए एक स्माल कोड भाग, जो, हालांकि, अपने लिए कुछ भी सार्थक नहीं करता है। दूसरी ओर, जो कोड मैंने प्रदान किया है वह "ऑनलाइन प्रयास करें" पर बदलाव के बिना काम करता है। क्या हमें मेटा जाना चाहिए?
— किताणा
इस विशेष मामले में आपके द्वारा पोस्ट किया गया कोड वास्तव में एक स्टैक अंडरफ्लो फेंक देगा जब तक कि आप इसके पहले पैरामीटर नहीं डालते। कोड गोल्फ उत्तर आम तौर पर एक स्व-निहित कार्यक्रम या फ़ंक्शन होना चाहिए जो बाद में कहा जाता है, तो अपेक्षित परिणाम उत्पन्न करता है। यदि आप मेरी पिछली टिप्पणी में मेटा पोस्ट के लिंक का अनुसरण करते हैं, तो यह स्पष्ट रूप से उल्लेख करता है कि मानक एक कार्यक्रम या एक फ़ंक्शन के जवाब के लिए है, जिसमें से आपका नहीं है। इसे ठीक करने के लिए केवल 4 बाइट्स की आवश्यकता होगी
— reffu
1

जाप , 5 बाइट्स

ìV ÊÉ

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

8 बाइट्स

N£MlXÃäz

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

— ओलिवर
स्रोत
1
के बारे में एक ही बात का उपयोग कर पोस्ट करने के लिए किया गया था ìके बजाय sके रूप में sअसफल हो जायेगी यदि V>36।
— झबरा
@ सुग्गी गुड कॉल ऑन V>36।
— ओलिवर
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.