पूर्णांक का पूर्णांक वर्गमूल [बंद]

Question

संकट:

अपनी पसंद की भाषा में, सबसे छोटा फंक्शन लिखिए जो एक अहस्ताक्षरित 64-बिट पूर्णांक के वर्गमूल के फर्श को लौटाता है।

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

आपके इनपुट को सभी इनपुट के लिए सही ढंग से काम करना चाहिए, लेकिन यहां कुछ ऐसे हैं जो विचार को दर्शाने में मदद करते हैं:

               INPUT ⟶ OUTPUT

                   0 ⟶  0
                   1 ⟶  1
                   2 ⟶  1
                   3 ⟶  1
                   4 ⟶  2
                   8 ⟶  2
                   9 ⟶  3
                  15 ⟶  3
                  16 ⟶  4
               65535 ⟶ 255
               65536 ⟶ 256
18446744073709551615 ⟶ 4294967295

नियम:

1. आप अपने फंक्शन को कुछ भी नाम दे सकते हैं। (अनाम, अनाम या लंबोदर फ़ंक्शन ठीक हैं, जब तक कि वे किसी तरह कॉल करने योग्य हों।)
2. चरित्र की गिनती इस चुनौती में सबसे ज्यादा मायने रखती है, लेकिन रनटाइम भी महत्वपूर्ण है। मुझे यकीन है कि आप ओ (timen) समय में उत्तर के लिए ऊपर की ओर स्कैन कर सकते हैं एक बहुत ही छोटी वर्ण गणना के साथ, लेकिन O (लॉग (n)) का समय वास्तव में बेहतर होगा (यानी, n का इनपुट मान मानते हुए, n की थोड़ी लंबाई नहीं)।
3. आप शायद विशुद्ध रूप से पूर्णांक और / या बूलियन आर्टिथमिक का उपयोग करके फ़ंक्शन को लागू करना चाहेंगे। हालांकि, यदि आप वास्तव में फ्लोटिंग-पॉइंट गणनाओं का उपयोग करना चाहते हैं, तो यह तब तक ठीक है जब तक आप कोई लाइब्रेरी फ़ंक्शन नहीं कहते हैं। तो, बस return (n>0)?(uint32_t)sqrtl(n):-1;सी में यह कहना सही सीमा है कि यह सही परिणाम देगा। आप फ्लोटिंग प्वाइंट अंकगणित का प्रयोग कर रहे हैं, आप का उपयोग कर सकते हैं *, /, +, -, और घातांक (जैसे, **या ^अगर यह एक निर्मित में पसंद की अपनी भाषा में ऑपरेटर, लेकिन है केवल शक्तियों का घातांक 1 से कम नहीं )। यह प्रतिबंध कॉल sqrt()या एक प्रकार से "धोखा" को रोकने या। शक्ति के लिए एक मूल्य बढ़ाने के लिए है।
4. यदि आप फ्लोटिंग-पॉइंट ऑपरेशंस (# 3 देखें) का उपयोग कर रहे हैं, तो आपको आवश्यक नहीं है कि रिटर्न टाइप पूर्णांक हो; केवल यह कि वापसी मूल्य एक पूर्णांक, उदाहरण के लिए, फर्श (sqrt (n)) है, और किसी भी अहस्ताक्षरित 32-बिट मान को रखने में सक्षम है।
5. यदि आप C / C ++ का उपयोग कर रहे हैं, तो आप अहस्ताक्षरित 64-बिट और 32-बिट पूर्णांक प्रकारों, जैसे, uint64_tऔर uint32_tमें परिभाषित के अस्तित्व को मान सकते हैं stdint.h। अन्यथा, केवल यह सुनिश्चित करें कि आपका पूर्णांक प्रकार 64-बिट अहस्ताक्षरित पूर्णांक रखने में सक्षम है।
6. यदि आपका लैंग्वेज 64-बिट पूर्णांक का समर्थन नहीं करता है (उदाहरण के लिए, ब्रेनफक जाहिर तौर पर केवल 8-बिट पूर्णांक समर्थन है), तो उसके साथ अपना सर्वश्रेष्ठ करें और अपने उत्तर शीर्षक में सीमा का वर्णन करें। उस ने कहा, यदि आप यह जान सकते हैं कि 64-बिट पूर्णांक को कैसे एन्कोड किया जाए और 8-बिट आदिम अंकगणित का उपयोग करके सही ढंग से इसका वर्गमूल प्राप्त किया जाए, तो आपके लिए और अधिक शक्ति!
7. मज़े करो और रचनात्मक हो जाओ!

Comments

"लेकिन O (log but (n)) का समय वास्तव में बेहतर होगा।" - कितना बेहतर? क्या कोई बोनस है? क्या यह एक कठिन आवश्यकता है? क्या यह अनिवार्य रूप से एक अलग चुनौती है? क्या यह सिर्फ एक अच्छा विचार है जो वास्तव में स्कोरिंग को प्रभावित नहीं करता है?

— जॉन ड्वोरक

एल्गोरिदमिक जटिलता प्राप्त करने के लिए आम तौर पर एक इनपुट मूल्य के बजाय इनपुट आकार का उपयोग करता है। इस लिहाज से इंक्रीमेंट-एंड-रिट्री एल्गोरिदम गति में घातीय है।

— जॉन ड्वोरक

उम्म… O(log_2 n) === O(log_4 n)। log_4(n) = log_2(n) / log_2(2) = log_2(n) / 2

— जॉन ड्वोरक

2/4 की गिनती करता है?

— मिलो

अधिकांश फ्लोटिंग-पॉइंट डेटा प्रकारों में वैसे भी इस कार्य के लिए आवश्यक सटीकता नहीं होती है। 53 महत्वपूर्ण बिट्स पूरे इनपुट रेंज के लिए पर्याप्त नहीं हैं।

— user2357112

Answer 1

CJam, 17 (या 10) बाइट्स

{_1.5#\/i}

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

[0 1 2 3 4 8 9 15 16 65535 65536 18446744073709551615]{_1.5#\/i}%N*

यह क्योंकि मुद्दों गोलाई के अंतिम परीक्षण का मामला पारित नहीं होगा, लेकिन बाद से 18446744073709551615एक नहीं है पूर्णांक CJam में (यह एक है बिग पूर्णांक ), हम अभी भी अच्छा कर रहे हैं, है ना?

यदि नहीं, तो निम्नलिखित (और थोड़ा अधिक) कोड उन त्रुटियों को ठीक करेगा:

{__1.5#\/i_2#@>-}

अब और कम से कम समाधान नहीं है, लेकिन दोष ।

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

__    " Duplicate the integer twice. ";
1.5#  " Raise to power 1.5. Note that, since 1.5 > 1, this doesn't break the rules. ";
\     " Swap the result with the original integer. ";
/     " Divide. ";
i     " Cast to integer. ";
_2#   " Push square of a copy. ";
@     " Rotate the orginal integer on top of the stack. ";
>-    " If the square root has been rounded up, subtract 1. ";

Comments

Hahaha! ओह, ठीक है, तुम मुझे वहाँ एक तकनीकी पर मिल गया। मुझे कहना चाहिए कि कोई भिन्नात्मक शक्तियाँ नहीं हैं। लेकिन आपका कोड वास्तव में बताए गए नियमों का पालन करता है, इसलिए मैं इसे बढ़ा रहा हूं। :)

— टॉड लेहमैन

क्या CJam के पास संपूर्ण इनपुट रेंज को कवर करने के लिए मनमानी-सटीक दशमलव हैं?

— isaacg

इसके अलावा, NaN -> 0 से कास्ट का उपयोग करने का अच्छा हैक।

— इसहाक

नीट आइडिया, इसे ठीक उसी कैरेक्टर काउंट में J में दर्शाया जा सकता है <.@%~^&1.5:। क्या मैं इसे एक अलग उत्तर के रूप में पोस्ट कर सकता हूं (क्योंकि यह मूल रूप से आपका एक सटीक पोर्ट है)?

— atı

@ @ıɐɔuʎs: आगे बढ़ो। लेकिन मुझे अभी पता चला है कि मेरा समाधान अंतिम परीक्षा के मामले सहित बड़ी संख्या के लिए गलत तरीके से गोल हो सकता है। मेरे बचाव में, यह मेरी निरीक्षण पारित कर दिया सिर्फ इसलिए 4294967295और 4294967296देखो बहुत समान ...

— डेनिस

Answer 2

हास्केल, 28 26

मेरा मानना ​​है कि यह किसी भी भाषा से सबसे छोटी प्रविष्टि है जिसे गोल्फ के लिए डिज़ाइन नहीं किया गया था।

s a=[x-1|x<-[0..],x*x>a]!!0

यह sपैरामीटर के साथ एक फ़ंक्शन का नाम aदेता है और एक माइनस को पहला नंबर देता है जिसका वर्ग इससे अधिक है a। अविश्वसनीय रूप से धीरे-धीरे चलता है (O (sqrt n), हो सकता है?)।

Comments

क्या सूची सूची ( [...]!!0) सिर से छोटी नहीं होगी?

— ईसैक

@ आइसाकग हाँ, यह होगा। धन्यवाद :-)

— जक

Answer 3

गोल्फस्क्रिप्ट, 17 अक्षर

{).,{.*1$<},,\;(}

मैं अपने फंक्शन को किसी भी तरह से पसंद कर सकता था, लेकिन मैंने यह तय किया कि मैं इसका नाम बिल्कुल न रखूं। इसे नाम देने के लिए दो वर्ण जोड़ें, इसे नाम देने के लिए तीन जोड़ें और इसे स्टैक पर न छोड़ें, पूर्ण वर्ण प्रदान करने पर एक वर्ण घटाएं।

यह घृणा इनपुट के मूल्य में लघुगणक समय में नहीं चलती है, O (sqrt n) समय में नहीं है, परिणाम उत्पन्न करने के लिए यह एक पूर्ण रैखिक राशि लेता है। इसमें इतना स्पेस भी लगता है। बिलकुल भयावह। लेकिन ... यह कोड-गोल्फ है।

एल्गोरिथ्म है:

n => [0..n].filter(x => x*x < n+1).length - 1

Comments

मुझे यह पसंद है!! अच्छा काम! जो खूबसूरती से व्याप्त है।

— टॉड लेहमैन

Answer 4

अजगर , 14 वर्ण

DsbR;fgb*TTL'b

एक नामित फ़ंक्शन प्रदान करता है, जो इनपुट से बड़ा होने के लिए 0 से n तक की सूची को फ़िल्टर करके वर्गमूल की गणना करता है, फिर अंतिम संख्या को प्रिंट करता है। कोई घातांक या फ़्लोट्स का उपयोग नहीं करता है।

Dsb       def s(b):
R;        return last element of
f         filter(lambda T:
gb*TT                     b>=T*T,
L'b                       range(b+1))

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

python3 pyth.py <<< "DsbR;fgb*TTL'b       \msd[0 1 2 3 4 8 9 15 16 65535 65536"
[0, 1, 1, 1, 2, 2, 3, 3, 4, 255, 256]

Answer 5

रेटिना (गैर-प्रतिस्पर्धी - भाषा चुनौती से नई है), 43

इस उत्तर पर काम करते समय , मेरे साथ यह हुआ कि रेटिना का उपयोग करके पूर्णांक वर्गमूल की गणना के लिए एक समान विधि का उपयोग किया जा सकता है:

.+
$*
^
1:
+`(1+):(11\1)
1 $2:
1+:$|:1+

1+

यह इस तथ्य पर निर्भर करता है कि पूर्ण वर्ग के रूप में व्यक्त किया जा सकता है 1+3+5+7+..., और कोरोलरी द्वारा कि इस अभिव्यक्ति में शब्दों की संख्या वर्गमूल है।

इसे ऑनलाइन आज़माएं। (पहली पंक्ति को कई टेस्टकेस चलाने की अनुमति देने के लिए जोड़ा गया है।)

स्पष्ट रूप से दशमलव के लिए यूनिरी रूपांतरण के कारण, यह केवल अपेक्षाकृत छोटे इनपुट के लिए काम करेगा।

Comments

(भाषा चुनौती से नई है)

— mbomb007

@ mbomb007 फेयर काफी - हेडलाइन संपादित। यह उत्तर निश्चित रूप से "क्योंकि यह किया जा सकता है" श्रेणी में है, और किसी भी सार्थक तरीके से चुनौती का मुकाबला करने के लिए नहीं है।

— डिजिटल ट्रॉमा

मैं जानता हूं कि आपका क्या मतलब है ।

— mbomb007

Answer 6

पर्ल, 133 अक्षर

अब तक सबसे छोटा नहीं है, लेकिन किसी भी आकार के इनपुट को संभालने के लिए अंक-दर-अंक एल्गोरिथ्म का उपयोग करता है, और ओ (लॉग एन) समय में चलता है। संख्याओं के रूप में और संख्याओं के रूप में संख्याओं के बीच स्वतंत्र रूप से परिवर्तित करता है। चूँकि सबसे बड़ा संभव उत्पाद एकल अंक के वर्ग के साथ मूल-दूर है, इसलिए इसे 64-बिट सिस्टम पर 120-बिट या इतनी संख्या तक का वर्गमूल लेने में सक्षम होना चाहिए।

sub{($_)=@_;$_="0$_"if(length)%2;$a=$r="";while(/(..)/g){
$a.=$1;$y=$d=0;$a<($z=$_*(20*$r+$_))or$y=$z,$d=$_ for 1..9;$r.=$d;$a-=$y}$r}

विघटित, वह है:

sub {
  my ($n) = @_;
  $n = "0$n" if length($n) % 2; # Make an even number of digits
  my ($carry, $root);
  while ($n =~ /(..)/g) { # Take digits of $n two at a time
    $carry .= $1;         # Add them to the carry
    my ($product, $digit) = (0, 0);
    # Find the largest next digit that won't overflow, using the formula
    # (10x+y)^2 = 100x^2 + 20xy + y^2 or
    # (10x+y)^2 = 100x^2 + y(20x + y)
    for my $trial_digit (1..9) {
      my $trial_product = $trial_digit * (20 * $root + $trial_digit);
      if ($trial_product <= $carry) {
        ($product, $digit) = ($trial_product, $trial_digit);
      } 
    } 
    $root .= $digit;
    $carry -= $product;
  } 
  return $root;
}

Comments

अच्छा! मैं सोच रहा था कि जब कोई पर्ल जवाब देगा। BTW, यह कहने के if length%2बजाय काम करता है if(length)%2? यह 1 चरित्र को शेव करेगा। इसके अलावा, यह कहने के $y=$z,$d=$_ ifबजाय काम करेगा ($y,$d)=($z,$_)if? मुझे लगता है कि इससे 3 और चरित्रों का नाम बदल जाएगा।

— टॉड लेहमन

और यह थोड़ा विकृत हो रहा है, लेकिन मुझे लगता है कि आप forलूप को फिर से लिखकर 1 और शेव कर सकते हैं :$a<($z=$_*(20*$r+$_))or$y=$z,$d=$_ for(1..9);

— टॉड लेहमन

पहला सुझाव काम नहीं करता (यह नाम हैश की लंबाई लेने की कोशिश करता है %2), लेकिन अन्य मान्य हैं। मैं उन्हें अंदर काम करूँगा।

— जुब

@ToddLehman पोस्टफिक्स forको कोष्ठक की आवश्यकता नहीं है; आपके सुझावों में इसे शामिल करने से मुझे कुल 6 वर्ण मिलते हैं। धन्यवाद!

— जूल

Answer 7

मतलाब (56) / ऑक्टेव (55)

यह एक निश्चित बिंदु विधि का उपयोग करके वर्गमूल को बाहर करता है। यह अधिकतम 36 चरणों (तर्क के रूप में 2 ^ 64-1 के लिए) में परिवर्तित हो जाता है और फिर जांचता है कि क्या यह 'संभव' पूर्णांक जड़ों में से एक है। जैसा कि यह हमेशा 36 पुनरावृत्तियों का उपयोग करता है, इसमें O (1) = P का रनटाइम होता है

तर्क को uint64 माना जाता है।

Matlab:

function x=q(s)
x=1
for i = 1:36
    x = (x+s/x)/2
end
if x*x>s
    x=x-1
end

सप्तक:

function x=q(s)
x=1
for i = 1:36
    x = (x+s/x)/2
end
if x*x>s
    x-=1
end

Comments

यह मेरे लिए एक नई विधि है, और यह बहुत अच्छा होने के लिए होता है। +1

— seequ

यह मूल रूप से en.wikipedia.org/wiki/… है जो जल्द से जल्द ज्ञात संख्यात्मक विधियों में से एक है जो लगभग 3700 वर्ष पुराना है। इसे en.wikipedia.org/wiki/Banach_fixed-point_theorem द्वारा औचित्य दिया जा सकता है, जिसमें आश्चर्यजनक रूप से आसान प्रमाण है, यह वास्तव में अच्छा है =)

— त्रुटी

Answer 8

रूबी - 36 अक्षर

s=->n{g=n;g=(g+n/g)/2 while g*g>n;g}

Comments

अच्छी तरह से किया! सबसे खराब स्थिति वाला निष्पादन समय क्या है?

— टॉड लेहमैन

इस घटना के बारे में क्या है कि जी * जी <एन और जवाब अभी भी वांछित मूल्य के करीब नहीं है? स्क्रिप्ट बंद नहीं होगा?

— वैल्ली वेस्ट

@ToddLehman मैं ईमानदारी से नहीं जानता। : - / यह बेबीलोन की विधि है । यहाँ जो दिखता है वह औसत जटिलता का अच्छा प्रमाण है । संख्या का प्रारंभिक अनुमान ही बहुत बुरा है, लेकिन मुझे सबसे बुरे मामले को समझने के लिए नीचे बैठना होगा और वास्तव में उस प्रमाण को टटोलना होगा। जब मुझे कुछ और खाली समय मिलेगा, तब इसे छोड़ दूंगा। :-)

— OI

@WallyWest मेरी समझ यह है कि whileजब लूप मंजिल (estn) में परिवर्तित हो जाता है, तो वांछित मूल्य समाप्त हो जाता है। क्या आप कोई ऐसा मामला देखते हैं जहाँ यह सच नहीं होगा?

— OI

Answer 9

पायथन (39)

f=lambda n,k=0:k*k>n and k-1or f(n,k+1)

प्राकृतिक पुनरावर्ती दृष्टिकोण। जब तक उनका वर्ग बहुत अधिक नहीं हो जाता है, तब तक संभावित वर्गाकार जड़ों को गिना जाता है, तब 1. नीचे जाते हैं। स्टैकलेस पायथन का उपयोग करें यदि आप स्टैक की गहराई को पार करने के बारे में चिंतित हैं।

and/orमुहावरा के रूप में त्रिगुट ऑपरेटर के बराबर है

f=lambda n,k=0:k-1 if k*k>n else f(n,k+1)

संपादित करें: मैं बजाय प्राप्त कर सकते हैं 25 वर्ण नियम "आप उपयोग कर सकते हैं का दुरुपयोग करके *, /, +, -, और घातांक (जैसे, **या ^अगर यह एक निर्मित में पसंद की अपनी भाषा में ऑपरेटर, लेकिन केवल शक्तियों का घातांक 1 से कम नहीं है)। " (संपादित करें: जाहिर तौर पर डेनिस ने पहले से ही इस चाल को पाया और उसका फायदा उठाया।)

lambda n:n**1.5//max(n,1)

मैं //राउंड डाउन करने के लिए पायथन 3 के पूर्णांक डिवीजन ऑपरेटर का उपयोग करता हूं । दुर्भाग्य से, मैं इस मामले के लिए वर्णों का एक बहुत खर्च करता हूं n=00 त्रुटि द्वारा विभाजन नहीं देने के लिए। यदि इसके लिए नहीं, तो मैं 18 वर्ण कर सकता था

lambda n:n**1.5//n 

नियमों ने यह भी नहीं कहा कि फ़ंक्शन को नाम दिया जाना था (आप कैसे व्याख्या करते हैं "आप अपने फ़ंक्शन को अपनी पसंद के अनुसार नाम दे सकते हैं"), लेकिन अगर ऐसा होता है, तो यह दो और वर्ण हैं।

Comments

- धन्यवाद, मैं स्पष्ट कर दूंगा। इसे केवल एक फंक्शन होना चाहिए। इसका नाम नहीं है। तो, लैम्बडा फ़ंक्शन ठीक हैं। अगर मैं इसके बारे में सोचता तो मैं शुरू से ही इसका उल्लेख करता। मैं सी के संदर्भ में बहुत सोच रहा था जब मैंने प्रश्न पोस्ट किया था।

— टॉड लेहमैन

Answer 10

C99 (58 अक्षर)

यह एक उत्तर का एक उदाहरण है जिसे मैं एक अच्छा नहीं मानूंगा, हालांकि यह मेरे लिए कोड गोल्फ दृष्टिकोण से दिलचस्प है क्योंकि यह बहुत विकृत है, और मैंने सोचा कि मिश्रण में फेंकना मजेदार होगा:

मूल: 64 वर्ण

uint64_t r(uint64_t n){uint64_t r=1;for(;n/r/r;r++);return r-1;}

इसका कारण यह भयानक है कि यह O (लॉग) (n) समय के बजाय O (timen) समय में चलता है। (जहां n इनपुट मूल्य है।)

संपादित करें: 63 वर्ण

बदलने r-1के लिए --rऔर करने के लिए इसे सटे return:

uint64_t r(uint64_t n){uint64_t r=1;for(;n/r/r;r++);return--r;}

संपादित करें: 62 वर्ण

लूप वेतन वृद्धि को लूप के सशर्त भाग के अंदर ले जाना (नोट: इसमें अस्पष्ट व्यवहार है क्योंकि प्रीइंक्रिमेंट ऑपरेटर के संबंध में संचालन का क्रम संकलक-विशिष्ट है):

uint64_t r(uint64_t n){uint64_t r=0;for(;n/++r/r;);return--r;}

संपादित करें: 60 वर्ण

typedefछिपाने के लिए जोड़ना uint64_t( इस सुझाव के लिए उपयोगकर्ता टेक्नोसॉरस का श्रेय )।

typedef uint64_t Z;Z r(Z n){Z r=0;for(;n/++r/r;);return--r;}

संपादित करें: 58 वर्ण

अब फ़ंक्शन के आह्वान में 0 के रूप में पारित होने वाले दूसरे पैरामीटर की आवश्यकता होती है, उदाहरण के लिए, r(n,0)इसके बजाय r(n)। ठीक है, मेरे जीवन के लिए, इस बिंदु पर मैं यह नहीं देख सकता कि इसे आगे कैसे संपीड़ित करें ... कोई भी?

typedef uint64_t Z;Z r(Z n,Z r){for(;n/++r/r;);return--r;}

Comments

आप वेतन वृद्धि के बजाय यह सी ++ और घटती कॉल करने के लिए तैयार हैं, तो आप पात्रों में से एक जोड़े को बंद दाढ़ी बनाने के लिए सक्षम हो जाएगा: uint64_t s(uint64_t n){for(uint64_t r=n;--n>r/n;);return n;}।

— फोर्स

@Fors - अच्छा तरीका! दुर्भाग्य से, यह 1 के इनपुट के लिए विभाजन-दर-शून्य का कारण नहीं होगा? इसके अलावा, यह 0 के इनपुट के लिए क्या करेगा? क्योंकि --nकब n==0होगा -1, और ये अहस्ताक्षरित मूल्य हैं, इसलिए -1 -1 2 1 -1 होगा।

— टॉड लेहमैन

#define Z uint64_t ... या

— टाइपडिफ

@technosaurus - आह हां, जो बचाता है 2. धन्यवाद। :-)

— टॉड लेहमैन

अभिव्यक्ति n/++r/rमें अपरिभाषित व्यवहार होता है ....

— aschepler

Answer 11

गोल्फस्क्रिप्ट - 14 वर्ण

{.,\{\.*<}+?(}

iजिस इनपुट के nलिए कम से कम संख्या का पता लगाएं n < i*i। वापसी i - 1।

अर्थात [0..n-1].first(i => n < i*i) - 1

इनपुट के साथ सैंपल कॉल के लिए जो लोग गोल्फ के रूप में अच्छी तरह से नहीं जानते हैं, उनके लिए स्पष्टीकरण 5:

.        //Duplicate input.  Stack: 5 5
,        //Get array less than top of stack.  Stack: 5 [0 1 2 3 4]
\        //Switch top two elements of stack.  Stack: [0 1 2 3 4] 5
{\.*<}+  //Create a block (to be explained), and prepend the top of the stack.  
         //Stack: [0 1 2 3 4]{5\.*<}
?        //Find the first element of the array for which the block is true. 
         //So, find the first element of [0 1 2 3 4] for which {5\.*<} evaluates to true.
         //The inner block squares a number and returns true if it is greater than the input.
(        //Decrement by 1 

Comments

ऊह, यह पिछले सर्वश्रेष्ठ गोल्फस्क्रिप्ट उत्तर की तुलना में 3 अक्षर छोटा है। अच्छा काम!

— टॉड लेहमैन

इनपुट के लिए सही उत्तर देने के लिए इसे ठीक करने से 1संभवतः दो वर्ण लगते हैं।

— पीटर टेलर

Answer 12

हास्केल, 147 138 134 128 बाइट्स

दुनिया का सबसे छोटा कोड नहीं है, लेकिन यह O (लॉग एन) में चलता है, और मनमाने आकार के नंबरों पर:

h x=div(x+1)2
n%(g,s)|g*g<n=(g+s,h s)|g*g>n=(g-s,h s)|0<1=(g,0)
f(x:r@(y:z:w))|x==z=min x y|0<1=f r
s n=fst$f$iterate(n%)(n,h n)

यह sqrt (n) के लिए सबसे अच्छा कम सन्निकटन खोजने के लिए सीमा [0..n] की एक द्विआधारी खोज करता है। यहाँ एक ungolfed संस्करण है:

-- Perform integer division by 2, rounding up
half x = x `div` 2 + x `rem` 2

-- Given a guess and step size, refine the guess by adding 
-- or subtracting the step as needed.  Return the new guess
-- and step size; if we found the square root exactly, set
-- the new step size to 0.
refineGuess n (guess, step)
    | square < n  =  (guess + step, half step)
    | square > n  =  (guess - step, half step)
    | otherwise   =  (guess, 0)
    where square = guess * guess     

-- Begin with the guess sqrt(n) = n and step size (half n),
-- then generate the infinite sequence of refined guesses.
-- 
-- NOTE: The sequence of guesses will do one of two things:
--         - If n has an integral square root m, the guess 
--           sequence will eventually be m,m,m,...
--         - If n does not have an exact integral square root,
--           the guess sequence will eventually alternate
--           L,U,L,U,.. between the integral lower and upper
--           bounds of the true square root.
--        In either case, the sequence will reach periodic
--        behavior in O(log n) iterations.
guesses n = map fst $ iterate (refineGuess n) (n, half n)

-- Find the limiting behavior of the guess sequence and pick out
-- the lower bound (either L or m in the comments above)
isqrt n = min2Cycle (guesses n)
    where min2Cycle (x0:rest@(x1:x2:xs))
            | x0 == x2    =   min x0 x1
            | otherwise   =   min2Cycle rest

संपादित करें: "ट्रू" के एक छोटे संस्करण के रूप में "0 <1" के साथ "अन्यथा" खंड को प्रतिस्थापित करके दो बाइट्स सहेजे गए, और जी * जी को इनलाइन करके कुछ और।

इसके अलावा, यदि आप O (sqrt (n)) से खुश हैं तो आप बस कर सकते हैं

s n=(head$filter((>n).(^2))[0..])-1

35 पात्रों के लिए, लेकिन वह क्या मजेदार है?

संपादित करें 2: मुझे बस एहसास हुआ कि चूंकि जोड़े मिक्सकाइकिल करने के बजाय शब्दकोष द्वारा क्रमबद्ध किए जाते हैं। नक्शा fst, मैं बस fst कर सकते हैं। min2Cycle। गोल्फ कोड में, जो $ f के साथ f $ मैप fst को बदलने के लिए अनुवाद करता है, जिससे 4 और बाइट्स बचती हैं।

संपादित करें 3: घमौरियों के लिए धन्यवाद छह और बाइट्स सहेजे गए!

Comments

आप अपने "आधे" फ़ंक्शन पर div (x + 1) 2 के साथ (div x 2 + rem x 2) को बदल सकते हैं

— गर्वित हैकेलर

मेरे पास वास्तव में अपना खुद का एक समाधान है जिसमें 49 वर्ण हैं, और ओ (लॉग एन) में हल है, लेकिन मेरे पास केवल अपवोट हैं; --( मुझे समझ नहीं आता कि क्यों

— गर्व हैकेलर

Answer 13

जावास्क्रिप्ट 91 88 86: गति के लिए अनुकूलित

function s(n){var a=1,b=n;while(Math.abs(a-b)>1){b=n/a;a=(a+b)/2}return Math.floor(a)}

जावास्क्रिप्ट 46: गति के लिए गैर अनुकूलित

function s(n){a=1;while(a*a<=n)a++;return a-1}

यहाँ एक JSField है: http://jsfiddle.net/rmadhuram/1Lnjuo4k/

Comments

PPCG में आपका स्वागत है! आप स्ट्राइकथ्रू के लिए <s> 91 </ s> <s> 88 </ s> का उपयोग कर सकते हैं। मैंने संपादन करने की कोशिश की, लेकिन आप उसी समय संपादन कर रहे थे इसलिए मैं आपको इसे करने दूंगा।

— रेनबोलेट

या आप इसे इस तरह 41 अक्षरों में कर सकते हैं:function s(n){for(a=1;++a*a<n;);return a}

— Rhubarb Custard

Answer 14

C 95 97

टंकण संपादित करें , @Michaelangelo द्वारा सुझाया गया

यह हेरॉन एल्गोरिदम का एक सीधा कार्यान्वयन कमोबेश होना चाहिए। केवल क्विकर पूर्णांक अतिप्रवाह से बचने के लिए औसत कंप्यूटिंग में है: a = (m + n) / 2 biiiig संख्याओं के लिए काम नहीं करता है।

typedef uint64_t Z;
Z q(Z x)
{
   Z n=1,a=x,m=0;
   for(;a-m&&a-n;) n=a,m=x/n,a=m/2+n/2+(m&n&1);
   return a;
}

Comments

अतिप्रवाह परिहार के साथ अच्छा काम - न केवल सही तरीके से करने के लिए, बल्कि पहली जगह में इसके बारे में सोचने और इसका परीक्षण करने के लिए ध्यान रखना। निश्चित रूप से सराहना की।

— टॉड लेहमैन

BTW, यह मजेदार है कि कुछ CPU पर कितना महंगा विभाजन हो सकता है। भले ही यह एल्गोरिथ्म अबैकस एल्गोरिथ्म के रूप में लगभग आधे चरणों में निष्पादित होता है, लेकिन यह एक रनटाइम है जो अबैकस एल्गोरिथ्म की तुलना में लगभग 5 गुना धीमा है जब मैं इसे अपने कोर आई 7 सीपीयू पर बेंचमार्क करता हूं, जो विभाजन करना पसंद नहीं करता है। वैसे भी, लेकिन यहां रनटाइम महत्वपूर्ण नहीं है - केवल आकार। :) इतना अच्छा काम !!!

— टॉड लेहमैन

Answer 15

C # 64 62 55

चूँकि यह एक कोड-गोल्फ है (और मैं गणित के साथ भयानक हूँ), और रनटाइम केवल एक सुझाव है, मैंने अनुभवहीन दृष्टिकोण किया है जो रैखिक समय में चलता है:

decimal f(ulong a){var i=0m;while(++i*i<=a);return--i;}

( डॉटनेटफिल्ड पर परीक्षण )

बेशक, यह बड़ी जानकारी के लिए बहुत धीमी है।

Comments

आप को बदलकर एक चरित्र को दाढ़ी बनाने में सक्षम हो सकता return i-1है return--i?

— टोड लेहमैन

अभिव्यक्ति में i*i<=a, यह सामान्य प्रकार के पूर्णांक अंकगणितीय होने की गारंटी है? (मैं C # से परिचित नहीं हूं।) यदि हां, और यदि C #, बूलियन को अंतर्निहित पूर्णांक रूपांतरण की अनुमति देता है, तो आप इसे बदलकर एक और चरित्र को बचाने में सक्षम हो सकते हैं a/i/i।

— टोड लेहमैन

@ToddLehman जो वास्तव में फिक्स्ड-पॉइंट अंकगणित ( Decimal, उच्च अधिकतम मूल्य और सटीक) होता है, ओवरफ्लो से बचने के लिए क्योंकि गुणा परिणाम संभावित रूप से एक कदम अतीत तक जा सकता है UInt64.MaxValue। लेकिन C # का वैसे भी बूलियन से कोई रूपांतरण नहीं है। मैं returnहालांकि, धन्यवाद बदलने में सक्षम होना चाहिए । कंप्यूटर पर वापस आने पर मैं इसे करूँगा।

— बॉब

Answer 16

क्लोजर - 51 या 55 बाइट्स

N को 0 से सभी संख्याओं की जांच करता है, जहां पहले वाला देता है x^2 <= n। रनटाइम हैO(n - sqrt n)

बेनाम:

(fn[x](first(filter #(<=(* % %)x)(range x -1 -1))))

नाम दिए गए:

(defn f[x](first(filter #(<=(* % %)x)(range x -1 -1))))

उदाहरण:

(map (fn[x](first(filter #(<=(* % %)x)(range x -1 -1)))) (range 50))
=> (0 1 1 1 2 2 2 2 2 3 3 3 3 3 3 3 4 4 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 5 5 5 6 6 6 6 6 6 6 6 6 6 6 6 6 7)

Answer 17

Befunge 93 - 48 बाइट्स या 38 अक्षर

101p&02p>02g01g:*`#v_01g1-.@
        ^  p10+1g10<        

इसे यहाँ पर आज़माएँ ।

Comments

ठीक है, यह सिर्फ अच्छा है। अच्छा काम! मैंने 17 में प्रवेश किया, क्रीप पर क्लिक किया और फिर रन किया, और यह 4 के साथ आया! :)

— टॉड लेहमैन

Answer 18

कोबरा - 62

do(n as uint64)as uint64
    o=n-n
    while o*o<n,o+=1
    return o

बैच - 74

set a=0
:1
set /ab=%a%*%a%
if %b% LSS %1 set /aa=%a%+1&goto 1
echo %a%

Answer 19

हास्केल, 53 50 49 वर्ण, हे (लॉग एन)

s n=until((<=n).(^2))(\g->g-1-div(g^2-n-1)(2*g))n

यह समाधान न्यूटन-रफसन विधि को लागू करता है, हालांकि यह फ्लोट के बजाय पूर्णांक खोजता है। wiki: http://en.wikipedia.org/wiki/Newton%27s_method

जटिलता O (log n) के बारे में प्रतीत होती है, लेकिन क्या इसका कोई प्रमाण है? कृपया टिप्पणियों में उत्तर दें।

Comments

\g->div(n+g^2)$2*g7 बाइट्स बचाता है।

— एंडर्स कासोर्ग

Answer 20

जे (10)

@ डेनिस के उत्तर से बहुत, बहुत, बहुत प्रेरित :

<.@%~^&1.5

और थोड़ा लंबा, लेकिन बेहतर प्रदर्शन के साथ (मुझे संदेह है):

<.@(-:&.^.)

floor(halve under log)

निष्पादित करने के लिए, इंडेंटेड पार्ट्स इनपुट हैं:

   f=:<.@%~^&1.5
   f 0 8 12 16
0 2 3 4
   g=:<.@(-:&.^.)
   g 0 8 12 16
0 2 3 4

Comments

किसी दिए गए पूर्णांक के लिए आप इसे कैसे निष्पादित करते हैं?

— डेनिस

@ डेनिस उत्तर देखें

— ʇǝɥʇıʇǝɥʇuenniss

Answer 21

एपीएल - 12 चार्ट, 19 बाइट्स

{⌊(⍵*1.5)÷⍵}

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

{⌊(⍵*1.5)÷⍵}17

रिटर्न 4

टेस्ट वेक्टर

{⌊(⍵*1.5)÷⍵}¨0 1 2 3 4 8 9 15 16 65535 65536 18446744073709551615

रिटर्न

1 1 1 2 2 3 3 4 255 256 4294967296

ऑनलाइन प्रयास करें

एल्गोरिथ्म के लिए उपयोगकर्ता "ssdecontrol" के लिए बड़ा धन्यवाद

Comments

PPCG में आपका स्वागत है! हम आम तौर पर एपीएल को प्रति चरित्र एक बाइट के रूप में स्कोर करते हैं। जब तक चुनौती इसे निर्दिष्ट नहीं करती, तब तक UTF-8 में गणना करने की आवश्यकता नहीं है। कोई मौजूदा एन्कोडिंग ठीक है, और दिन में पीछे से एक पुराना एपीएल कोडपेज है जो प्रत्येक चरित्र के लिए एक बाइट का उपयोग करता है। तथ्य यह है कि APL ASCII से पहले गैर-ASCII वर्णों का उपयोग करने के लिए इसे दंडित करने का एक बुरा कारण है। ;) (यह कहा, यह पुरानी चुनौती वैसे भी पात्रों द्वारा स्कोर करने के लिए लगता है।)

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

@MartinEnder गर्मजोशी से स्वागत और युक्तियों के लिए धन्यवाद :)

