एक प्रोग्राम या समारोह है कि धनात्मक पूर्णांक में लेता लिखें a, bऔर c, और प्रिंट या रिटर्न a/bके लिए cदशमलव स्थानों, संचालन का उपयोग कर + - धनात्मक पूर्णांक पर * /% [एड, घटाने, गुणा, विभाजन, न्यूनाधिक]: आप सभी का उपयोग कर सकते है कि आपकी भाषा अनुमति देती है, लेकिन फ्लोटिंग पॉइंट नंबरों पर नहीं। आपकी भाषा में अहस्ताक्षरित पूर्णांकों के लिए अनुमत श्रेणी, a, b, c की सीमा होगी। संख्या परिणाम को अंतिम अंक में मुद्रित करने के लिए छोटा किया जाएगा (इसलिए नहीं round)।

इसका मतलब यह है कि यदि आपकी भाषा में पूर्णांक प्रकार (केवल फ्लोट) नहीं है, तो आप इन फ्लोट संख्याओं का उपयोग केवल सकारात्मक पूर्णांक के रूप में कर सकते हैं। इस अभ्यास का सुराग यह होगा कि फ़ंक्शन को एक फ्लोट पॉइंट डिवीजन में अंकों का पता लगाएं, केवल [+ अहस्ताक्षरित] पूर्णांक पर ऑपरेशन + - /% का उपयोग करते हुए।

उदाहरण

print(1,2,1) छपता था 0.5
print(1,2,2) छपता था 0.50
print(13,7,27) छपता था 1.857142857142857142857142857
print(2,3,1) छपता था 0.6
print(4,5,7) छपता था 0.8000000
print(4,5,1) छपता था 0.8
print(9999,23,1) छपता था 434.7
print(12345613,2321,89) यदि आपकी भाषा में 32 बिट अहस्ताक्षरित है तो प्रिंट होगा 5319.09220163722533390779836277466609220163722533390779836277466609220163722533390779836277466

बाइट्स में सबसे छोटा कोड जीतता है। मुझे क्षमा करें यदि यह स्पष्ट नहीं दिखाई देता है ... मुझे भाषाएं भी नहीं आती हैं, शब्दों को अच्छी तरह से याद नहीं है ... Ideone.com या किसी अन्य स्थान के लिए एक लिंक होना बेहतर है आसानी से उत्तर के लिए विशेष रूप से प्रयास करें प्रस्तावित से अलग कुछ इनपुट का परीक्षण करें।

— RosLuP
स्रोत

1

पूर्णांकों की सीमा क्या है a, b, c?

— टन हास्पेल

@Ton Hharma की रेंज a, b, c होगी, जो आपकी भाषा में अहस्ताक्षरित पूर्णांक के लिए सीमा होगी: उदाहरण के लिए यदि यह 32 बिट का है तो यह 0..0xFFFFFFFF होगा, लेकिन यदि c> = 0xFFFFFFF इतना बड़ा आउटपुट होगा थोड़ा धीमा हो ...

— RosLuP

2

यह एक राउंडिंग फ़ंक्शन है - या, अधिक सटीक रूप से, इसे ठीक से निर्दिष्ट करने के लिए एक राउंडिंग फ़ंक्शन होना चाहिए। वर्तमान में, यह स्पष्ट नहीं है कि उदाहरण के लिए सही उत्तर क्या होगा (1,2,0)। Meta.codegolf.stackexchange.com/a/5608/194

— पीटर टेलर

1

इस प्रश्न को फिर से खोलने के लिए क्षमा करें; मुझे लगता है कि पीटर टेलर ने बताया कि समस्या को छोड़कर, इसे फिर से खोलने के लिए लगभग तैयार है। आउटपुट के लिए क्या है (1,2,0)?

— ETHproductions

2

वास्तव में (1,2,0)अप्रासंगिक होना चाहिए क्योंकि 0एक सकारात्मक पूर्णांक नहीं है। और मैं इसे पसंद करता हूँ अगर ग उस तरह से रहता है, क्योंकि मैं पसंद करूँगा कि मुझे इस बारे में सोचना .नहीं है या नहीं

