एक फ़ंक्शन को लागू करें divide(int a, int b, int c)जो आधार 10 के मूल्य को प्रिंट करता है a/b। बिना किसी फ़्लोटिंग पॉइंट गणित और BigInteger/ BigDecimalया समकक्ष पुस्तकालयों का उपयोग किए बिना । नीचे बिंदु 4 में (संभव) अपवाद को छोड़कर, cसेट के भीतर कम से कम सटीक वर्ण 0123456789.मुद्रित होने चाहिए।

aऔर bकोई भी 32 बिट पूर्णांक हो सकता है। अपडेट: यदि, गोल्फिंग प्रयोजनों के लिए, आप चाहेंगे कि इनपुट 64 बिट प्राइमेटिव्स हो जो ठीक है, लेकिन आपको डेटा की पूरी 64 बिट रेंज का समर्थन करने की आवश्यकता नहीं है।
आपको यह जाँचने की आवश्यकता नहीं है कि cयह सकारात्मक है (हालाँकि उम्मीद है कि आपका कार्यक्रम दुर्घटनाग्रस्त न हो) यदि ऐसा नहीं है।
के लिए न्यूनतम समर्थित ऊपरी बाउंड cहै 500। यह ठीक है अगर आपका कार्यक्रम cउपरोक्त मूल्यों का समर्थन नहीं करता है 500, लेकिन यह भी ठीक है अगर यह करता है।
समान रूप से विभाजित होने वाली संख्याओं के लिए, यह आपकी पसंद है कि क्या अतिरिक्त शून्य प्रिंट करना है (मूल्य के आधार पर c) या कुछ भी नहीं।
आपको भागफल के साथ आगे के कार्यों को करने के लिए फ़ंक्शन का उपयोग करने में सक्षम होने की आवश्यकता नहीं है, एकमात्र लक्ष्य मुद्रण है।
के बीच संख्या के लिए -1और 1, यह आपकी पसंद है कि क्या एक प्रमुख प्रिंट करें 0। हालांकि, यह एकमात्र ऐसा परिदृश्य है जहां एक अग्रणी शून्य को प्रिंट करना स्वीकार्य है, और आप केवल एक ही शून्य को प्रिंट कर सकते हैं।
आप किसी भी गोलाई / मंजिल / छत के तर्क का उपयोग कर सकते हैं जिसे आप अंतिम दशमलव स्थान के लिए पसंद करते हैं।
नकारात्मक उत्तर के लिए, आपको एक अग्रणी प्रिंट करना होगा -। इस ओर ध्यान नहीं जाता है c। हालांकि, यह अपनी पसंद करता है, तो आप प्रिंट करना चाहते हैं , +या एक सकारात्मक जवाब के लिए कुछ भी नहीं है।
पूर्णांक विभाजन और पूर्णांक मापांक दोनों की अनुमति है। हालांकि, ध्यान रखें कि आप प्राइमरी तक ही सीमित हैं, जब तक कि आप अपनी खुद की BigInteger/ BigDecimalलाइब्रेरी को लागू करने का विकल्प नहीं चुनते हैं जो आपकी कोड लंबाई के खिलाफ गिना जाता है।
आप को संभालने के लिए की जरूरत नहीं है bकिया जा रहा है 0, हालांकि आप अगर आप चाहते हैं कर सकते हैं,। आपका कार्यक्रम एक अनंत लूप, या क्रैश में प्रवेश कर सकता है, यदि b=0, और आपको दंडित नहीं किया जाएगा।
प्रति टिप्पणी थोड़ा सा नियम परिवर्तन। यह सुनिश्चित करने के लिए कि खेल का मैदान स्तर है, जबकि aऔर b32 बिट पूर्णांक होने की गारंटी है, आप 64 बिट लंबे पूर्णांक का उपयोग कर सकते हैं। यदि आपकी चुनी हुई भाषा एक आदिम के रूप में 64 बिट पूर्णांक से आगे जाती है, तो आप किसी भी बिंदु पर उस कार्यक्षमता का उपयोग नहीं कर सकते हैं (दिखावा करें कि यह 64 बिट पर छाया हुआ है)।
एक और बिंदु जो अस्पष्ट है (इसे वर्तमान मान्य उत्तरों में से किसी को भी नहीं बदलना चाहिए): जबकि cव्याख्या की जा सकती है या तो मुद्रित वर्णों की संख्या या दशमलव के बाद रिक्त स्थान की संख्या, आपके कार्यक्रम को cप्रासंगिक तरीके से किसी भी तरह से उपयोग करना चाहिए। यह तय करने के लिए कि कितने वर्ण मुद्रित करने हैं। दूसरे शब्दों में, की divide(2,3,2)तुलना में बहुत कम उत्पादन होना चाहिए divide(2,3,500); 500 अक्षरों को छापना ठीक नहीं है c।
मैं वास्तव में फ़ंक्शन के नाम के बारे में परवाह नहीं करता हूं। dगोल्फ उद्देश्यों के लिए ठीक है।