— QuantumKarl

0→ 1! Dyalog APL का उपयोग करके , आप ⎕DIV←1सही परिणाम प्राप्त करने के लिए (जो डिफ़ॉल्ट रूप में कई उपयोग) सेट कर सकते हैं ।

— आदम

Answer 22

C99 (108 वर्ण)

यहाँ C99 में मेरा अपना समाधान है, जिसे विकिपीडिया पर एक लेख में एक एल्गोरिथ्म से रूपांतरित किया गया है । मुझे यकीन है कि अन्य भाषाओं में इससे बेहतर करना संभव होगा।

golfed:

uint64_t s(uint64_t n){uint64_t b=1,r=0;while(n/b/4)b*=4;for(;b;b/=4,r/=2)n>=r+b?r+=b,n-=r,r+=b:0;return r;}

आंशिक रूप से गोल्फ:

uint64 uint64_sqrt(uint64 n)
{
  uint64 b = 1, r = 0;
  while (b <= n / 4)
    b *= 4;
  for (; b; b /= 4, r /= 2)
    if (n >= r + b)
      { r += b; n -= r; r+= b; }
  return r;
}

Ungolfed:

uint64_t uint64_sqrt(uint64_t const n)
{
  uint64_t a, b, r;

  for (b = 1; ((b << 2) != 0) && ((b << 2) <= n); b <<= 2)
    ;

  a = n;
  r = 0;
  for (; b != 0; b >>= 2)
  {
    if (a >= r + b)
    {
      a -= r + b;
      r = (r >> 1) + b;
    }
    else
    {
      r >>= 1;
    }
  }

  // Validate that r² <= n < (r+1)², being careful to avoid integer overflow,
  // which would occur in the case where n==2⁶⁴-1, r==2³²-1, and could also
  // occur in the event that r is incorrect.
  assert(n>0? r<=n/r : r==0);  // Safe way of saying r*r <= n
  assert(n/(r+1) < (r+1));     // Safe way of saying n < (r+1)*(r+1)

  return r;
}

