सभी वर्गों को त्याग दो, जो मुझे विभाजित करते हैं

Question

परिभाषाएं

• एक पूर्ण वर्ग एक पूर्णांक है जिसे दूसरे पूर्णांक के वर्ग के रूप में व्यक्त किया जा सकता है। उदाहरण के लिए, 36एक सही वर्ग है क्योंकि 6^2 = 36।
• एक स्क्वायरफ्री नंबर एक पूर्णांक है जो किसी भी पूर्ण वर्ग द्वारा, को छोड़कर, विभाज्य नहीं है 1। उदाहरण के लिए, 10एक वर्गाकार संख्या है। हालाँकि, 12एक वर्गाकार संख्या नहीं है, क्योंकि 12यह विभाज्य है 4और 4एक पूर्ण वर्ग है।

कार्य

एक सकारात्मक पूर्णांक को देखते हुए n, सबसे बड़ा वर्गफ्री नंबर आउटपुट करता है जो विभाजित होता है n।

परीक्षण के मामलों

n   output
1   1
2   2
3   3
4   2
5   5
6   6
7   7
8   2
9   3
10  10
11  11
12  6
13  13
14  14
15  15
16  2
17  17
18  6
19  19
20  10
21  21
22  22
23  23
24  6
25  5
26  26
27  3
28  14
29  29
30  30
31  31
32  2
33  33
34  34
35  35
36  6
37  37
38  38
39  39
40  10
41  41
42  42
43  43
44  22
45  15
46  46
47  47
48  6
49  7
50  10

स्कोरिंग

यह कोड-गोल्फ है । बाइट्स जीत में सबसे छोटा जवाब।

मानक खामियां लागू होती हैं।

संदर्भ

• OEIS A007947

Comments

... और मूलक कहा जाता है - इसलिए 1980 का!

— जोनाथन एलन

बारीकी से संबंधित , बस दो आउटपुट गुणा करें। संपादित करें: कोई बात नहीं, यह केवल घन संख्या पर मेल खाता है।

— xnor

Answer 1

05AB1E , 2 बाइट्स

fP

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

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

f   Implicitly take input and compute the integer's unique prime factors.
 P  Take the product.

Comments

> _> वास्तव में ... ??

— हाइपरएनुट्रीनो

@ हाइपरनेटिनो यान - यदि कोई संख्या वर्ग-मुक्त नहीं है तो यह इसलिए है क्योंकि इसके कुछ प्रमुख कारक (गुण) में अनेकता है।

— जोनाथन एलन

@JonathanAllan मैं केवल अनोखे प्रमुख कारकों के लिए अंतर्निहित रुचि रखता हूं। काश जेली उनमें से एक होती ...

— HyperNeutrino

@ हैपरनेट्रिनो यह 05AB1E है, इसकी आदत डाल लें। 05AB1E में वास्तव में कुछ अतिरेक निर्मित हैं जो स्पष्ट रूप से बाइट्स को बचाते हैं।

— आउटगॉल्फ को एरिक करें

सुधार, "बाइट्स सहेजें", इसके बारे में शायद कोई नहीं है।

— ड्रेको 18

Answer 2

ब्रेकीलॉग , 3 बाइट्स

ḋd×

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

एक बहुत ही मूल उत्तर ...

व्याख्या

ḋ          Take the prime factors of the Input
 d         Remove duplicates
  ×        Multiply

Comments

फिर से, ब्रेजलॉग ने जेली को हरा दिया क्योंकि यहां एक दो-बाइट परमाणु केवल एक बाइट है। > :-P

— HyperNeutrino

जेली के बहुत सारे निर्माण होने से अक्सर एक लाभ के रूप में देखा जाता है; लेकिन अधिक निर्मितियों का मतलब है कि उन्हें औसतन लंबे नामों की आवश्यकता है। तो गोल्फिंग भाषा डिजाइन में शामिल ट्रेडऑफ़ हैं।

