स्क्वरिश रूट का पता लगाएं

Question

लिखें कोड है कि जब दिए गए एक सकारात्मक संख्या इनपुट के रूप में, का सबसे बड़ा सकारात्मक भाजक आउटपुट से कम या के वर्गमूल के बराबर ।$x$$x$$x$

दूसरे शब्दों में सबसे बड़ा ऐसा पाते हैं$n > 0$

$\exists m\geq n:m\cdot n=x$

^{(मौजूद से अधिक या उसके बराबर ऐसा है कि बार है )एन एम एन $m$$n$$m$$n$$x$}

---

उदाहरण के लिए यदि इनपुट थे , तो भाजक , , , , और । पाने के लिए , और सभी बड़ी संख्याओं से गुणा करते हैं , लेकिन सबसे बड़ा है इसलिए हम लौटाते हैं ।$12$2 3 4 6 12 1 2 3 12 3 $1$$2$$3$$4$$6$$12$$1$$2$$3$$12$$3$$3$

---

यह कोड-गोल्फ है इसलिए उत्तर बाइट्स में कम बाइट्स के साथ स्कोर किया जाएगा जिसे एक बेहतर स्कोर माना जाता है।

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

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

OEIS A033676

Comments

मैं यह नहीं देखता कि पुराने निष्क्रिय लोगों के ठिकानों के रूप में लोकप्रिय सवालों को बंद करना साइट की मदद कैसे करता है ...? यदि आप इसे जल्दी नोटिस करते हैं, तो निश्चित रूप से, आगे बढ़ें और इसे हथौड़ा दें। यदि इसके पास उत्तर की तुलना में दोगुना और अधिक upvotes हैं। इसे रखें, और यदि कुछ भी हो, तो दूसरे को बंद कर दें ...

— स्टिव ग्रिफिन

@StewieGriffin "लोकप्रिय प्रश्नों" के साथ एक समस्या यह है कि वे HNQ पर हैं। जो शायद बहुत अच्छी बात नहीं है। / मैं यह नहीं देखता कि यह साइट को कैसे नुकसान पहुँचाता है, आप केवल उत्तर को पुराने पर ले जा सकते हैं।

— user202729

HNQ नए उपयोगकर्ताओं को आकर्षित कर सकता है, और यह एक अच्छी बात है (IMO)।

— स्टीवी ग्रिफिन

@qwr लेकिन मूल विचार एक ही है। अंतर बहुत छोटा है। प्रत्येक चुनौती में विधि दूसरे के लिए इस्तेमाल की जा सकती है।

— user202729

@ हाथ-ई-फूड मैं यह दावा नहीं करता कि यह अलग है। वास्तव में मेरा मानना ​​है कि दोनों की सामग्री समान है। आपके प्रश्न के बंद होने के मेरे कारण वही हैं जो थ्रेड के शीर्ष पर टिप्पणी में हैं, इस प्रश्न के अधिक उत्तर हैं। यदि आप वहां पूछना चाहते हैं तो मेटा यहाँ है । तुम भी में रुचि हो सकती है इस ।

— गेहूं जादूगर

Answer 1

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

def f(x):
 l=x**.5//1
 while x%l:l-=1
 return l

व्याख्या

• l=x**.5//1→ lवर्गमूल के बराबर की तुलना में सबसे बड़ा पूर्णांक निरुपित करेंx
• while x%l:l-=1→ जबकि lसमान रूप से विभाजित नहीं होता x, क्षय होता है l।

संपादित करता

• पायथन 3 का उल्लेख करें, न कि पायथन 2 का
• ...//1दो बाइट बचाने के लिए उपयोग करें । (दशमलव ठीक है! धन्यवाद @Rod)

Comments

PPCG में आपका स्वागत है, अच्छा पहला जवाब! आप का उपयोग करके कुछ बाइट्स बचा सकता है input/ printबजाय def/ return, आप भी जगह ले सकता है int(...)के साथ ...//1अधिक बाइट्स को बचाने के लिए के रूप में आप देख सकते हैं यहाँ

— रॉड