Comments

सुझाव: aउपयोग की कोई आवश्यकता नहीं है n।

— edc65

आह येस। धन्यवाद। अपने मूल संस्करण में, मैं इसे बनाए रख रहा था nताकि लौटने से पहले मैं जोर दे सकूं (नहीं दिखाया गया) कि r ^ 2 <= n <(r + 1) ^ 2। उस जोर के साथ छोड़ दिया, यह अब nबरकरार रखने के लिए आवश्यक है।

— टोड लेहमैन

@ edc65 - यह इंगित करने के लिए फिर से धन्यवाद। मैंने अपने कोड को प्रतिबिंबित करने के लिए अपडेट किया, साथ ही साथ कुछ अन्य गोल्फ ट्रिक्स भी जोड़े। इसके अलावा मूल कथनों को जोड़ा गया और constungolfed संस्करण में n बनाया गया।

— टोड लेहमैन

Answer 23

जावास्क्रिप्ट 73 81 (64-बिट संख्या आवश्यकता का अनुपालन करने के लिए)

n=prompt();g=n/3;do{G=g,g=(n/g+g)/2}while(1E-9<Math.abs(G-g))alert(Math.floor(g))

सिकंदरिया के एल्गोरिथ्म के हेरोन को लागू करना ...

Comments

अच्छा! क्या यह सभी अहस्ताक्षरित 64-बिट पूर्णांक इनपुट के लिए काम करता है?