मैं "उस आदमी" होने की कोशिश नहीं कर रहा हूं, और शायद मैं सिर्फ बाइट की गिनती को गलत समझ रहा हूं, लेकिन यह 6 बाइट्स नहीं है? mothereff.in/byte-counter# × d ×

— कप्तान मैन

@CaptainMan Brachylog एक 256 वर्ण कस्टम कोड पृष्ठ का उपयोग करता है जिसे आप यहां पा सकते हैं ।

— घातक

Answer 3

जावास्क्रिप्ट (ईएस 6), 55 54 50 46 बाइट्स

कोटेशन OEIS :
a (n) n का सबसे छोटा भाजक u है जो n को विभाजित करता है u ^ n

अद्यतन कार्यान्वयन:
a (n) n पॉजिटिव पूर्णांक u का सबसे छोटा भाजक u है जो कि n को विभाजित करता है ^ ^ n

let f =

n=>(g=(p,i=n)=>i--?g(p*p%n,i):p?g(++u):u)(u=1)

for(n = 1; n <= 50; n++) {
  console.log(n,f(n));
}

Comments

समस्या के लिए अच्छा दृष्टिकोण, esp।

— बिलियन

Answer 4

MATL , 6 4 बाइट्स

@LeakyNun की मदद से 2 बाइट्स बचाए गए

Yfup

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

व्याख्या

इनपुट पर विचार करें 48।

Yf   % Implicit input. Push prime factors with repetitions.  STACK: [2 2 2 2 3]
u    % Unique.                                               STACK: [2 3]
p    % Product of array. Implicit display.                   STACK: 6

Comments

आउट-गोल्फ

— लीकी नून

@LeakyNun हेह, मैं पोस्ट करने वाला था कि :-) धन्यवाद

— लुइस मेंडू

Answer 5

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

ÆfQP

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

ÆfQP  Main link, argument is z
Æf    Takes the prime factors of z
  Q   Returns the unique elements of z
   P  Takes the product

Answer 6

सीजेएम , 8 बाइट्स

rimf_&:*

^{इस कार्यक्रम में प्रत्येक ऑपरेशन को 2 बाइट्स क्यों करना पड़ता है -_-}

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

ri       e# Read int from input
  mf     e# Get the prime factors
    _&   e# Deduplicate
      :* e# Take the product of the list

Comments

मुझे समर्पण करने का कोई तरीका नहीं मिला। अच्छा!

— लुइस मेंडू

@LuisMendo मैंने हाल ही में खोजा है। मैंने हमेशा सोचा था कि यह मल्टीसेट चौराहा है लेकिन जाहिर है यह सिर्फ सामान्य सेट चौराहा है।

— बिजनेस कैट

Answer 7

रेटिना , 36 30 28 बाइट्स

