एक पूर्णांक को देखते हुए n >= 2, इसके प्रमुख कारक में सबसे बड़ा प्रतिपादक आउटपुट। यह OEIS अनुक्रम A051903 है ।
चलो n = 144। इसका मुख्य कारक है 2^4 * 3^2। सबसे बड़ा प्रतिपादक है 4।
2 -> 1
3 -> 1
4 -> 2
5 -> 1
6 -> 1
7 -> 1
8 -> 3
9 -> 2
10 -> 1
11 -> 1
12 -> 2
144 -> 4
200 -> 3
500 -> 3
1024 -> 10
3257832488 -> 3
जवाबों:
lambda n:max(k%n-n%(k/n+2)**(k%n)*n for k in range(n*n))f=lambda n,k=0:max(k%n-n%(k/n+2)**(k%n)*n,k<n**2and f(n,k+1))
ÆEṀ
ÆE। - पूर्ण कार्यक्रम / मौद्रिक लिंक। ÆE - अभाज्य गुणनखंड के घातांक की सरणी। Ṁ - अधिकतम।
यह भी M में काम करता है । इसे ऑनलाइन आज़माएं!
n=input()
e=m=0
f=2
while~-n:q=n%f<1;f+=1-q;e=q*-~e;m=max(m,e);n/=f**q
print m-5 ओवर्स के लिए धन्यवाद ।
यह उत्तर प्रधान जाँच नहीं करता है। इसके बजाय, यह इस तथ्य का लाभ उठाता है कि एक प्रमुख कारक का उच्चतम प्रतिपादक किसी संख्या के किसी भी कारक में किसी भी अन्य कारक के प्रतिपादक से अधिक या उसके बराबर होगा।
-h , k ü mÊn
k ü mÊn :Implicit input of integer
k :Prime factors
ü :Group by value
m :Map
Ê : Length
n :Sort
:Implicit output of last element
üसमान मूल्यों के उप-सरणियाँ बनाता है। यह करता भी प्रकार मूल्य से पहले, लेकिन वह यहां प्रासंगिक नहीं है।
Max@@Last/@FactorInteger@#&। दुर्भाग्य से यह किसी भी बाइट को नहीं बचाता है।
YFX>
% implicit input
YF % Exponents of prime factors
X> % maximum
% implicit output
ḋḅlᵐ⌉
ḋ Prime decomposition
ḅ Group consecutive equal values
lᵐ Map length
⌉ Maximum
▲mLgp
p - प्रमुख कारक हो जाते हैं।g - समूह आसन्न मान।mL - प्रत्येक समूह की लंबाई हो जाती है।▲ - ज्यादा से ज्यादा।⎕CY'dfns'
⌈/1↓2pco⎕कैसे?
2pco⎕ - प्रमुख कारकों और घातांक का 2 डी सरणी
1↓ - कारकों को छोड़ दें
⌈/ - ज्यादा से ज्यादा
* अनंत स्टैक मान लेना (जैसा कि कोड-गोल्फ चुनौतियों में होता है)
P=(n,i=2,k)=>i>n?k:n%i?k>(K=P(n,i+1))?k:K:P(n/i,i,-~k)
console.log(P(2 )== 1)
console.log(P(3 )== 1)
console.log(P(4 )== 2)
console.log(P(5 )== 1)
console.log(P(6 )== 1)
console.log(P(7 )== 1)
console.log(P(8 )== 3)
console.log(P(9 )== 2)
console.log(P(10 )== 1)
console.log(P(11 )== 1)
console.log(P(12 )== 2)
console.log(P(144 )== 4)
console.log(P(200 )== 3)
console.log(P(500 )== 3)
console.log(P(1024 )== 10)
//console.log(P(3257832488 )== 3)n->vecmax(factor(n)[,2])
यदि मैं n->भाग की गणना नहीं करता हूं , तो यह 21 बाइट्स है।
@(n)[~,m]=mode(factor(n))factor(संभवतः बार-बार) प्राइम एक्सपोर्टर की सरणी उत्पन्न करता है दूसरा आउटपुट modeकई बार देता है कि मोड (यानी सबसे दोहराया प्रविष्टि) दिखाई देता है।
eS/LPQP(7 बाइट्स), eSlM.gkP(8 बाइट्स)।
f=lambda n,i=2,l=[0]:(n<2)*max(map(l.count,l))or n%i and f(n,i+1,l)or f(n/i,2,l+[i])ḋ)⌠)
ḋ- अभाज्य गुणनखंडन को [अभाज्य, प्रतिपादक] जोड़ो के रूप में गणना करता है ।
⌠ - नक्शा और अधिकतम मूल्य के साथ परिणाम इकट्ठा।
) - अंतिम तत्व (घातांक)।
) - अंतिम तत्व (अधिकतम प्रतिपादक)
ḋ)¦⌉
ḋ- अभाज्य गुणनखंडन को [अभाज्य, प्रतिपादक] जोड़ो के रूप में गणना करता है ।
)¦ - अंतिम तत्व (घातांक) के साथ नक्शा।
⌉ - अधिकतम तत्व प्राप्त होता है।
ωĖ⍐←
ωĖ⍐←
ω = argument
Ė = prime exponents
⍐ = maximum
← = output without a newline
@(x)max(histc(a=factor(x),a));
a=factor(x)एक वेक्टर देता है जिसमें प्रमुख कारक होते हैं x। यह एक वेक्टर है जो आरोही क्रम में है जहाँ factor(x)पैदावार में सभी संख्याओं का गुणन xऐसा है कि वेक्टर में प्रत्येक संख्या प्रधान है।histc(...,a)प्राइम फैक्टर वेक्टर पर एक हिस्टोग्राम की गणना करता है जहां डिब्बे प्रमुख कारक हैं। हिस्टोग्राम गिनता है कि हमने कितनी बार प्रत्येक अभाज्य संख्या को देखा है और इस प्रकार प्रत्येक अभाज्य संख्या के घातांक को जोड़ते हैं। हम यहां थोड़ा धोखा कर सकते हैं क्योंकि भले ही factor(x)डुप्लिकेट नंबर या डिब्बे वापस आ जाएंगे, लेकिन केवल एक ही बार हम एक अभाज्य संख्या को देखते हुए कुल राशि पर कब्जा कर लेंगे।max(...) इस प्रकार सबसे बड़ा प्रतिपादक लौटता है।/o
\i@/w].D:.t$Kq
/o
\i@/...
यह दशमलव I / O के साथ सरल-ईश अंकगणितीय कार्यक्रमों के लिए सिर्फ एक रूपरेखा है। ...वास्तविक कार्यक्रम है, जो पहले से ही ढेर पर इनपुट है और ढेर के शीर्ष पर उत्पादन छोड़ देता है।
ऐलिस ने वास्तव में एक पूर्णांक (प्राइम-एक्सपोजर जोड़े के साथ) का मुख्य कारक प्राप्त करने के लिए बिल्ट-इन किया है, लेकिन सबसे कम मैं उन का उपयोग करके आया हूं जो इससे 10 बाइट्स लंबा है।
इसके बजाय विचार यह है कि हम बार-बार इनपुट से बाहर प्रत्येक अलग-अलग प्राइम फैक्टर की एक कॉपी को तब तक विभाजित करते हैं, जब तक हम 1 तक नहीं पहुंच जाते । इसके द्वारा उठाए जाने वाले कदमों की संख्या सबसे बड़े प्रमुख प्रतिपादक के बराबर है। हम काउंटर चर के रूप में टेप हेड का दुरुपयोग करेंगे।
w Remember the current IP position. Effectively starts a loop.
] Move the tape head to the right, which increments our counter.
.D Duplicate the current value, and deduplicate its prime factors.
That means, we'll get a number which is the product of the value's
unique prime factors. For example 144 = 2^4 * 3^2 would become
6 = 2 * 3.
: Divide the value by its deduplicated version, which decrements the
exponents of its prime factors.
.t Duplicate the result and decrement it. This value becomes 0 once we
reach a result of 1, which is when we want to terminate the loop.
$K Jump back to the beginning of the loop if the previous value wasn't 0.
q Retrieve the tape head's position, i.e. the number of steps we've taken
through the above loop.
f(x)=maximum(collect(values(factor(x))))
-12 + सुधार के लिए धन्यवाद Steadybox
print()। इसके अलावा, मुझे TIO पर चलने के लिए कोड नहीं मिल सकता है, मुझे लगता है कि यह वहां उपलब्ध भाषा के कुछ अन्य संस्करणों पर काम करता है? यह TIO पर ठीक चलता है: print(maximum(collect(values(factor(parse(BigInt,readline()))))))
print()आवश्यकता है क्योंकि उत्तर को एक पूर्ण कार्यक्रम (जो आउटपुट प्रदर्शित करता है) या एक फ़ंक्शन (जो आउटपुट देता है) होना चाहिए। अन्यथा आपका समाधान ठीक है। ऐसा लगता है कि आप कुछ बाइट्स (और प्रिंट से बच सकते हैं) को इस तरह से बचा सकते हैं:f(x)=maximum(collect(values(factor(x))))
w♂NM
wNM - पूर्ण कार्यक्रम। w - अभाज्य गुणनखंडन को [अभाज्य, प्रतिपादक] जोड़ो के रूप में करता है। ♂N - प्रत्येक (घातांक) का अंतिम तत्व प्राप्त करें। एम - अधिकतम।
-4 बाइट्स H.PWiz को धन्यवाद।
lambda n:max(a*(n%k**a<1)for a in range(n)for k in range(2,-~n))H.PWiz के हास्केल उत्तर का पोर्ट । मैं केवल इसे साझा कर रहा हूं क्योंकि मुझे गर्व है कि मैं हास्केल कोड के इस टुकड़े को समझने और अनुवाद करने में सक्षम था। : पी
range(1,n)काम नहीं?
range(1, n)[1, n) में सभी पूर्णांक बनाता है।
a
(λ(n)(cadr(argmax cadr((let()(local-require math/number-theory)factorize)n))))
(मुझे यकीन नहीं है कि क्या एक पूर्ण रैकेट समाधान का गठन करने पर आम सहमति है, इसलिए मैं गणितज्ञ सम्मेलन के साथ जा रहा हूं जो एक शुद्ध फ़ंक्शन मायने रखता है।)
factorizeजोड़े की एक सूची के रूप में कारककरण (factorize 108)देता है : देता है '((2 2) (3 3))। एक जोड़ी का दूसरा तत्व द्वारा दिया जाता है cadr, car(किसी सूची के प्रमुख) की रचना के लिए एक आशुलिपि (एक सूची की cdrपूंछ)।
मुझे लगता (cadr (argmax cadr list))है कि दूसरे तत्वों की अधिकतम संख्या को खोजने के लिए मूर्खतापूर्ण काम कर रहे हैं, लेकिन maxसूचियों पर काम नहीं करता है: (max (map cadr list))हम जो चाहते हैं वह नहीं करते हैं। मैं रैकेट का विशेषज्ञ नहीं हूं, इसलिए शायद ऐसा करने के लिए एक मानक बेहतर तरीका है।
(λ(n)(define(p d m)(if(=(gcd m d)d)(+(p d(/ m d))1)0))(p(argmax(λ(d)(p d n))(range 2 n))n))
एक वैकल्पिक संस्करण जो आयात नहीं करता है factorizeऔर इसके बजाय सब कुछ खरोंच से, कम या ज्यादा करता है। फ़ंक्शन उस विभाजन (p m d)की उच्चतम शक्ति पाता है और फिर हम केवल बीच और के लिए उच्चतम मूल्य पाते हैं । (हमें इसे केवल अपराधों तक सीमित रखने की आवश्यकता नहीं है, क्योंकि एक समग्र शक्ति नहीं होगी जो प्रधान शक्तियों से बेहतर काम करती है।)dm(p n d)d2n
maxसमाधान है, (apply max (map cadr list)लेकिन (cadr (argmax cadr list))दुर्भाग्य से कम है।
{⌈/+/¨v∘=¨v←π⍵}
परीक्षा:
f←{⌈/+/¨v∘=¨v←π⍵}
f¨2..12
1 1 2 1 1 1 3 2 1 1 2
f¨144 200 500 1024 3257832488
4 3 3 10 3
टिप्पणी:
{⌈/+/¨v∘=¨v←π⍵}
v←π⍵ π12 return 2 2 3; assign to v the array of prime divisors of argument ⍵
v∘=¨ for each element of v, build one binary array, show with 1 where are in v array, else puts 0
return one big array I call B, where each element is the binary array above
+/¨ sum each binary element array of B
⌈/ get the max of all element of B (that should be the max exponet)