— अप्लाई

5

05AB1E , 17 13 11 19 14 बाइट्स

के रूप में इनपुट b, a, c।
5 बाइट्स ग्रिम के लिए धन्यवाद बचा लिया ।

‰`¹+I°*¹÷¦'.sJ

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

— Emigna
स्रोत

मैंने इसे इनपुट 13,7,27 के साथ ऑनलाइन करने की कोशिश की और उत्तर सही नहीं है

— मैथ्यू जे।

@ शशिगुरु: यह परीक्षण-मामलों के समान परिणाम देता है । क्या आपने देखा कि इनपुट्स का क्रम क्या है b,a,c?

— एमिग्ना

मैं "ऑनलाइन प्रयास करें" बटन का प्रयास करता हूं, जहां यह विभाजन है: 89 अंकों के साथ 12345613/2321, लेकिन परिणाम 5319.922 के रूप में कुछ है ... 5319.0922 के बजाय ...

— RosLuP

1

15:‰`I°*¹÷I°+¦'.sJ

— ग्रैमी

2

14:‰`¹+I°*¹÷¦'.sJ

— ग्रिमी

4

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

(a#b)c|s<-show$div(a*10^c)b,l<-length s-c,(h,t)<-splitAt l s=['0'|l<1]++h++['.'|c>0]++t

उपयोग उदाहरण: (13#7)27 -> "1.857142857142857142857142857"।

23 बाइट्स को संभालने के लिए c==0मामले और जैसे चीजों के बजाय एक अग्रणी शून्य का उपयोग करना .5।

यह कैसे काम करता है: इसके aसाथ गुणा करें 10^c, विभाजित करें b, एक स्ट्रिंग में बदल दें, विभाजित करें जहां .सम्मिलित होना चाहिए, दोनों भागों को एक .-के साथ जोड़ दें और किनारे के मामलों को ठीक करें।

— nimi
स्रोत

4

पर्ल 6 , 58 57 55 48 बाइट्स

{(($^a.FatRat/$^b*10**$^c).Int.FatRat/10**$c).base(10,$c)}

{(Int($^a.FatRat/$^b*10**$^c).FatRat/10**$c).base(10,$c)}

{base Int($^a.FatRat/$^b*10**$^c).FatRat/10**$c: 10,$c}

{base ($^a*10**$^c div$^b).FatRat/10**$c: 10,$c}

काफी परेशान करने वाली बात यह है कि इसे केवल {($^a.FatRat/$^b).base(10,$^c)}तभी छोटा किया जा सकता है जब इसे निकटतम मूल्य पर गोल करने की अनुमति दी गई हो।

स्पष्टीकरण:

# bare block lambda with 3 placeholder parameters ｢$^a｣, ｢$^b｣ and ｢$^c｣
{
  (
    (

      # create an Int containing all of the digits we care about
      $^a * 10 ** $^c div $^b

    ).FatRat / 10**$c  # turn it into a Rational

  ).base( 10, $c )     # force it to display ｢$c｣ digits after the decimal point
}

— ब्रैड गिल्बर्ट b2gills
स्रोत

मैं perl6 से परिचित नहीं हूं, लेकिन (...).FatRat / 10**$xएक तर्कसंगत का विभाजन नहीं है? आपको केवल पूर्णांकों को विभाजित करने की अनुमति है।

— nimi

@nimi a Rational एक ऐसा वर्ग है जिसमें दो Ints होते हैं ।

— ब्रैड गिल्बर्ट b2gills

गणित ऑपरेटरों को केवल पूर्णांक प्रकारों के लिए अनुमति दी जाती है और अन्य संख्यात्मक प्रकारों के लिए नहीं। उद्धरण: "इस अभ्यास का सुराग ... फ़ंक्शन लिखने के लिए ... केवल [अहस्ताक्षरित] अजनबियों पर ऑपरेशन + - * /% का उपयोग करते हुए।"

— nimi

@nimi तो अगर मैंने तर्कसंगत के पुन: कार्यान्वयन को लिखा है, और इसे जोड़ा नहीं गया है does Realया does Numericइसकी अनुमति दी जाएगी? क्या होगा अगर मैं उन भूमिकाओं को हटाने के लिए मौजूदा वर्ग (बंदर पैच) को बढ़ा दूं, तो क्या इसकी अनुमति होगी?

— ब्रैड गिल्बर्ट b2gills

पता नहीं। मैंने पहले जैसा कहा गया था कल्पना पढ़ी: +-*/%केवल सादे पूर्णांक प्रकारों के साथ। कार्यक्षमता के संदर्भ में "सादे पूर्णांक" (सबसे पहले: पूर्णांक विभाजन) आंतरिक प्रतिनिधित्व का नहीं। क्या आपको लगता है कि यह एक सॉफ्टवेयर फ़्लोटिंग पॉइंट लाइब्रेरी का उपयोग करने की अनुमति है, जो (नाम के बावजूद) आंतरिक प्रतिनिधित्व के लिए केवल पूर्णांक का उपयोग करता है?

— नीम

3

पर्ल, 55 बाइट्स

के लिए +3 शामिल है -p

STDIN पर एक लाइन पर a और b दें, अगले पर c

division.pl
1 26
38
^D

division.pl:

#!/usr/bin/perl -p
eval'$\.=($_/$&|0)."."x!$\;$_=$_%$&.0;'x(/ .*/+<>)}{

$_/$&थोड़ा विवादास्पद है। मैं वास्तव में वहां एक पूर्णांक विभाजन चाहता हूं, लेकिन पर्ल के पास विशेष मॉड्यूल लोड किए बिना नहीं है। तो यह अस्थायी रूप से एक गैर-पूर्णांक है जिसे मैं तुरंत काट (उपयोग |0) करता हूं, इसलिए मैं पूर्णांक के साथ एक पूर्णांक विभाजन देता हूं। इसे फिर से लिखा जा सकता है क्योंकि ($_-$_%$&)/$&अस्थायी रूप से एक गैर-पूर्णांक मान नहीं है (यह आंतरिक रूप से अभी भी एक अस्थायी आधार होगा)

— टन हास्पेल
स्रोत

क्या आप $-इसे केवल int बनाने के लिए उपयोग कर सकते हैं ? (मुझे लगता है कि इसके मिश्रण / अधिकतम पर सख्त सीमाएं हैं, और मुझे यकीन है कि आप पहले से ही इस पर विचार कर चुके होंगे, लेकिन हालांकि यह जाँच के लायक है!)

— डोम हेस्टिंग्स

@DomHastings यह फ़्लोटिंग पॉइंट डिवीज़न करने के बाद भी एक छोटा होगा। पर्ल के पास बिना पूर्णांक विभाजन नहीं हैuse integer

— टन हास्पेल

आह, तो यह बस के साथ नकाबपोश है $-, पता करने के लिए अच्छा है। धन्यवाद!

— डोम हेस्टिंग्स

3

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

f=(a,b,c,d=".")=>~c?(a/b|0)+d+f(a%b*10,b,c-1,""):d

(a/b|0)फ्लोट डिवीजन करता है, लेकिन तुरंत एक पूर्णांक में डाल देता है। कृपया मुझे बताएं कि क्या इसकी अनुमति नहीं है।

— ETHproductions
स्रोत

3

PHP, 187 बाइट्स

अंश के लिए तार के साथ काम करता है जो तब अधिक से अधिक अंतर मान हो सकता है PHP_INT_MAX

list(,$n,$d,$c)=$argv;$a=str_split($n);while($a){$n.=array_shift($a);if($n>=$d||$r)$n-=$d*$r[]=$n/$d^0;}if(!$r)$r[]=0;if($c)$r[]=".";while($c--){$n*=10;$n-=$d*$r[]=$n/$d^0;}echo join($r);

मेरे पास कोई और मौका नहीं है तो १३/ is को १.14५2१४२ then५ then१ and२ ९ को छोटा कर दिया गया है और मैं २ chance० स्थानों पर परीक्षण के मामले में नहीं पहुँचा हूँ

इस तरह 36 बाइट्स की अनुमति नहीं है

<?=bcdiv(($z=$argv)[1],$z[2],$z[3]);

— जार्ग हुल्सरमन
स्रोत

फ्लोट डिवीजन को ओपी के अनुसार अनुमति नहीं है

— माल्टीसेन

@ मैल्टीसेन माफ करें मैं एक रोलबैक करता हूं। मैं एक छोटा समाधान खोजने से इतना डरता था कि मैं इसे पहचान नहीं पाया कि यह सब कुछ है।

— जोर्ग हल्सरमन

2

पायथ - 21 19 18 16 14 बाइट्स

इनपुट प्रारूप की तलाश में होगा, जो एक गुच्छा को बचा सकता है।

j\.c`/*E^TQE]_

टेस्ट सूट । (पीएस 27 एक ऑनलाइन खत्म नहीं करता है, इसलिए मैंने इसके बजाय 10 किया)।

— Maltysen
स्रोत

@Emigna न ही इसका मतलब है कि यह 0एक सकारात्मक पूर्णांक नहीं है (भले ही ऑप इसके साथ उदाहरण जोड़ता रहता है c=0)

— टन हास्पेल

@ टोनहोस: आह, वास्तव में। मैं उदाहरणों को देख रहा था। मैं अपना जवाब छोटा कर सकता हूं :)

— एमिग्ना

दशमलव बिंदु के बाद एक अग्रणी 0 वाले अंकों के साथ काम नहीं करता है, उदाहरण के लिए 2/21 से 10 दशमलव तक।

— 21

— 10/2

0.09 के बजाय 10 अंकों के साथ 2/21 कहते हैं ... प्रिंट 0.9 ...

— RosLuP

2

जावास्क्रिप्ट (ईएस 6), 64 62 59 बाइट्स

बच निकले 2 बाइट्स ETHproductions की बदौलत।

शामिल विभाजन हमेशा पूर्णांक में परिणाम करता है।

f=(a,b,n,s)=>~n?f((q=(a-a%b)/b,a%b*10),b,n-1,s?s+q:q+'.'):s

console.log(f(13,7,27))

स्निपेट का विस्तार करें

— Arnauld
स्रोत

mपूरी तरह से अभी भी काम लंघन होगा ? f=(a,b,n,s)=>n+1?f((q=(a-a%b)/b,a%b*10),b,n-1,s?s+q:q+'.'):s60 बाइट्स है।

— ETHproductions

@ETHproductions - वास्तव में। धन्यवाद!

— अरनौलड

2

जावा 7, 105 बाइट्स

import java.math.*;String c(int...a){return new BigDecimal(a[0]).divide(new BigDecimal(a[1]),a[2],3)+"";}

Ungolfed और परीक्षण कोड:

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

import java.math.*;
class M{
  static String c(int... a){
    return new BigDecimal(a[0]).divide(new BigDecimal(a[1]), a[2], 3)+"";
  }

  public static void main(String[] a){
    System.out.println(c(1, 2, 1));
    System.out.println(c(1, 2, 2));
    System.out.println(c(13, 7, 27));
    System.out.println(c(2, 3, 1));
    System.out.println(c(4, 5, 7));
    System.out.println(c(4, 5, 0));
    System.out.println(c(9999, 23, 0));
    System.out.println(c(12345613, 2321, 89));
  }
}

आउटपुट:

0.5
0.50
1.857142857142857142857142857
0.6
0.8000000
0
434
5319.09220163722533390779836277466609220163722533390779836277466609220163722533390779836277466

— केविन क्रूज़सेन
स्रोत

मुझे नहीं लगता कि यह मान्य है, क्योंकि यह अनिवार्य रूप से फ्लोटिंग-पॉइंट डिवीजन है, भले ही इसे कहा जाता है divideऔर नहीं /।

— corvus_192

@ corvus_192 मेरे द्वारा बाद में पोस्ट किए गए एक और हटाए गए जावा उत्तर को तर्क दिया गया था, जिसे मैं यहां कॉपी-पेस्ट करूंगा (इस स्पष्टीकरण का श्रेय @S डेमोक्रेटिक फेनिक्स को जाता है ): " यह कैसे काम करता है: जावा intint[]बिगडिमिमल्स को बिगइन्टेगर के पैमाने के साथ लागू किया जाता है। यह तकनीकी रूप से फ़्लोटिंग पॉइंट है, हालाँकि BigInteger और BigDecimal ऑब्जेक्ट्स संख्यात्मक मान को स्टोर करने के लिए केवल प्रकार का उपयोग करते हैं । (यह अच्छा नहीं है? BigInteger अंकों का एक है। जैसे, आधार 10 में {1,2,5} 125 है। I मुझे यकीन नहीं है कि

— बिगइन्टेगर

2

रूबी, 67 बाइट्स

->(a,b,c){('0'+(a*10**c/b).to_s).gsub(/^0*(.+)(.{#{c}})$/,'\1.\2')}

अगर मैं इसे ऊपर दिए गए परीक्षण मामलों को निष्पादित करने के लिए एक फ़ंक्शन बनाता हूं

def print(a,b,c); ('0'+(a*10**c/b).to_s).gsub(/^0*(.+)(.{#{c}})$/, '\1.\2'); end
 => :print 
print(1,2,1)   # would print 0.5
 => "0.5" 
print(1,2,2)   # would print 0.50
 => "0.50" 
print(13,7,27) # would print 1.857142857142857142857142857
 => "1.857142857142857142857142857" 
print(2,3,1)   # would print 0.6
 => "0.6" 
print(4,5,7)   # would print 0.8000000
 => "0.8000000" 
print(4,5,1)   # would print 0.8
 => "0.8" 
print(9999,23,1) # would print 434.7
 => "434.7" 
print(12345613,2321,89) # would print if your Language has 32 bit unsigned 5319.09220163722533390779836277466609220163722533390779836277466609220163722533390779836277466
 => "5319.09220163722533390779836277466609220163722533390779836277466609220163722533390779836277466" 
"('0'+(a*10**c/b).to_s).gsub(/^0*(.+)(.{#{c}})$/, '\1.\2')".length
 => 52

— मथिउ जे।
स्रोत

गोल्फ में आपका स्वागत है! अधिकांश भाषाओं के लिए, जब आप किसी फ़ंक्शन को परिभाषित करते हैं, तो आपको इसे सभी तरह से परिभाषित करना होगा, और आप यह मानने पर भरोसा नहीं कर सकते कि इस तरह पूर्वनिर्धारित चर हैं। रूबी में, लंबोदर को परिभाषित करने का सबसे छोटा तरीका वह है ->a,b,c{...}जहां आप अपने कोड के साथ दीर्घवृत्त की जगह लेते हैं। (वैरिएबल का वास्तविक असाइनमेंट सर्वसम्मति से अनावश्यक है।)

— वैल्यू इंक

धन्यवाद, मैं गलत धारणा के तहत था कि दूसरों ने उस हिस्से को छोड़ दिया था ... लेकिन आप सही हैं। मैंने अभी इसे जोड़ा है।

— मैथ्यू जे।

2

रैकेट 203 बाइट्स

(let*((s(~r(/ a b)#:precision c))(sl(string-split s "."))(s2(list-ref sl 1))(n(string-length s2)))
(if(< n c)(begin(for((i(- c n)))(set! s2(string-append s2 "0")))(string-append(list-ref sl 0)"."s2))s))

Ungolfed:

(define (f a b c)
  (let* ((s (~r(/ a b)#:precision c))
         (sl (string-split s "."))
         (s2 (list-ref sl 1))
         (n (string-length s2)))
    (if (< n c)
        (begin 
          (for ((i (- c n)))
            (set! s2 (string-append s2 "0")))
          (string-append (list-ref sl 0) "." s2))
        s )))

उपयोग:

(f 7 5 3)
(f 1 2 1) 
(f 1 2 2) 
(f 13 7 27)

आउटपुट:

"1.400"
"0.5"
"0.50"
"1.857142857142857142857142857"

अन्य विधि (यहाँ मान्य उत्तर नहीं):

(real->decimal-string(/ a b)c)

— rnso
स्रोत

मुझे डर है कि यह अमान्य है, क्योंकि इसके पहले तर्क के रूप में real->decimal-stringएक realमूल्य की उम्मीद है , इसलिए /फ्लोटिंग पॉइंट डिवीजन है, जिसे इस कार्य में अनुमति नहीं है। इसके अलावा: काट-छाँट के बजाय real->decimal-string( (f 1 6 7)-> 0.1666667) गोल ।

— निमि

टिप्पणियों के लिए धन्यवाद। मैं जल्द ही कोड सही कर दूंगा।

— rnso

1

क्यू, 196 बाइट्स

w:{((x 0)div 10;1+x 1)}/[{0<x 0};(a;0)]1;{s:x 0;m:x 2;r:(10*x 1)+$[m<0;{x*10}/[-1*m;a];{x div 10}/[m;a]]mod 10;d:1#.Q.s r div b;($[m=-1;s,".",d;$[s~,:'["0"];d;s,d]];r mod b;m-1)}/[c+w;("";0;w-1)]0

चलाने के लिए: ए, बी, सी पहले सेट करें।

— बोस्टन वाकर
स्रोत

1

जंग, 114 बाइट्स

fn print(mut a:u32,b:u32,c:u32){let mut p=||{print!("{}",a/b);a=a%b*10};p();if c>0{print!(".")}for _ in 0..c{p()}}

परीक्षण कोड:

fn main() {
    print(1, 2, 1);    println!(""); // should print 0.5
    print(1, 2, 2);    println!(""); // should print 0.50
    print(13, 7, 27);  println!(""); // should print 1.857142857142857142857142857
    print(2, 3, 1);    println!(""); // should print 0.6
    print(4, 5, 7);    println!(""); // should print 0.8000000
    print(4, 5, 0);    println!(""); // should print 0
    print(9999, 23, 0);println!(""); // should print 434
    print(12345613,2321,89); println!("\n");  // 5319.09220163722533390779836277466609220163722533390779836277466609220163722533390779836277466
}

— क्रिस्टोफर फिलिप्स
स्रोत

1

PHP, 89 बाइट्स

list(,$a,$b,$c)=$argv;for($o=intdiv($a,$b).'.';$c--;)$o.=intdiv($a=10*($a%$b),$b);echo$o;

intdiv () को php 7 में पेश किया गया है ताकि इसकी आवश्यकता हो। php 7.1 मुझे सूची () को [] में बदलने की अनुमति देगा और इसलिए 4 बाइट्स को बचाएगा।

जैसे उपयोग करें:

php -r "list(,$a,$b,$c)=$argv;for($o=intdiv($a,$b).'.';$c--;)$o.=intdiv($a=10*($a%$b),$b);echo$o;" 1 2 1

— user59178
स्रोत

के $o.=intdiv($a=10*($a%$b),$b);साथ बदलें $o.=($a=10*($a%$b))/$b^0;4 बाइट्स बचाएगा।

— जार्ग हुल्सरमैन

प्रारंभ में मैं वह सलाह लेने जा रहा था (मैंने उत्तर और सब कुछ संपादित किया), लेकिन दूसरे विचार में यह फ्लोटिंग पॉइंट डिवीजन है और फिर <10% वृद्धि के लिए int करने के लिए एक कास्ट मैं लंबाई में पूरी तरह से छड़ी करता हूं बल्कि चश्मा प्रश्न।

— user59178 16

1

सी #, 126 बाइट्स

(a,b,c)=>{var v=a*BigInteger.Parse("1"+new string('0',c))/b+"";return v.PadLeft(c+1,'0').Insert(Math.Max(1,v.Length-c),".");};

परीक्षण मामलों के साथ पूरा कार्यक्रम:

using System;
using System.Numerics;

namespace DivisionOfNotSoLittleNumbers
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<BigInteger,BigInteger,int,string>f= (a,b,c)=>{var v=a*BigInteger.Parse("1"+new string('0',c))/b+"";return v.PadLeft(c+1,'0').Insert(Math.Max(1,v.Length-c),".");};

            //test cases:
            Console.WriteLine(f(1,2,1));    //0.5
            Console.WriteLine(f(1,2,2));    //0.50
            Console.WriteLine(f(13,7,27));  //1.857142857142857142857142857
            Console.WriteLine(f(2,3,1));    //0.6
            Console.WriteLine(f(4,5,7));    //0.8000000
            Console.WriteLine(f(4,5,1));    //0.8
            Console.WriteLine(f(9999,23,1));    //434.7
            Console.WriteLine(f(12345613,2321,89)); //5319.09220163722533390779836277466609220163722533390779836277466609220163722533390779836277466
            Console.WriteLine(f(2,3,1));    //0.6
            Console.WriteLine(f(4,5,2));    //0.80
        }
    }
}

पूर्णांक विभाजन लागू किया गया है। BigIntegerडेटा प्रकार (आयात System.Numericsकी आवश्यकता है) के कारण किसी भी आकार की संख्या का उपयोग किया जा सकता है । अंक-गणना पैरामीटर c2 ^ 31-1 तक सीमित है, हालांकि इसे पर्याप्त अंकों से अधिक प्रदान करना चाहिए।

— adrianmp
स्रोत

1

ग्रूवी ( 78 77 42 बाइट्स)

{a,b,n->Eval.me(a+'.0g').divide(b, n, 1)}

व्याख्या

Eval.me(a+'.0g');- पूर्णांक इनपुट से BigDecimal इनपुट में कनवर्ट करें। ग्रूवी में बिगडेसिमल संकेतन एक जोड़ा जी या जी के साथ डबल अंकन है। मैं कंस्ट्रक्टर का भी इस्तेमाल कर सकता था new BigDecimal(it)लेकिन इसने एक बाइट को बचा लिया।
.divide(b, n, 1)- n परिशुद्धता, गोलाई मोड हाफ-अप के साथ बी से विभाजित करें।

इसे यहाँ आज़माएँ: https://groovyconsole.appspot.com/script/5177545091710976

— जादू ऑक्टोपस Urn
स्रोत

लेकिन BigDecimal फ्लोटिंग पॉइंट ऑपरेशन का समर्थन करता है, जब तक कि मैं गलत नहीं हूँ, मेरा मानना है कि इस अभ्यास के लिए मना किया गया था।

— मैथ्यू जे।

1

बैच, 122 बाइट्स

@set/as=%1/%2,r=%1%%%2
@set s=%s%.
@for /l %%a in (1,1,%3)do @set/ad=r*10/%2,r=r*10%%%2&call set s=%%s%%%%d%%
@echo %s%

— नील
स्रोत

1

गणितज्ञ, 50 बाइट्स

StringInsert[ToString@Floor[10^# #2/#3],".",-#-1]&

तीन तर्कों (जो आदेश दिया जाता है की अनाम समारोह c, a, bएक बाइट कहीं बचाने के लिए) है, जो एक स्ट्रिंग देता है। यह गुणा करता a/bहै 10^c, सबसे बड़ा पूर्णांक फ़ंक्शन लेता है, फिर एक स्ट्रिंग में कनवर्ट करता है और उपयुक्त स्थान पर एक दशमलव बिंदु सम्मिलित करता है। बहुत खराब फ़ंक्शन नाम कम नहीं हैं।

— ग्रेग मार्टिन
स्रोत

1

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

a,b,c=map(int,input().split());print("{:.{1}f}".format(a/b,c))

यह यहाँ की कोशिश करो

* नोट : repl.it की ver एक पुराने का उपयोग करता अजगर 3 है, जो सभी क्षेत्र के सूचकांक निर्दिष्ट करना आवश्यक है, जिसका अर्थ है "{:.{1}f}"किया जाएगा "{0:.{1}f}"इसके बजाय, यह कर रही है 63 बाइट्स प्रतिकृति में बन जाएंगे।

कैसे इस्तेमाल करे

बीच में रिक्त स्थान के साथ सभी तीन मान दर्ज करें। यानी का इनपुट1 2 1 परिणाम देगा0.5

व्याख्या

input().split(): उपयोगकर्ता इनपुट प्राप्त करता है और इसे (अंतरिक्ष) के विभाजक के साथ एक सूची में विभाजित करता है

a,b,c = map(int,XX): एक अंतर प्रकार के साथ उपयोगकर्ता द्वारा निर्दिष्ट मूल्यों में चर को मैप करता है

"{:.{1}f}".format(a/b,c): विभाजन परिणाम प्रदर्शित करने के लिए एक स्ट्रिंग प्रारूप और के {1}साथ विकल्पc दिखाया गया है स्ट्रिंग की दशमलव स्थान निर्धारित करने के लिए

print(XX): आपूर्ति की गई स्ट्रिंग को प्रिंट करता है

— user7297223
स्रोत

1

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

lambda a,b,c:(lambda s:s[:-c]+"."+s[-c:])(str(a*10**c//b))

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

यह निर्दिष्ट संख्या में दशमलव तक सटीक है जब तक कि a * 10 ** cबहुत बड़ा नहीं है।

मैंने पायथन 2 को छोटा करने की कोशिश की str(...), `...`लेकिन पायथन 2 एक सम्मिलित करता हैL अंत में यदि यह बहुत बड़ा है तो इसके लिए जाँच करना इससे अधिक बाइट्स लेने के लायक है।

— HyperNeutrino
स्रोत

1

स्टैक्स , 13 बाइट्स

ä·oαì█↕▬AS¥é▼

इसे चलाएं और डीबग करें

तर्क c a bक्रम में स्वीकार किए जाते हैं ।

— पुनरावर्ती
स्रोत

समस्या "प्रिंट (9999,23,1)" पोस्ट में रिजल्ट प्रिंट "434.7" होगी, जबकि आपका परिणाम "4.7" समान प्रतीत होता है, अंतिम बार: 5319.092201etc के बजाय 9.092201etc

— RosLuP

मैं सहमत नहीं हूं ... मैंने आज सुबह आपके लिंक का अनुसरण किया और आपके फ़ंक्शन ऑर्डर में "प्रिंट (9999,23,1)" परिणाम के लिए 4.7 और 434.7 नहीं था

— रोजलूपी

@RosLuP: मैंने दृष्टिकोण बदल दिया है। परिणाम अब सही ढंग से `434.7` है। मैंने प्रक्रिया में एक बाइट द्वारा आकार को भी कम कर दिया।

— पुनरावर्ती

0

सी, 67 बाइट्स

h(a,b,i){int j=!i;for(;printf(j++?"%u":"%u.",a/b),i--;a=10*(a%b));}

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

कुछ पिछले संस्करण मुझे लगता है कि कार्यक्रम के लिए सौंपी गई मेमोरी में से एक बग था ... सीलिंगकैट और सभी के लिए धन्यवाद ...

— RosLuP
स्रोत

@ceilingcat ठीक है धन्यवाद

— RosLuP

मुझे पिछले एक 69 बाइट्स पसंद हैं

— RosLuP

62 बाइट्स

— सीलिंगकैट

@ceilingcat ठीक है धन्यवाद

— RosLuP

इतनी कम संख्या का विभाजन नहीं

उदाहरण

05AB1E , 17 13 11 19 14 बाइट्स

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

पर्ल 6 , 58 57 55 48 बाइट्स

स्पष्टीकरण:

पर्ल, 55 बाइट्स

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

PHP, 187 बाइट्स

पायथ - 21 19 18 16 14 बाइट्स

जावास्क्रिप्ट (ईएस 6), 64 62 59 बाइट्स

जावा 7, 105 बाइट्स

रूबी, 67 बाइट्स

रैकेट 203 बाइट्स

क्यू, 196 बाइट्स

जंग, 114 बाइट्स

PHP, 89 बाइट्स

सी #, 126 बाइट्स

ग्रूवी ( 78 77 42 बाइट्स)

व्याख्या

बैच, 122 बाइट्स

गणितज्ञ, 50 बाइट्स

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

स्टैक्स , 13 बाइट्स

सी, 67 बाइट्स