— टॉड लेहमन

के रूप में मैं यह केवल 32-बिट तक काम करने के लिए लगता है की कोशिश कर सकते हैं ... मेरी निराशा के लिए बहुत कुछ ...

— WallyWest

निश्चित रूप से अंतिम | 0 किसी भी मान को 32 बिट तक काटता है। इसके बजाय Math.floor का उपयोग कर रहे हैं?

— edc65

@ edc65 आप वास्तव में सही हैं, ऐसा लगता है |0कि 32-बिट तक प्रभावित होता Math.floorहै जबकि 64-बिट पर अधिक प्रभावी होता है ... मैंने अपना कोड अपडेट कर दिया है, ऐसा करने के लिए एक अतिरिक्त 8 अक्षर लेने होंगे ...

— WallyWest

@ edc65 मैंने अभी सोचा है ... ~ ~ x 64-बिट में काम करेगा?

— वैलेस्ट वेस्ट

Answer 24

Powershell (52) Limited से Int32 (-2,147,483,648 से 2,147,483,647)

function f($n){($n/2)..0|%{if($_*$_-le$n){$_;exit}}}

मैं पॉवरशेल में चिल्ला रहा हूं अभी अंतिम परीक्षण मामले को काम करने की कोशिश कर रहा हूं, लेकिन कोई फर्क नहीं पड़ता कि मैं पॉवरशेल विंड को एक इंट32 के रूप में पाइपलाइन चर $ _ का उपयोग करके क्या करता हूं, और मुझे अभी इसके आसपास कोई रास्ता नहीं मिल रहा है।