इनपुट

फ़ंक्शन कॉल और रीडिंग दोनों stdinस्वीकार किए जाते हैं। यदि आप से पढ़ते हैं stdin, तो सेट में किसी भी चरित्र को [-0123456789]एक तर्क परिसीमन नहीं माना जाता है।

उत्पादन

stdoutऊपर वर्णित के रूप में वर्ण ।

उदाहरण

के लिए divide(2,3,5), निम्न में से सभी स्वीकार्य आउटपुट हैं:

0.666
0.667
.6666
.6667
 0.666
 0.667
 .6666
 .6667
+0.666
+0.667
+.6666
+.6667

एक अन्य उदाहरण: divide(371,3,5)निम्नलिखित के लिए सभी स्वीकार्य आउटपुट हैं:

और divide(371,-3,5)निम्नलिखित के लिए सभी स्वीकार्य हैं:

-123.6
-123.7
-123.66666
-123.66667

code-golf division

— durron597
स्रोत

एक स्तर के खेल के मैदान के लिए, यह एक विशिष्ट अधिकतम बिट लंबाई देने के लिए बुद्धिमान हो सकता है जिसका उपयोग किया जा सकता है (आदिम या अन्यथा) जब तक आप अपने स्वयं के बड़े कार्यान्वयन को रोल नहीं करते हैं, क्योंकि ए) कुछ भाषाओं में बिट की प्राथमिकताओं की लंबाई भिन्न होती है। कुछ भाषाओं में अंतर्निहित वास्तुकला और बी) बड़ी संख्या में आदिम हैं।

— जोनाथन वान मैट्रे

@JonathanVanMatre ने आपकी टिप्पणी के अनुसार नियम 11 को जोड़ा

— Durron597

1

आप सटीक अंक कैसे गिनेंगे ? आपके उदाहरण में मुझे तीन या चार दिखाई देते हैं लेकिन अंतिम तर्क बताता है कि पांच कभी नहीं।

— हावर्ड

@ हॉवर्ड, अगर आपने 92,3,5उत्तर दिया, उदाहरण के लिए,30.67

— डुर्रोन 597

1

btw 370/3 = 123.333 लोल

— izabera

5

जावा, 92/128

void d(long a,int b,int c){if(a<0^b<0){a=-a;p('-');}for(p(a/b+".");c>0;c--)p((a=a%b*10)/b);}<T>void p(T x){System.out.print(x);}

मुझे इतना सुधार करना पड़ा कि aया b-2147483648 हो सकता है क्योंकि सकारात्मक 32-बिट पूर्णांकों की गिनती केवल 2147483647 की ओर होती है, यही कारण है कि aए बन गया long। नकारात्मक परिणामों को संभालने का एक बेहतर तरीका हो सकता है, लेकिन मुझे पता है कि कोई नहीं ( doubleशायद यह काम करेगा abs(a) < abs(b)क्योंकि उनके पास काम करने के लिए -0केवल पूरक ही सटीक होगा)।

दो बाइट संख्या क्यों? मुझे गणना के लिए 92 बाइट्स की आवश्यकता थी और प्रिंट-हेल्पर के लिए 36 ( System.out.printबेकार, आमतौर पर जावा कि गोल्फ नहीं है)।

public class Div {

    void d(long a, int b, int c) {
        if (a < 0 ^ b < 0) {
            a = -a;
            p('-');
        }
        for (p(a / b + "."); c > 0; c--) {
            p((a = a % b * 10) / b);
        }
    }