@Rod नहीं // 1, जैसा कि मैंने कहा है कि Python3। (जब तक कि आउटपुट के लिए दशमलव ठीक न हो, जो मैंने ऐसा नहीं सोचा था।) लेकिन पायथन 2 के लिए, धन्यवाद!

— hunteke

@ स्वेच्छा से दशमलव उत्पादन ठीक है, मुझे ऐसा कोई कारण नहीं दिख रहा है, जो होना चाहिए।

— गेहूं जादूगर

क्या यह "जबकि" के बजाय "फॉर" के साथ छोटा होगा, इसलिए आप सशर्त में मान निर्दिष्ट कर सकते हैं, संभवतः "एल" को परिभाषित करने से बचें?

— मालदीव

Answer 2

MATL , 7 बाइट्स

Z\tn2/)

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

इस स्पष्टीकरण के लिए, हम नमूना इनपुट के रूप में '12' का उपयोग करेंगे। स्पष्टीकरण:

Z\      % Divisors.
        % Stack:
        %   [1 2 3 4 6 12]
  t     % Duplicate.
        % Stack:
        %   [1 2 3 4 6 12]
        %   [1 2 3 4 6 12]
   n    % Number of elements.
        % Stack:
        %   6
        %   [1 2 3 4 6 12]
    2/  % Divide by 2
        % Stack:
        %   3
        %   [1 2 3 4 6 12]
      ) % Index (grab the 3rd element)
        % 3

यह बहुत भाग्यशाली संयोगों के कारण काम करता है।

1. MATL 1 अनुक्रमण का उपयोग करता है
2. अगर हम एक गैर-पूर्णांक के साथ इंडेक्स करते हैं (यह किसी भी पूर्ण वर्ग इनपुट के लिए होगा), तो<n>) को इंडेक्स करेगा$\lceil n \rceil$

Comments

...... अच्छी तरह से मैं सूना हो गया है!

— ग्यूसेप

यह आपको होना चाहिए जिन्होंने MATL :-)

— लुइस

BTW मुझे लगता है कि आप Z\J2/)( J2/या जब एक सूचकांक के रूप में इस्तेमाल किया जाता है तो इसके .5jलिए खड़ा end/2होता है) को छोटा कर सकते हैं

— लुइस मेंडेन

यह एक विषम संख्या वाले विभाजक के साथ एक संख्या पर लागू होने पर व्यवहार को समझाने के लायक हो सकता है, क्योंकि एक गैर-पूर्णांक मान के साथ "सूचकांक" स्पष्ट नहीं है।

— कामिल द्रकरी

@KamilDrakari वह कैसे है?

— DJMcMayhem

Answer 3

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

i;f(n){for(i=sqrt(n);n%i;i--);n=i;}

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

Comments

BTW, यह केवल GCC की sqrtअंतर्निहित फ़ंक्शन के रूप में मान्यता के कारण काम करता है । के साथ -fno-builtin-sqrt, जीसीसी मानता है int sqrt(int), और एक पास नहीं है double। X86-64 पर, doubleपूर्णांक की तुलना में एक अलग रजिस्टर में पारित किया जाता है। 32-बिट doubleपर, स्टैक पर 2 स्लॉट्स लगेंगे, इसलिए आप कचरा भी पार कर लेंगे (या मंटिसा के निचले हिस्से के रूप में पूर्णांक के साथ एक सबनॉर्मल, यदि ऊपरी 32 बिट शून्य थे)। यह तब तक भी टूटता है जब तक कि आप डिबग बिल्ड नहीं बना रहे हैं क्योंकि यह जीसीसी के डिफ़ॉल्ट-अन-अनुकूलित कोड-जनरल पर निर्भर करता है जो रिटर्न-वैल्यू रजिस्टर में अभिव्यक्तियों का मूल्यांकन करता है।

— पीटर कॉर्ड्स

@PeterCordes हां, यह कोड गोल्फ है, मेडिकल डिवाइस नहीं है

— क्लेब्लांक