तो मैं अभी के लिए अपने उत्तर को सीमित करूँगा। अगर मुझे uint64s को संभालने का एक बेहतर तरीका मिल जाए तो मैं संपादित करूंगा। (पिछले परीक्षण का मामला वैसे भी पॉवर्सशेल के सामान्य Int64 प्रकार के लिए बहुत बड़ा है!)

यहाँ कुछ परीक्षण मामले हैं (कुछ अतिरिक्त आउटपुट के साथ, जिनका उपयोग मैंने समय को ट्रैक करने के लिए किया था)

f 17
4
Elapsed Time: 0.0060006 seconds

f 65
8
Elapsed Time: 0.0050005 seconds

f 65540
256
Elapsed Time: 1.7931793 seconds

f 256554
506
Elapsed Time: 14.7395391 seconds

मुझे अपना O () पता नहीं है, लेकिन यह एक बहुत ही नाटकीय छलांग जैसा लगता है।

Answer 25

कैविएट: 2011 तक, आर के पास 64 बिट पूर्णांकों के लिए कोई अंतर्निहित समर्थन नहीं था जैसा कि मैंने मान लिया था। ये उत्तर उस तकनीकी पर अमान्य हो सकते हैं, लेकिन फिर पिछले 3 वर्षों में आर बहुत बदल गया है।