    <T> void p(T x) {
        System.out.print(x);
    }

    public static void main(String[] args) {
        final Div div = new Div();
        div.d(12345, 234, 20);
        div.p('\n');
        div.d(-12345, 234, 20);
        div.p('\n');
        div.d(234, 234, 20);
        div.p('\n');
        div.d(-234, 234, 20);
        div.p('\n');
        div.d(234, 12345, 20);
        div.p('\n');
        div.d(234, -12345, 20);
        div.p('\n');
        div.d(-234, 12345, 20);
        div.p('\n');
        div.d(-234, -12345, 20);
        div.p('\n');
        div.d(-2147483648, 2147483647, 20);
        div.p('\n');
        div.d(2147483647, -2147483648, 20);
        div.p('\n');
    }
}

विधि मूल रूप से व्यायाम करती है जो हममें से अधिकांश ने स्कूल में अनुरोधित दशमलव अंकों को उत्पन्न करने के लिए सीखा है।

— TheConstructor
स्रोत

आधिकारिक निर्णय: मैं कहूंगा कि अनदेखी Integer.MIN_VALUEठीक नहीं है, लेकिन longजैसा कि इनपुट ठीक है।

— डुर्रोन 597

वह बहुत छोटा है। अच्छी तरह से किया।

— डुर्रोन 597

@ durron597 धन्यवाद। अभी भी सख्त टाइपिंग और System.outजावा को भारी लगता है;; फिर भी एक अच्छा अहसास है, कि पहले से ही लंबे जवाब पोस्ट किए गए हैं।

— TheConstructor

1

@ durron597 आपने विशेष रूप से एक समारोह के लिए कहा तो मैंने सोचा कि यह नहीं गिना जाएगा। अगर मुझे शायद हाँ की तुलना में आयात का उपयोग करना था।

— TheConstructor

1

कम से कम हर चर के लिए कोई $ नहीं है ;-)

— TheConstructor

9

C, 98 95 89

d(a,b,c){if(a>0^b>0)a=-a,printf("-");for(printf("%d.",a/b);c--;putchar(a/b+48))a=a%b*10;}

प्रिंट c अंक के बाद.

उदाहरण आउटपुट:

d(2,3,5);
0.66666

d(-2,3,5);
-0.66666

d(24352345,31412,500);
775.25611231376543995925124156373360499172290844263338851394371577740990704189481726728638736788488475741754743410161721635043932255189099707118298739335285878008404431427479943970457150133706863618999108620909206672609193938622182605373742518782630841716541449127721889723672481854068508850120972876607665860180822615560932127849229593785814338469374761237743537501591748376416656055010823888959633261174073602444925506175983700496625493441996689163377053355405577486310963962816757926906914554947153953

d(-77,12346463,500);
-0.00000623660395693892250760399962321192717298873369644407471192356871761572524859953818352673150196943043525906974329409159530142357369879940514137530724386409289850866600418273638369142644334656816288195250736992448768525852302801215214430238036593962173620088603513411087855687900251270343579371679160258286118056645048869461642577311412993340683886551152342172814999729072204727783171585254821563066280601982932277851559592411203111368818745903178910429650985873444078680671541315111866451144752954

-2147483647 <= a <= 2147483647 के लिए काम करना चाहिए, वही बी के लिए। संभालना- एक दर्द था।

ऑनलाइन संस्करण: ideone

— izabera
स्रोत

क्या यह कार्य -2147483648 है? पता नहीं है कि संकलक पर्याप्त रूप से यह बताने के लिए कि पूर्णांक-प्रकार आपके मापदंडों को सौंपा गया है।

— TheConstructor

इस पर ध्यान दिलाने के लिए धन्यवाद। यह -2147483647 <= a <= 2147483647 के लिए सही ढंग से काम करता है, बी के लिए भी ऐसा ही है। समस्या तब है जब a = -2147483648 और b सकारात्मक है a=-a।

— इजाबेरा

मैंने कोशिश की लेकिन आखिरकार आपको भी उतना ही समाधान मिल गया। आप उस printf("-")रिटर्न को साकार करके एक चरित्र को बचा सकते हैं

— थॉमस

4

PHP, 108