वैसे मैं नकली-रिटर्न हैक का प्रशंसक नहीं हूं। यह अब सी भी नहीं है, यह सिर्फ एक कंपाइलर सेटिंग के साथ एक कार्यान्वयन विवरण है जो डिफ़ॉल्ट होता है। (यह वास्तव में "कम से कम एक कार्यान्वयन के साथ काम करना है" नियम को खींच sqrt()रहा है ।) मुद्दा अलग है: मैं उत्सुक था कि यह कैसे काम करने में कामयाब रहा, क्योंकि कॉल करने वाले को किसी भी तरह से कन्वर्ट intकरने के लिए जानना होगा double। मैंने उस जवाब को पोस्ट किया, जब किसी और ने टिप्पणी के रूप में उत्सुक था। प्रभावी रूप से जीसी sqrt(प्रोटोटाइप सहित) एक अंतर्निहित के रूप में है, अन्यथा यह उन कारणों के लिए विफल होगा जो हम कभी-कभी एसओ एएसएम क्यूएस में देखते हैं

— पीटर कॉर्ड्स

i;f(n){for(i=0;++i<n/i||n%i;);}31B है, और gcc -Ox86-64 (कमांड लाइन विकल्प के लिए 2 या 3 अधिक बाइट्स की लागत के साथ काम करता है ।) EAX से परिणाम छोड़ने ||के |कारणों के बजाय , रिटर्न-वैल्यू रजिस्टर ( godbolt.org/g-RJYeui) )। अनुक्रम बिंदु के बिना अपरिभाषित व्यवहार काम करने के लिए होता है। (Asm उत्पादित मूल रूप से मेरे x86 मशीन कोड उत्तर के समान है ।) के साथ , जीसीसी हमेशा EAX में छोड़ने लगता है , लेकिन शायद हम इसका उपयोग कर सकते हैं ...n/iidiv++i-O0i

— पीटर कॉर्ड्स

वैसे भी, यदि आपको गैर-सी gcc कार्यान्वयन-विवरण उत्तर पसंद हैं, तो शायद आप इस x86-64 gcc उत्तर को पसंद करेंगे, जो स्पष्ट रूप से अपरिभाषित व्यवहार के लिए संकलक द्वारा उत्पादित asm के कारण काम करने के लिए होता है: इसे ऑनलाइन आज़माएं! (31 + 2 बाइट्स)

— पीटर कॉर्ड्स

Answer 4

05AB1E , 5 बाइट्स

Ñ2äнθ

इसे ऑनलाइन आज़माएं! या टेस्ट सूट के रूप में

व्याख्या

Ñ        # push the list of divisors
 2ä      # split it into 2 parts
   н     # take the first haft
    θ    # take the last element of that

Answer 5

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

मुझे खुशी है कि मैं एपीएल में कुछ उत्तर लिखने में सक्षम था क्योंकि मैंने केवल इसे सीखा था। कई, कई गोल्फ के लिए मदद के लिए धन्यवाद। गोल्फ सुझाव बहुत स्वागत करते हैं। इसे ऑनलाइन आज़माएं!

एपीएल के बारे में अधिक जानने के लिए, एपीएल ऑर्चर्ड पर एक नज़र डालें ।

संपादित करें: -2 मेरे कोड के साथ एक समस्या को ठीक करने के लिए बाइट्स। उस समस्या को इंगित करने के लिए H.PWiz को धन्यवाद। -2 बाइट्स फिर से सब कुछ छोटा करने से।

⌈/{⍳⌊⍵*÷2}∨⊢

Ungolfing

⌈/{⍳⌊⍵*÷2}∨⊢
          ∨   GCD of the following...
           ⊢    The right argument, our input.
  {⍳⌊⍵*÷2}
     ⍵            Our input.
      *÷2         To the power of 1/2, i.e. square root.
    ⌊             Floor.
   ⍳              Indices up to floor(sqrt(input)).
                In total, range from 1 to floor(sqrt(input)).
⌈/            The maximum of the GCDs of our input with the above range.

Comments

आप रिवर्स ऑर्डर में स्ट्राइकथ्रू क्यों करते हैं? ... मैं अक्सर देखता हूं --- 16 --- --- 14 --- 12, 12 नहीं --- 14 --- --- 16 ---।

— user202729

@ user202729 सच कहूँ तो, यह एक समय हो गया है, और मैं काफी स्ट्राइकथ्रू के आदेश को भूल गया। शीघ्र ही ठीक कर देंगे।

— शर्लक