+`((^|\3)(^(1+?)|\3\4))+$
$3

इनपुट और आउटपुट अनरी में ।

इसे ऑनलाइन आज़माएं! (दशमलव के लिए एक हेडर और पाद लेख शामिल है <-> एकतरफा रूपांतरण और एक साथ कई परीक्षण मामलों को चलाने के लिए।)

व्याख्या

विचार वर्ग को कुछ कारक के रूप में इनपुट से मिलाना है। एक वर्ग के मिलान के लिए मूल रेगेक्स लगातार विषम पूर्णांक के योगों के लिए आगे-संदर्भ का उपयोग करता है:

(^1|11\1)+$

चूँकि हम पूर्ण वर्गों का मिलान नहीं करना चाहते हैं, लेकिन वे संख्याएँ जो एक वर्ग द्वारा विभाज्य हैं, हम उन्हें 1एक पश्चगामी के साथ प्रतिस्थापित करते हैं :

(^(1+?)|\1\2\2)+$

तो अब बाहरी समूह 1का उपयोग n बार किया जाएगा जहां n ² सबसे बड़ा वर्ग है जो इनपुट को विभाजित करता है और समूह 2शेष कारक को संग्रहीत करता है। वर्ग को हटाने के लिए हम पूर्णांक को n से विभाजित करना चाहते हैं । परिणाम समूह 1समय समूह के पुनरावृत्तियों की संख्या के रूप में व्यक्त किया जा सकता है 2, लेकिन यह करने के लिए थोड़ा मुश्किल है। रेटिना की $*शायद जल्द ही एक गैर-चरित्र टोकन लेने के लिए सुधार किया जाएगा क्योंकि इसके दाहिने हाथ का तर्क है कि किस मामले में हम बस इसे बदल सकते हैं $#1$*$2, लेकिन यह अभी तक काम नहीं करता है।

इसके बजाय, हम विषम संख्याओं को अलग तरह से विघटित करते हैं। आइए, पूर्ण वर्गों के साथ मिलान के सरल उदाहरण पर वापस जाएं (^1|11\1)+$। एक काउंटर होने के बजाय \1जो 1 से शुरू होता है और प्रत्येक पुनरावृत्ति पर 2 द्वारा बढ़ाया जाता है, हमारे पास दो काउंटर होंगे। एक को 0 से शुरू किया जाता है और एक को 1 से शुरू किया जाता है , और वे दोनों प्रत्येक पुनरावृत्ति पर 1 से बढ़ जाते हैं। इसलिए हमने मूल रूप से विषम संख्या 2n + 1 को (n) + (n + 1) में विघटित कर दिया है । लाभ यह है कि हम समूहों में से एक में n के साथ समाप्त करेंगे । अपने सरलतम रूप में, जो इस तरह दिखता है:

((^|1\2)(^1|1\3))+$

कहाँ \2है n और \3है n + 1 । हालाँकि, हम इसे और अधिक कुशलता से देख सकते हैं कि एक पुनरावृत्ति का n + 1 अगले पुनरावृत्ति के n के बराबर है , इसलिए हम 1यहाँ पर बचत कर सकते हैं:

((^|\3)(^1|1\3))+$

अब हमें सिर्फ 1एक सही वर्ग द्वारा विभाजित होने वाले इनपुट के बजाय एक प्रारंभिक कारक का उपयोग करके वापस जाना होगा :

((^|\3)(^(1+?)|\3\4))+$

अब हमें बस इतना करना है कि इस पूरी चीज़ $3को अंत में बदल दिया जाए, जो प्रारंभिक कारक समय को चरणों की संख्या में संग्रहीत करता है, जो इनपुट से वर्ग के एक कारक को गिरा देता है।

यह +प्रोग्राम की शुरुआत में बार-बार किया जाता है , ऐसे इनपुट्स को ध्यान में रखते हुए जिनमें वर्गों की तुलना में अधिक शक्तियां होती हैं।

Answer 8

ऑक्टेव, 27 बाइट्स

@(x)prod(unique(factor(x)))

अन्य उत्तरों के समान दृष्टिकोण। अंतर यह है: कार्यों के बहुत लंबे नाम हैं। मेरा मानना ​​है कि कोड खुद को वास्तव में समझाता है: एक नंबर prodके uniqueप्रमुख के uct को लेता है factor।

Comments

तुम मुझे निंजा ~ 30 सेकंड :)

— Kritii Lithos

अब नाम आप कहते हैं

— पावेल

Answer 9

वोल्फ्राम लैंग्वेज, 29 28 बाइट्स

-1 @ मर्टिन एंडर को धन्यवाद

Most[1##&@@FactorInteger@#]&

स्पष्टीकरण:

           FactorInteger@#    (*Get prime factorization as {{a,b},{c,d}}*)
     1##&@@                   (*Multiply list elements together, to get the product of the factors and the product of their exponents*)
Most[                     ]&  (*Take the first element*)

Comments

बस यह एहसास हुआ कि मूल रूप से मैथिक्स के उत्तर पर @ ग्रेगार्टिन की टिप्पणी, केवल कम गोल्फ ...

— स्कॉट मिलनर

बुरा मत मानना, मेरे पास इससे भी कम गोल्फ का जवाब थाTimes@@(#&@@@FactorInteger@#)&

— इयान मिलर

Mostइसे एक सूची के रूप में छोड़ देता है। आपको Firstमान प्राप्त करने की आवश्यकता है।

— इयान मिलर

@IanMiller मुझे एहसास है कि, लेकिन यह केवल एक तत्व के साथ एक सूची वापस करने के लिए कम बाइट्स है। मैंने मान लिया कि यह ठीक था, क्योंकि यह अभी भी एक उचित आउटपुट है।

— स्कॉट मिलनर

Answer 10

पायथन , 37 बाइट्स

f=lambda n,r=1:1>>r**n%n or-~f(n,r+1)

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

इसका सबसे बड़ा वर्ग विभाजक nवह सबसे छोटा है rजिसमें सभी nप्रमुख कारक हैं। हम इसकी जाँच कर सकते हैं r**n%n==0, क्योंकि प्रत्येक प्राइम फैक्टर की प्रतियां r**nबनाते हैं , और केवल तब तक ही विभाज्य है जब प्रत्येक प्राइम फैक्टर का प्रतिनिधित्व किया जाता है।nrnn

के 1>>r**n%nबराबर है int(r**n%n==0)। यदि Trueआउटपुट 1 का उपयोग किया जा सकता है, तो यह करने के लिए 2 बाइट्स कम है।

f=lambda n,r=1:r**n%n<1or-~f(n,r+1)

Answer 11

मैथिक्स , 40 बाइट्स

Times@@(Transpose@FactorInteger@#)[[1]]&

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

Comments

Times@@#&@@Transpose@FactorInteger@#&3 बाइट्स बचाता है ( इस तरह के मामलों में #&@@मानक चाल है [[1]]और यह अक्सर कोष्ठकों पर कुछ अतिरिक्त बाइट्स को बचा सकता है)।

— मार्टिन एंडर

तुम भी उपयोग कर सकते हैं Threadके बजाय Transpose। Mathematica में इसके लिए एक 3-बाइट ऑपरेटर भी है Transpose, लेकिन मुझे नहीं पता कि मैथिक्स इसका समर्थन करता है या नहीं।

— मार्टिन एंडर

#&@@(1##&@@FactorInteger@#)&Transposeपूरी तरह से जरूरत से बचा जाता है । ( 1##&@@बस है Times@@भेस, जो द्वारा उत्पन्न होने का आदेश दिया जोड़े पर अच्छा काम करता है में FactorInteger, और '#&@@है First@भेस में।)

— ग्रेग मार्टिन

@GregMartin मूल रूप से आपका अपना समाधान है, यदि आप चाहें तो इसे पोस्ट करने के लिए स्वतंत्र महसूस करें।

— पावेल

स्कॉट मिलनर जैसा दिखता है वैसे भी :)

— ग्रेग मार्टिन

Answer 12

ऐलिस , 4 बाइट्स

iDo@

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

इनपुट और आउटपुट एक चरित्र के कोड बिंदु के रूप में दिए गए हैं (सभी वैध यूनिकोड कोड बिंदुओं के लिए काम करता है)।

व्याख्या

खैर, ऐलिस में एक अंतर्निहित है, Dजिसकी परिभाषा "डेडुप्लिकेट प्रधान कारक" है। यही कारण है कि के रूप में एक मूल्य के कुछ से विभाज्य है, है जब तक पी ² एक प्रमुख के लिए पी , विभाजन कि द्वारा मूल्य पी । यह इस चुनौती में आवश्यक कार्य के समान होता है। बाकी सिर्फ इनपुट, आउटपुट है, प्रोग्राम को समाप्त करें।

कारण यह है कि ऐलिस में जोड़ा गया था वास्तव में इस पूर्णांक अनुक्रम से कोई लेना देना नहीं है। मैं विभाजकों और पात्रों के साथ प्रमुख कारकों के साथ विभाजकों को जोड़ने की एक थीम पर टिकने की कोशिश कर रहा था। और मुझे एक फ़ंक्शन की आवश्यकता थी जो "डिडुप्लिकेट पात्रों" के साथ जाता है (जो सामान्य रूप से बहुत अधिक उपयोगी है, क्योंकि यह आपको सेट के रूप में स्ट्रिंग्स का इलाज करता है, खासकर जब विभिन्न मल्टीसेट ऑपरेटरों के साथ मिलकर उपयोग किया जाता है)।

Comments

दुख की बात यह है कि बिलियन के साथ भी यह सबसे छोटा जवाब नहीं है।

— R

@ रिकर खैर, ऐसा इसलिए है क्योंकि ऐलिस एक गोल्फ भाषा नहीं है, इसलिए इसे स्पष्ट I / O और (क्योंकि यह एक 2D भाषा है) कार्यक्रम समाप्ति की आवश्यकता है।

— मार्टिन एंडर

हाँ, हालांकि अभी भी कुछ उदास है।

— 19

@ ConorO'Brien हमारे पास बस यह चर्चा कहीं और थी, और यह केवल तभी मान्य है जब स्टैंड-अलोन ऑपरेटर एक अभिव्यक्ति है जो फ़ंक्शन का मूल्यांकन करता है (जो कि यहां मामला नहीं है, क्योंकि फ़ंक्शन / ऑपरेटर प्रथम श्रेणी के मान नहीं हैं) । codegolf.meta.stackexchange.com/a/7206/8478

— मार्टिन

@ ConorO'Brien खेद है कि एक विशेष "हम" था।

— मार्टिन एंडर

Answer 13

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

f n=until(\r->r^n`mod`n<1)(+1)1

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

Answer 14

Pyke , 3 बाइट्स

P}B

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

P   -   factors(input)
 }  -  uniquify(^)
  B - product(^)

Answer 15

प्रोलोग (एसडब्ल्यूआई) , 84 39 बाइट्स

f(N,P):-between(1,N,P),P^N mod N=:=0,!.

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

प्रोलॉग को @ xnor के हास्केल उत्तर के विचार को अपनाया ।

Answer 16

PHP, 70 बाइट्स

for($r=1,$i=2;1<$n=&$argn;)$n%$i?++$i:$n/=$i+!($r%$i?$r*=$i:1);echo$r;

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

Answer 17

पायथ, 8 6 बाइट्स

*F+1{P

* -2 बाइट्स @LeakyNun को धन्यवाद

3 होगा यदि Pyth में सूचियों के उत्पादों के लिए अंतर्निहित ...

कोशिश करो!

*F+1{P
      Q     # Implicit input
     P      # Prime factors of the input
    {       # Deduplicate
  +1        # Prepend 1 to the list (for the case Q==1)
*F          # Fold * over the list

Comments

आप *F+1{Pइसके बजाय उपयोग कर सकते हैं ।

— लीक नून

Answer 18

सी, 65 50 बाइट्स

@ Johanrjan जोहानसन के लिए की जरूरत को दूर करने के लिए धन्यवाद r। इसके लिए धन्यवाद और कुछ अन्य गंदे चालें मैं 15 बाइट्स को निचोड़ने में सक्षम था!

d;f(n){for(d=1;d++<n;)n%(d*d)||(n/=d--);return n;}

whileचला गया और बदल दिया ||और सूचकांक के साथ बदल दिया । सब साथ <=होना चाहिए था <।

<=<प्राप्त करने के लिए वेतन वृद्धि को चालू करने के लिए n%(++d*d)(ऑपरेटर पूर्वता के कारण अच्छी तरह से परिभाषित किया जाना चाहिए)।

---

मूल कोड:

d;r;f(n){for(r=d=1;d++<=n;)while(n%d<1)r*=r%d?d:1,n/=d;return r;}

Comments

मुझे लगता है कि आप इसे हटाकर rउपयोग करने के बजाय इसे छोटा कर सकते हैं while(n%(d*d)<1)n/=d;।

— अर्जन जोहान्सन

@ .RjanJohansen जो सही लगता है। मैं कमी के बजाय निर्माण सोच रहा था। मेरे पास जोड़ने के लिए कुछ अतिरिक्त सुधार हैं, जल्द ही अपडेट होंगे।

— अल्जीमर

++d*dसी मानकों द्वारा पूरी तरह से परिभाषित नहीं है - यह स्पष्ट रूप से अपरिभाषित व्यवहार का एक क्लासिक मामला है। लेकिन हम यहाँ वैसे भी कार्यान्वयन द्वारा जा रहे हैं।

— अर्जन जोहान्सन

वास्तव में, नहीं होना चाहिए d++<n, जो अच्छी तरह से परिभाषित है, अभी भी काम करते हैं? मुझे लगता है कि पुराने संस्करण n+1(हानिरहित) सभी तरह से चले गए ।

— अर्जन जोहान्सन

आप शायद अपरिभाषित व्यवहार के बारे में सही हैं। किसी कारण से मुझे लगा कि ऑपरेटर पूर्वता से इसका समाधान होगा। अधिकांश उदाहरण जो मैंने यूबी के देखे हैं, वही प्राथमिकता वाले ऑपरेटरों का उपयोग करते हैं, लेकिन निश्चित रूप से यहां डेटा दौड़ भी है। आप सही d++<nहोने के बारे में भी सही हैं, किसी कारण से मैंने यह नहीं देखा कि जब मैंने कोड को फिर से लिखा था।

— अल्जीमर

Answer 19

Axiom, 89 बाइट्स

f(x:PI):PI==(x=1=>1;g:=factor x;reduce(*,[nthFactor(g,i) for i in 1..numberOfFactors g]))

परीक्षण और परिणाम

(38) -> [[i, f(i)] for i in 1..30 ]
   (38)
   [[1,1], [2,2], [3,3], [4,2], [5,5], [6,6], [7,7], [8,2], [9,3], [10,10],
    [11,11], [12,6], [13,13], [14,14], [15,15], [16,2], [17,17], [18,6],
    [19,19], [20,10], [21,21], [22,22], [23,23], [24,6], [25,5], [26,26],
    [27,3], [28,14], [29,29], [30,30]]

यह एक कारक () फ़ंक्शन का उपयोग नहीं करता है

g(x:PI):PI==(w:=sqrt(x);r:=i:=1;repeat(i:=i+1;i>w or x<2=>break;x rem i=0=>(r:=r*i;repeat(x rem i=0=>(x:=x quo i);break)));r)

लेकिन यह केवल 125 बाइट्स है

Answer 20

आर, 52 बाइट्स

`if`((n=scan())<2,1,prod(unique(c(1,gmp::factorize(n))))

स्टड nसे पढ़ता है। आवश्यक है gmp(ताकि TIO काम नहीं करेगा) पुस्तकालय स्थापित होने के लिए। उपरोक्त उत्तरों में से कई के रूप में एक ही दृष्टिकोण का उपयोग करता है, लेकिन यह इनपुट पर दुर्घटनाग्रस्त हो जाता है 1, क्योंकि factorize(1)कक्षा का एक खाली वेक्टर देता है bigz, जो दुर्घटनाग्रस्त हो जाता है unique, अफसोस।

Comments

यह 12 आउटपुट करता है जब मैं 12 इनपुट करता हूं

— फ्लॉडरर

@ फ़ाउंडर आप सही हैं, मैंने कोड अपडेट कर दिया है।

— ग्यूसेप

Answer 21

दरअसल , 2 बाइट्स

yπ

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

स्पष्टीकरण:

yπ
y   prime divisors
 π  product

Answer 22

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

n->factorback(factor(n)[,1])

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

Answer 23

Pyt , 3 बाइट्स

←ϼΠ

स्पष्टीकरण:

←                  Get input
 ϼ                 Get list of unique prime factors
  Π                Compute product of list
                   Implicit print