function d($a,$b,$c){$a*$b<0&&$a*=-print'-';for($p='.';$c--;$a.=0,print$i.$p,$p='')$a-=$b*$i=($a-$a%$b)/$b;}

यह केवल के लूप के दौरान a/ के भागफल को आउटपुट करके काम करता हैbc चरणों , aशेष प्रत्येक पुनरावृत्ति में 10 से गुणा होता है।

डेमो

— राज़्वान
स्रोत

जब कोई परिणाम b या ऋणात्मक हो तो अजीब परिणाम

— उत्पन्न करता है

मैंने बग को नकारात्मक संख्या के लिए निर्धारित किया है। धन्यवाद!

— रज़वान

बस अपने कोड का एक 112 संस्करण मिला: रिटर्न वैल्यूfunction d($a,$b,$c){if($a*$b<0)$a*=-print'-';for($p='.';$c--;$a*=10,$p=''){$a-=$b*$i=($a-$a%$b)/$b;echo$i.$p;}} देखें

— TheConstructor

धन्यवाद। मैंने आपका संस्करण भी अपडेट किया और अतिरिक्त 1 बाइट जीतने में कामयाब रहा।

— रजवन ६

2

अजगर 111

f=lambda a,b,c:'-'[a*b>=0:]+'%s'%reduce(lambda(d,r),c:(d%c*10,r+`d/c`+'.'[r!='':],),[abs(b)]*c,(abs(a),''))[-1]

यह समाधान बताए गए किसी भी नियम का उल्लंघन नहीं करता है।

— अभिजीत
स्रोत

2

C: 72 वर्ण

d(a,b,c){for(printf("%d.",a/b);c--;putchar((a=abs(a)%b*10)/abs(b)+48));}

यह लगभग पूरी तरह से वही करता है जो इसे करना चाहिए था। हालाँकि, यह कुछ अन्य उत्तरों के रूप में होगा, जो कि रुचिकर मूल्य देते हैं या असफल होते हैंd(-2147483648,b,c) और d(a,-2147483648,c)चूंकि -2147483648 का निरपेक्ष मूल्य 32-बिट शब्द के लिए सीमा से बाहर है।

— Fors
स्रोत

2

पर्ल, कोई अंकगणित, 274 बाइट्स

यह यूक्लिडियन लंबा विभाजन है, स्मृति की असामान्य मात्रा का उपभोग करने की संभावना है। फ़्लोटिंग-पॉइंट नंबरों पर गणित के लिए निकटतम यह उन्हें पार्स करने के लिए बिट संचालन का उपयोग करने में है।