वास्तव में यह कोई समस्या नहीं है, लीडरबोर्ड स्निपेट दोनों का समर्थन करता है।

— user202729

Answer 6

भूसी , 4 बाइट्स

→←½Ḋ

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

व्याख्या

→←½Ḋ
   Ḋ      Divisors of (implicit) input.
  ½       Bisect.
→←        Take the last element of the first half.

Answer 7

आर , 45 33 बाइट्स

function(x,y=1:x^.5)max(y[!x%%y])

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

मूल:

function(x,y=x/1:x^.5)max(which(y==floor(y)))

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

Comments

33 बाइट्स

— Giuseppe

Answer 8

x86 32-बिट (IA32) मशीन कोड: 18 16 बाइट्स

चेंजलॉग: n=1टेस्ट केस को सही ढंग से संभालें , 2 बाइट्स बचाएं, और EAX में लौटें।

तब तक गिनें जब तक n/i <= i(जब हम sqrt तक पहुँचते हैं), और उसके बाद पहले सटीक भाजक का उपयोग करें।

इसका 64-बिट संस्करण x86-64 सिस्टम V कॉलिंग कन्वेंशन के साथ C से कॉल करने योग्य है, जैसा कि
int squarish_root_countup(int edi)।

nasm -felf32 -l/dev/stdout squarish-root.asm:

58                         DEF(squarish_root_countup)
59                             ; input: n in EDI
60                             ; output: EAX
61                             ; clobbers: eax,ecx,edx
62                         .start:
63 00000025 31C9               xor    ecx, ecx
64                         .loop:                    ; do{
65                         
66 00000027 41                 inc    ecx                ; ++i
67 00000028 89F8               mov    eax, edi
68 0000002A 99                 cdq
69 0000002B F7F9               idiv   ecx                ; edx=n%i    eax=n/i
70                         
71 0000002D 39C1               cmp    ecx, eax
72 0000002F 7CF6               jl     .loop          ; }while(i < n/i
73                                                   ;          || n%i != 0);  // checked below
74                             ; falls through for i >= sqrt(n)
75                             ; so quotient <= sqrt(n) if we get here
76                         
77                                                   ; test edx,edx / jnz  .loop
78 00000031 4A                 dec    edx            ; edx-1 is negative only if edx was zero to start with
79 00000032 7DF3               jge   .loop           ; }while(n%i >= 1);
80                             ; falls through for exact divisors
81                         
82                             ; return value = quotient in EAX
83                         
84 00000034 C3                 ret

           0x10 bytes = 16 bytes.

85 00000035 10             .size: db $ - .start

इसे ऑनलाइन आज़माएं! एक एएसएम कॉलर के साथ जो सीधे पूर्णांक के रूप में argv [1] की पहली बाइट का उपयोग करता है, और परिणाम को बाहर निकलने की स्थिति के रूप में उपयोग करता है।

$ asm-link -m32 -Gd squarish-root.asm && 
for i in {0..2}{{0..9},{a..f}};do 
    printf "%d   " "0x$i"; ./squarish-root "$(printf '%b' '\x'$i)"; echo $?;
done

0   0  # bash: warning: command substitution: ignored null byte in input
1   1
2   1
3   1
4   2
5   1
6   2
7   1
8   2
9   3
10   0       # this is a testing glitch: bash ate the newline so we got an empty string.  Actual result is 2 for n=10
11   1
12   3
13   1
14   2
15   3
16   4
   ...

Comments

क्या आप सुनिश्चित हैं कि n = 1 केवल 1 नहीं है? इसे एक परीक्षण मामले के रूप में सूचीबद्ध किया गया है और यह एक भाजक है =1 = 1.

— qwr

आपका उत्तर 1 के लिए काम करना चाहिए। यदि यह आपके एल्गोरिथ्म के साथ काम नहीं करता है, तो आपको इसे हार्ड कोड करना होगा।

— गेहूं जादूगर

@qwr: सभी इनपुट्स के लिए काम करने वाले एक छोटे संस्करण के साथ अपडेट किया गया।

— पीटर कॉर्ड्स

Answer 9

जाप -h, 8 6 बाइट्स

â f§U¬

कोशिश करो