---

आर, 85

न्यूटन की विधि का उपयोग करना:

function(n){s=F
x=n
y=(1/2)*(x+n/x)
while(abs(x-y)>=1){x=y
y=(1/2)*(x+n/x)}
trunc(y)}

जो चतुष्कोणीय रूप से परिवर्तित होता है। बेंचमार्किंग के लिए फंक्शन को वेरिएबल में असाइन करने के लिए +2 कैरेक्टर:

microbenchmark(q(113424534523616))
# Unit: microseconds
#                expr    min      lq median      uq    max neval
#  q(113424534523616) 24.489 25.9935 28.162 29.5755 46.192   100

---

आर, ३ 37

पाशविक बल:

function(n){t=0
while(t^2<n) t=t+1
t}

और एक ही जाँच:

microbenchmark::microbenchmark(q(113424534523616),times=1)
# Unit: seconds
#                 expr      min       lq   median       uq      max neval
#   q(113424534523616) 4.578494 4.578494 4.578494 4.578494 4.578494     1

---

आर, 30

सस्ते / प्रतिभाशाली घातांक चाल :

function(n) trunc(n^(1.5)/n)

जो बहुत तेज़ी से होता है (हालाँकि बिल्ट-इन जितना तेज़ नहीं है):

microbenchmark(q(113424534523616),sqrt(113424534523616))
# Unit: nanoseconds
#                   expr min    lq median    uq  max neval
#     z(113424534523616) 468 622.5  676.5 714.5 4067   100
#  sqrt(113424534523616)  93 101.0  119.0 160.5 2863   100