sub di{($v,$i,$d,$e)=(0,@_);($s,$c,$j)=$i=~s/-//g;$s^=$d=~s/-//g;
$i=~s/\.(\d+)/$j=$1,""/e;$d=~s/\.(\d+)/$c=$1,""/e;
$z=0.x+length($c|$j);$i.=$j|$z;$d.=$c|$z;
($e,$m,$z,$t)=(1.x$e,0.x$i,0.x$d,"-"x($s&1));
for(;$e;$t.="."x!$v,$v=chop$e){$t.=$m=~s/$z//g||0;$m="$m"x10}
print"$t\n"}

उदाहरण:

di(-355,113,238);
di(1.13,355,239);
di(27942,19175,239);
di(1,-90.09,238);
di("--10.0","----9.801",239);
di(".01",".200",239);

आउटपुट:

-3.141592920353982300884955752212389380530973451327433628318
584070796460176991150442477876106194690265486725663716814159
292035398230088495575221238938053097345132743362831858407079
646017699115044247787610619469026548672566371681415929203539

0.0031830985915492957746478873239436619718309859154929577464
788732394366197183098591549295774647887323943661971830985915
492957746478873239436619718309859154929577464788732394366197
183098591549295774647887323943661971830985915492957746478873

1.4572099087353324641460234680573663624511082138200782268578
878748370273794002607561929595827900912646675358539765319426
336375488917861799217731421121251629726205997392438070404172
099087353324641460234680573663624511082138200782268578878748

-0.011100011100011100011100011100011100011100011100011100011
100011100011100011100011100011100011100011100011100011100011
100011100011100011100011100011100011100011100011100011100011
100011100011100011100011100011100011100011100011100011100011

1.0203040506070809101112131415161718192021222324252627282930
313233343536373839404142434445464748495051525354555657585960
616263646566676869707172737475767778798081828384858687888990
919293949596979900010203040506070809101112131415161718192021

0.0500000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000

— user130144
स्रोत

1

रूबी, १,

def d(a,b,c)
    n=(a<0)^(b<0)
    a=-a if n
    m=a/b-b/a
    l=m.to_s.size-1
    g=(a*10**(10+c)/b).to_s
    f=m<0?"."+"0"*(l-1)+g[0..c-l-1] : g[0..l]+"."+g[l+1..c-2]
    p n ? "-"+f : f
end

परीक्षण के लिए ऑनलाइन संस्करण ।

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

— डेविड हेरमैन
स्रोत

क्या यह 350 से अधिक के लिए काम करता है?

— डुर्रोन 597

मैंने इसे सी = 1000 के साथ परीक्षण किया - कोड ने मुझे एक उत्तर दिया, शायद मुझे वास्तविक परिणाम की जांच करनी चाहिए ...

— डेविड हेरमन

2

करता है gबड़े के लिए 64 बिट्स से परे मिल c? संपादित करें: मुझे लगता है कि आप यहां स्पष्ट रूप से उपयोग कर रहे BigIntegerहैं

— डुर्रोन 597

Err, gएक स्ट्रिंग है, लेकिन कॉल करने से पहले आपने to_sमेमोरी में एक नंबर बनाया है जो आकार में 64 बिट्स से परे है

— Durron597

1

यह समझ में आता है - और कार्य को अधिक चुनौतीपूर्ण (और दिलचस्प) बनाता है! उत्तर को हटाना या दूसरों के लिए इसे छोड़ना बेहतर है कि इसका उदाहरण है कि कार्य को कैसे लागू नहीं किया जाए?

— डेविड हेरमैन

1

अजगर 92 बाइट्स:

def d(a,b,c):c-=len(str(a/b))+1;e=10**c;a*=e;a/=b;a=str(a);x=len(a)-c;return a[:x]+'.'+a[x:]

मुझे लगता है कि कुछ और गोल्फ संभव है .....

— Maltysen
स्रोत

2

है eबड़ा ग के लिए 64 बिट्स से परे है? संपादित करें: मुझे लगता है कि आप स्पष्ट रूप से BigIntegerयहाँ का उपयोग कर रहे हैं।

— डुर्रोन 597

1

@ durron597 मुझे अत्यधिक संदेह है कि। यह बिगआईंट (लंबे समय तक अजगर में) जाता है लेकिन 2 ** 45 बिट्स है। क्या यह पर्याप्त संकेत है ?? इसके अलावा, अजगर के पास कोई आदिम नहीं है ...

— माल्टीसेन

यदि a=5और c=400उसके बाद e=10**c, हेक्स में, संख्या 333 अंक लंबी है। यह शुरू होता है 8889e7dd7f43fc2f7900bc2eac756d1c4927a5b8e56bbcfc97d39bac6936e648180f47d1396bc905a47cc481617c7...यह 64 से अधिक बिट्स है।

— डुर्रोन

@ ड्यूर्रोन 597 400 ... क्या मुझे इसकी आवश्यकता है

— माल्टीसेन

1

हाँ नियम 3 कहता है कि आपको कम से कम 500 तक का समर्थन करने की आवश्यकता है ... मैं इसे (imo तुच्छ) समाधान को रोकने की कोशिश कर रहा था।

— डुर्रोन 597

1

सी 83

d(a,b,c){printf("%d.",a/b);for(a=abs(a),b=abs(b);c--&&(a=a%b*10);)putchar(a/b+48);}

वही आइडिया जो मैंने अपने पायथन कार्यान्वयन में इस्तेमाल किया

— अभिजीत
स्रोत

बहुत अच्छा! हालाँकि, यह क्रैश हो जाता हैd(-2147483648,-1,10)

— Durron597

मनमाना सटीक विभाजन लागू करें

इनपुट

उत्पादन

उदाहरण

जावा, 92/128

C, 98 95 89

PHP, 108

अजगर 111

C: 72 वर्ण

पर्ल, कोई अंकगणित, 274 बाइट्स

रूबी, १,

अजगर 92 बाइट्स:

सी 83