2 बाइट्स ने ओलिवर को धन्यवाद दिया

---

व्याख्या

           :Implicit input of integer U
â          :Divisors of U
  f        :Filter
   §       :  Less than or equal to
    U¬     :  Square root of U
           :Implicitly get the last element in the array and output it

Comments

झंडे अभी भी बाइट्स लागत नहीं है?

— mbomb007

@ mbomb007 नहीं। ध्वज के प्रत्येक उदाहरण को एक नई भाषा प्रविष्टि माना जाता है।

— ओलिवर

कोई बात नहीं। मुझे लगता है मैंने उस मेटा पोस्ट को अभी तक नहीं देखा था ।

— mbomb007

Answer 10

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

ọⱮ½TṪ

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

Answer 11

जावास्क्रिप्ट ईएस 7, 33 31 बाइट्स

n=>(g=x=>n%x?g(x-1):x)(n**.5|0)

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

Answer 12

स्नोमैन , 38 बाइट्स

((}1vn2nD`#nPnF|:|NdE|;:,#NMo*|,;bW*))

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

((
  }        activate variables b, e, and g
  1vn2nD`  e=1/2
  #        retrieve the input into b
  nP       set b=b^e, which is sqrt(input)
  nF       floor the square root
  |        move b into g so there's space for a while loop
  :        body of the loop
    |NdE|  decrement the value in g
  ;:       loop condition
    ,#     assign b=input, e=current value
    NMo    store the modulo in g
    *|     discard the input value and place the modulo in the condition slot
    ,      put the current value back into g
  ;bW      continue looping while the modulo is nonzero
  *        return the result
))

Answer 13

डीसी , २४

?dsnv1+[1-dlnr%0<m]dsmxp

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

स्पष्टीकरण:

?                         # read input
 d                        # duplicate
  sn                      # store copy 1 in register n
    v                     # take the square root of copy 2
     1+                   # add 1
       [          ]       # define macro to:
        1-                #   subtract 1
          d               #   duplicate
           ln             #   load from register n
             r            #   reverse top 2 stack members
              %           #   calculate modulo
               0<m        #   if not 0, recursively call macro m again
                   d      # duplicate macro
                    sm    # store copy 1 in register m
                      x   # execute copy 2
                       p  # print final value

Answer 14

जे, 24 19 बाइट्स

-5 बाइट्स शर्लक के जीसीडी विचार के लिए धन्यवाद