Answer 26

सी, 38

f(n){int m;while(++m*m<=n);return--m;}

मेरे फोर्थ सबमिशन का अनुवाद। धीमा लेकिन सही। हे (√n)। ओएस एक्स (64 बिट) पर परीक्षण किया गया।

Answer 27

डीसी, 50 बाइट्स

dc -e"?dsist[lt2/dstd*li<B]dsBx[lt1+dstd*li!<A]dsAxlt1-f"

बाहर रखा और समझाया:

               # The idea here is to start with the input and reduce it quickly until it is
               # less than what we want, then increment it until it's just right
?              # Take input from stdin
d si st        # Duplicate input, store in `i' and in `t'
[              # Begin macro definition (when I write in dc, "macro"=="function")
 lt            # Load t, our test term
 2/            # Divide t by two
 d st          # Store a copy of this new term in `t'
 d*            # Duplicate and multiply (square)
 li<B          # Load i; if i<(t^2), execute B
] d sB x       # Duplicate, store function as `B', and execute
               # Loop ends when t^2 is less than i
[              # Begin macro definition
 lt            # Load t, our test term
 1+            # Increment
 d st          # Store a copy of this new term in `t'
 d*            # Duplicate and multiply (square)
 li!<A         # Load i; if i>=(t^2), execute A
] d sA x       # Duplicate, store function as `A', and execute
               # Loop ends when t^2 == i+1
lt 1- f        # Load t, decrement, and dump stack

Comments

उह, आखिरी टेस्ट केस क्रैश जैसा लग रहा है। मैं इसे ठीक करने की कोशिश करूंगा।

— जो

संकल्प लिया। अब बहुत बड़े इनपुट को स्वीकार करता है; गंभीर रूप से, इस फिक्स ने मुझे शुरुआत में कुछ बदसूरत कोड हटाने की अनुमति दी।

— जो

Answer 28

सी, 139 137 136 बाइट्स

कोड गोल्फ में मेरा पहला प्रयास है। ऐसा लगता है कि यह सी में सबसे छोटा है जो "कुशल" आवश्यकता को पूरा करता है, क्योंकि यह O(log n)समय में चलता है , केवल जोड़ और बिट शिफ्ट का उपयोग करके। हालांकि मुझे यकीन है कि यह अभी तक कम हो सकता है ...

बड़े पूर्णांक मानों के लिए भी यह ठीक काम करना चाहिए जब तक कि a=32भाग को बदल नहीं दिया जाता है a=NUMBITS/2।

typedef uint64_t x;x f(x o){x a=32,t=0,r=0,y=0,z;for(;a--+1;){z=(x)3<<2*a;y*=2;t++<r?y++,r-=t++:t--;t*=2;r*=4;r+=(o&z)>>2*a;}return y;}

Comments

अच्छा काम! मैंने इसे परीक्षण के लिए नहीं चलाया है, लेकिन कोड दिलचस्प लगता है। क्या आपके द्वारा असाइनमेंट में (t++)सिर्फ लिखने के बजाय एक कारण t++है r?

— टॉड लेहमन

@ToddLehman नहींं, बस उन लोगों को बाहर ले जाने से चूक गए। अच्छा पकड़ा!

— क्रिस

Btw, मैं प्यारa--+1 से बचने के लेखन के लिए एक रास्ता के रूप में a-- != UINT64_C(-1)। क्या आपने वह तरकीब कहीं सीखी या खुद ही उसका आविष्कार किया?

— टोड लेहमैन

@ToddLehman धन्यवाद! मुझे लगा कि मैं खुद बाहर हूं।

— क्रिस

Answer 29

सी - 50 (वैश्विक के बिना 61)

typedef uint64_t T;T n,i;f(){while(++i*i<=n);--i;}

यह अंतरिक्ष को बचाने के लिए पैरामीटर और वापसी मान के रूप में वैश्विक चर का उपयोग करता है।

कोई वैश्विक संस्करण नहीं:

typedef uint64_t T;T f(T n){T i=0;while(++i*i<=n);return--i;}

Comments

मुझे नहीं लगता कि वैश्विक चर का उपयोग करना कानूनी है। कम से कम यह बताएं कि यह कब तक वैध होगा और एक वैध संस्करण प्रदान करेगा

— गर्वित हैकेलर

@proud haskeller वैश्विक चर को निषिद्ध क्यों किया जाएगा?

— मंटाले

@mantal क्योंकि आपको एक रन करने योग्य प्रोग्राम / विधि प्रदान करनी चाहिए।

— मार्कियानो। एंडरेड

@ Marciano.Andrade कोड दिया गया है जो चल रहा है।

— मंतले

Answer 30

C ++ 125

int main()
{
uint64_t y;cin>>y;
double x=y/2,d,z;
while((d=(x*x-y))>0.5)
{
d<0?x+=0.5:x-=0.5;
}
cout<<(uint64_t)x;
}

Comments

अच्छा! कैसे के बारे में x+=(d<0)-0.5;... 5 और पात्रों को बचाता है?

— टॉड लेहमैन

BTW, यह एक समारोह के रूप में (लेकिन होना चाहिए) नहीं है, जैसा कि समस्या कथन में वर्णित है। (ठीक है, तकनीकी रूप से, हाँ, mainएक फ़ंक्शन है, लेकिन यह किसी प्रोग्राम के अंदर से कॉल करने योग्य नहीं है जैसे कि f(y)होगा।)

— टॉड लेहमन

मुझे लगता है कि आप कोष्ठक के अंतरतम जोड़ी को छोड़ सकते हैं और while((d=x*x-y)>0.5)इसके बजाय लिख सकते हैं while((d=(x*x-y))>0.5)। 2 और पात्रों को बचाता है। :)

— टॉड लेहमैन

हर 0.5 को .5 में बदला जा सकता है

— यति