([:>./+.)1+i.@<.@%:

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

मूल उत्तर

([:{:]#~0=]|[)1+i.@<.@%:

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

पार्स

┌───────────────────────────────┬──────────────────────┐
│┌──┬──┬───────────────────────┐│┌─┬─┬────────────────┐│
││[:│{:│┌─┬─────┬─────────────┐│││1│+│┌─────────┬─┬──┐││
││  │  ││]│┌─┬─┐│┌─┬─┬───────┐││││ │ ││┌──┬─┬──┐│@│%:│││
││  │  ││ ││#│~│││0│=│┌─┬─┬─┐│││││ │ │││i.│@│<.││ │  │││
││  │  ││ │└─┴─┘││ │ ││]│|│[││││││ │ ││└──┴─┴──┘│ │  │││
││  │  ││ │     ││ │ │└─┴─┴─┘│││││ │ │└─────────┴─┴──┘││
││  │  ││ │     │└─┴─┴───────┘│││└─┴─┴────────────────┘│
││  │  │└─┴─────┴─────────────┘││                      │
│└──┴──┴───────────────────────┘│                      │
└───────────────────────────────┴──────────────────────┘

व्याख्या

• 1 + i.@<.@%:सीमा देता है 1 .. floor(sqrt)।
• संपूर्ण क्रिया (A) Bएक हुक बनाती है, जिसमें उपरोक्त सीमा ]ए के दाहिने आर्ग के रूप में और मूल संख्या उसके बायें आर्ग के रूप में पास होती है [। इस प्रकार ...
• ] | [ मूल arg में विभाजित सीमा में प्रत्येक आइटम के रहने वाले देता है।
• और 0 = ] | [बचे हुए के साथ भाजक नहीं देता है।
• ] #~ ... फिर केवल उन लोगों को छोड़कर, सीमा को फ़िल्टर करता है।
• और {:सूची में अंतिम आइटम देता है, यानी, सबसे बड़ा।

Answer 15

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

½ḍƇµṪ

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

Answer 16

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

f x=[z|y<-[1..],z<-[1..y],y*z==x]!!0

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

$y$[1..]$z$[1..y]$(y,z)$$y \geq z$

$y\cdot z=x$$x$$y$$z$$y$$z$

$z$$z$

Answer 17

QBasic (4.5), 52 बाइट्स

INPUT x
FOR i=1TO sqr(x)
if x/i=x\i then m=i
next
?m

Answer 18

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

सबसे छोटा रास्ता फ़्लोटिंग पॉइंट स्टैक का उपयोग करता हुआ प्रतीत होता है और fsqrt, इसके बिना सबसे छोटा मैं 62 बाइट्स का उपयोग कर सकता था /modऔर जाँच कर सकता था कि क्या भागफल भाजक से अधिक था।

: f dup s>f fsqrt f>s 1+ begin 1- 2dup mod 0= until ;

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

व्याख्या

1. वर्गमूल की गणना करें
2. वर्गमूल से शुरू होकर, मूल संख्या का एक गुणनफल प्राप्त होने तक 1 तक की कमी

कोड स्पष्टीकरण

: f                \ Start a word definition
dup                \ duplicate the input
s>f fsqrt          \ move the number to the float stack and get the square root
f>s                \ truncate result and move to integer stack
1+                 \ add 1 to the square root
begin              \ start indefinite loop
  1- 2dup          \ decrement divisor and duplicate input and divisor
  mod              \ calculate n % divisor
0= until           \ if result equals 0 (no remainder) end the loop
;                  \ end the word definition

Answer 19

एफ #, 55 49 बाइट्स

let f x=Seq.findBack(fun i->x%i=0.0){1.0..x**0.5}

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

Seq.findBack: अंतिम तत्व लौटाता है जिसके लिए दिए गए फ़ंक्शन देता है True। इस मामले में फ़ंक्शन यह देखने के लिए जांचता है कि क्या कोई संख्या मान का एक कारक है।

Answer 20

ब्रेन-आलोचना , 144 बाइट्स

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

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

मुझे यकीन नहीं है कि यह जवाब बहुत अच्छा है। मुझे लगता है कि इस कार्य को हल करने का एक अच्छा तरीका हो सकता है लेकिन मैं अभी पर्याप्त चालाक नहीं हूं।

व्याख्या

मैंने उत्तर का एक धमाकेदार दृश्य करने की कोशिश की, लेकिन बहुत सारे चलती हिस्से हैं यह बहुत ज्ञानवर्धक नहीं था, इसलिए यहां एक स्पष्टीकरण है कि कोड क्या करता है।

पहला महत्वपूर्ण बिट यह है

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

यह स्टैक के शीर्ष पर दो नंबरों को लेता है और यदि वे असमान रूप से दूसरी वृद्धि करते हैं, यदि वे समान हैं तो यह पहले वाले को बढ़ाता है और दूसरे को शून्य के साथ बदलता है। अगर हम इस कोड को दोहराते हैं तो हमें सभी जोड़े ऐसे मिलेंगे जैसे x ≥ y ।$(x,y)$$x \geq y$

अगला भाग गुणा है, विकी से संशोधन के साथ लिया जाता है । यह गुणन विशेष है क्योंकि यह मौजूदा मूल्यों को नष्ट किए बिना संरक्षित करता है। यह इस प्रकार है:

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

इसलिए हम इन सभी ऑर्डर किए गए जोड़े को गुणा कर रहे हैं। प्रत्येक परिणाम के लिए हम जांचते हैं कि क्या यह इनपुट के बराबर है। यदि हां, तो हम जोड़ी में छोटी वस्तु को समाप्त करते हैं और वापस करते हैं।

Answer 21

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

n=k=input()
while(k*k>n)+n%k:k-=1
print k

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

Answer 22

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

ÆDŒHḢṪ

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

Answer 23

पर्ल 5 -p , 26 बाइट्स

$\=0|sqrt;$\--while$_%$\}{

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

Answer 24

जंग, 71 70 बाइट्स

fn f(x:u64)->u64{let mut l=(x as f64).sqrt()as u64;while x%l>0{l-=1}l}

पूर्व-कुरूप संस्करण

fn f(x: u64) -> u64 {                    // function takes u64, gives u64
  let mut l = (x as f64).sqrt() as u64;  // l takes integer'ed root value
  while x % l > 0 {                      // loop while l leaves remainder
    l -= 1                               // decrement
  }
  l                                      // return the found value
}

संपादित करता

• > 0ओवर के साथ एक बाइट सहेजें != 0। (@CatWizard को धन्यवाद)

Comments

!=से बदला जा सकता है >?

— गेहूं जादूगर

अच्छा निर्णय! हाँ।

— स्वेच्छा

Answer 25

जाप , 8 बाइट्स

â w æ§Uq

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

Answer 26

त्रिकोणीयता , 49 बाइट्स

....)....
...@_)...
..IEdF)..
.2)1/)IE.
^>{m.....

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

Answer 27

पाइरेट , 93 बाइट्स

{(z):rec f={(i,x):if num-modulo(i, x) == 0:x else:f(i,x - 1)end}
f(z,num-floor(num-sqrt(z)))}

आप इसे ऑनलाइन Pyret संपादक में कॉपी करके ऑनलाइन प्रयास कर सकते हैं !

उपरोक्त एक अनाम फ़ंक्शन का मूल्यांकन करता है। जब इसे पूर्णांक पर लागू किया जाता है, तो यह विनिर्देश के अनुसार एक परिणाम देता है।

Answer 28

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

मेरे APL उत्तर के आधार पर यहाँ । गोल्फ सुझाव का स्वागत करते हैं! इसे ऑनलाइन आज़माएं!

;√LR♀gM

Ungolfing

;√LR♀gM  Implicit input n
;        Duplicate n
 √       sqrt(n)
  L      floor(sqrt(n))
   R     1..floor(sqrt(n))
    ♀g   gcd(n, foreach(1..floor(sqrt(n)))
      M  The maximum of the GCDs.
         Return this maximum.

Answer 29

इस Mathematica उत्तर का एक बंदरगाह ।

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

½ðḞ³÷Ċ³÷µÐL

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

यह (11 बाइट्स) भी काम करता है, और इस पर निर्भर नहीं है ³:

½Ḟ÷@Ċ÷@ʋƬµṪ

दुर्भाग्य से ½Ḟ÷@Ċ÷@ʋÐL(10 बाइट्स) काम नहीं करता है। और जाहिरा तौर पर Ƭऔर ÐĿठीक उसी नहीं है (लिंक dyadic है जब)

---

$n$

• $i = \sqrt n$$a$
• प्रत्येक चरण पर:
  • $i$$\lfloor i\rfloor$
  • $n\over i$$a \le i \Rightarrow \frac n a \ge \frac n i \Rightarrow \frac n a \ge \lceil \frac n i \rceil \Rightarrow a \le n \div \lceil \frac n i \rceil$
• $i$$n \div \lceil \frac n {\lfloor i\rfloor} \rceil$

Answer 30

जावा 8, 65 54 बाइट्स

n->{int r=(int)Math.sqrt(n);for(;n%r>0;r--);return r;}

पोर्ट ऑफ हंटेनके पाइथन 3 उत्तर ।

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

---

पुराने 65 बाइट्स उत्तर:

n->{int r=1,i=n;for(;i-->1;)r=n%i<1&n/i<=i&n/i>r?n/i:r;return r;}

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

स्पष्टीकरण:

n->{                // Method with integer as both parameter and return-type
  int r=1,          //  Result-integer, starting at 1
  i=n;for(;i-->1;)  //  Loop `i` in the range (n, 1]
    r=n%i<1         //   If `n` is divisible by `i`,
      &n/i<=i       //   and if `n` divided by `i` is smaller than or equal to `i` itself,
      &n/i>r?       //   and if `n` divided by `i` is larger than the current `r`
       n/i          //    Set `n` divided by `i` as the new result `r`
      :             //   Else:
       r;           //    Leave result `r` unchanged
  return r;}        //  Return the result `r`