एक अंश को बार-बार दशमलव में बदलें

Question

लगभग ध्रुवीय विपरीत अगर यह चुनौती है, और मुझे संदेह है कि यह थोड़ा आसान होगा।

आपका कार्य प्रारूप में दो पूर्णांकों को लेना है a/b(एक परिमेय संख्या बनाते हुए) फिर दशमलव में संख्या को बिल्कुल आउटपुट करें।

उदाहरण के लिए, यदि आप इनपुट करते थे, तो 1/3यह आउटपुट:

0.33333333333333333

और समय के अंत तक 3s की छपाई जारी रखेगा, एक वैकल्पिक अग्रणी के साथ 0. (आप प्रति पंक्ति एक वर्ण भी प्रिंट कर सकते हैं यदि और केवल तभी जब आपकी भाषा एक ही पंक्ति पर मुद्रण की अनुमति नहीं देती है।)

के लिए व्यवहार x/0अपरिभाषित होगा। एक संख्या के लिए जो दिखता है वह दोहराता नहीं है (जैसे, कहते हैं 5/4) यह वास्तव में दोहराता है। निम्नलिखित दो रूपों में से किसी एक के लिए स्वीकार्य होगा 5/4:

1.25000000000000000
1.24999999999999999

(पूरी संख्याओं के साथ भी, 1.9999999या 2.000000)

अंश इसके सरलतम रूप में नहीं हो सकता है, और aया bनकारात्मक हो सकता (नोट -a/b = -(a/b), -a/-b = a/b, a/-b = -a/b, और -.6249999अमान्य है, लेकिन -0.6249999स्वीकार्य है, लेकिन आप अभी भी उपयोग कर सकते हैं।

Comments

क्या हम यूनिक्स का उपयोग कर सकते हैं bc, या यह धोखा है?

— डेविड आर ट्रिबल

इससे पहले कि मैं अपने जवाब गोल्फ रखना: Can aऔर / या bहो नकारात्मक?

— डेनिस

@Dennis हाँ, पर या तो aया bनकारात्मक (या दोनों) हो सकता है)

@DavidRTribble मुझे लगता है कि यह एक मानक खामी है, इसलिए नहीं।

क्या आपका नवीनतम संपादन कहता है कि अग्रणी शून्य सकारात्मक संख्याओं के साथ ठीक हैं, लेकिन नकारात्मक नहीं? यदि हां, तो उसका कारण क्या है?

— ज्योबिट्स

Answer 1

CJam, 38 37 बाइट्स

l'/%:i2*~*0<'-*o:Dmd\zo'.{oA*Dmd\z1}g

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

l     e# Read line from STDIN.            STACK '17/-13'
'/%   e# Split at '/'.                    STACK ['17' '-13']
:i    e# Cast each element to int.        STACK [17 -13]
2*~   e# Duplicate and dump the array.    STACK 17 -13 17 -13
*     e# Multiply.                        STACK 17 -13 -221
0<    e# Compare with zero.               STACK 17 -13 1
'-*o  e# Print '-' that many times.       STACK 17 -13
:D    e# Save the topmost integer in D.   STACK 17 -13
md    e# Perform modular division.        STACK -1 4
\z    e# Swap and take absolute value.    STACK 4 1
o'.   e# Print and push '.'.              STACK 4 '.'
{     e# do:
  o   e#   Print.                         STACK 4
  A*  e#   Multiply by 10.                STACK 40
  Dmd e#   Divide modulo D.               STACK -3 1
  \z  e#   Swap and take absolute value.  STACK 1 3
  o   e#   Print.                         STACK 1
1}g   e# while(1)

Comments

चूंकि आप डबल डिवीजन का उपयोग करते हैं, इसलिए यह बड़ी संख्या के लिए पूरी तरह से टूट नहीं है?

— orlp

@orlp: पूरी तरह से। यह अब तय हो गया है।

— डेनिस

Answer 2

सी, 108 79

नकारात्मक संख्याओं के साथ काम करने के लिए संशोधित संपादित करें ।

स्टड से इनपुट। पुरानी कश्मीर और आर शैली।

main(a,b){char*s="-%d.";scanf("%d/%d",&a,&b);for(a*b<0?(a<0?a=-a:(b=-b)):++s;printf(s,a/b);s="%d")a=a%b*10;}

Answer 3

रूबी, 83 69 102 91 89 बाइट्स

->s{a,b=s.scan(/\d+/).map &:to_i
eval(s+?r)<0&&$><<?-
$><<a/b<<?.
loop{a=a%b*10
$><<a/b}}

कंप्यूटर के पूर्णांक विभाजन के आधार पर मैनुअल पूर्णांक विभाजन का सरल कार्यान्वयन।

गोल्फिंग में मदद के लिए @blutorange का धन्यवाद।

संपादित करें: नकारात्मक संख्याओं को शामिल करने के लिए समाधान का निर्धारण।

Comments

रूबी में कुछ शॉर्टकट का उपयोग करके, आप इसे 66 बाइट्स में ला सकते हैं: ->s{a,b=s.split(?/).map &:to_i;$><<a/b<<?.;loop{a=a%b*10;$><<a/b}} मुझे सिर्फ रूबी के बारे में यह पसंद है।

— ब्लुटोरांगे

वाह, मैंने अभी बहुत सी बातें सीखीं, धन्यवाद! मुझे ?/वर्णों को निरूपित करने के बारे में याद नहीं था , न ही मुझे $><<प्रिंट या loopकीवर्ड के बारे में पता था । बहुत बहुत धन्यवाद!!

— रॉलर्क

आपका स्वागत है, मुझे इनमें से कई ट्रिक के बारे में तब तक नहीं पता था जब तक कि कोई इसे इंगित नहीं करता। $>के लिए छोटा है $stdout, और <<एक ऑपरेटर है। आप इसे बदलकर दूसरी पंक्ति में एक और बाइट बचा सकते हैं c*d<0&&$><<?-; 3 / 4th लाइन के संयोजन से कुछ बाइट्स $><<a/b<<?., और <<अंतिम पंक्ति में स्थान को हटाकर एक और । और यहाँ इसे 91 बाइट्स तक लाने का विचार है:->s{a,b=s.scan(/\d+/).map &:to_i;1==s.count(?-)&&$><<?-;$><<a/b<<?.;loop{a=a%b*10;$><<a/b}} (रूबी 2.2.0)

— ब्लोटोरेंज

सिंटैक्स के लिए $><<a/bसही ढंग से काम नहीं किया, यही कारण है कि मैं वहाँ अंतरिक्ष डाल दिया। बाकी सब अच्छा लगता है, बहुत-बहुत धन्यवाद!

— रॉलर्क

यदि आप अभी भी रुचि रखते हैं, तो रूबी 2.1 के बाद से एक तर्कसंगत शाब्दिक ( Rational(2,3) == 2/3r) भी है (जो मैंने 10 मिनट पहले सीखा था) जिसका उपयोग दूसरी पंक्ति को छोटा करने के लिए किया जा सकता है:eval(s+?r)<0&&$><<?-

— ब्लुटोरेंज

Answer 4

जावा, 177 176 170

s->{try{int x=new Integer(s.split("/")[0]),y=new Integer(s.split("/")[1]),z=1;for(;;x=x%y*10,Thread.sleep(999))System.out.print(x/y+(z-->0?".":""));}catch(Exception e){}}

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

विस्तारित, रन करने योग्य संस्करण

public class RepeatedDecimal {
    public static void main(String[] args) {
        java.util.function.Consumer<String> f = s -> {
                try {
                    int x = new Integer(s.split("/")[0]),
                        y = new Integer(s.split("/")[1]),
                        z = 1;
                    for (;; x = x % y * 10, Thread.sleep(999)) {
                        System.out.print(x / y + (z-- > 0 ? "." : ""));
                    }
                } catch (Exception e) { }
                };

        f.accept("5/7");
    }
}

Comments

जबकि आउटपुट में फ्लशिंग समस्या है, मैं इसे 9ms तक सोने से आउटपुट दिखाने में सक्षम था जो दो बाइट्स दाढ़ी करता था।

@Snowman यह शायद हार्डवेयर या OS पर निर्भर करता है; मेरा कंप्यूटर 250ms या उससे कम के साथ काम नहीं करेगा।

— यपनिप

Answer 5

आर, 103 137 109 103

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

cat(if(prod(i=scan(sep='/'))<0)'-',(n=(i=abs(i))[1])%/%(d=i[2]),'.',sep='');repeat cat((n=n%%d*10)%/%d)

टेस्ट चलता है

> cat(if(prod(i=scan(sep='/'))<0)'-',(n=(i=abs(i))[1])%/%(d=i[2]),'.',sep='');repeat cat((n=n%%d*10)%/%d)
1: -1/3
3: 
Read 2 items
-0.33333333333333333333...
> cat(if(prod(i=scan(sep='/'))<0)'-',(n=(i=abs(i))[1])%/%(d=i[2]),'.',sep='');repeat cat((n=n%%d*10)%/%d)
1: -5/-4
3: 
Read 2 items
1.250000000000000000000...

Answer 6

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

a,b=map(int,input().split("/"))
print(("%.1f"%(a/b))[:-1],end="")
b=abs(b)
while 1:a=abs(a)%b*10;print(a//b,end="")

बहुत सीधा:

• अंश और हर को इनपुट करें
• दशमलव बिंदु के बाद भागफल को 1 अंक के साथ आउटपुट करें, फिर अंतिम अंक को हटाएं (जैसे -1/3-> -0.)
• पूर्ण मान लें *
• लूप:
  • भाजक शेष भाजक को विभाजित करने के बाद शेष है
  • गुणक 10 से गुणा करें
  • अगले अंक के रूप में आउटपुट पूर्णांक भागफल

* (हालांकि aकुछ बाइट्स को बचाने के लिए गणना को लूप के अंदर ले जाया गया था।)

संपादित करें: नकारात्मक अंशों के साथ फिक्स्ड बग> -1।

Answer 7

पायथन 2.7, 209 बाइट्स

from sys import*;m,o=1,lambda x:stdout.write(str(x));a,b=[int(x)for x in argv[1].split('/')]
o(str(a*b)[0]);a,b=abs(a),abs(b);o('0'*(b>a))
while 1:
 while not((m*a)/b):o('0.'[m==1]);m*=10
 o((m*a)/b);a=(m*a)%b

संपादित करें:

अब सभी वर्णों को उसी पंक्ति में आउटपुट करता है, जैसा पूछा गया है।

EDIT2:

अब कमांड लाइन तर्क से अंश पढ़ता है, जैसा कि अनुरोध किया गया :)

Comments

कुछ सुझाव: 1) mapसूची समझ के बजाय का उपयोग करना काफी थोड़ा बचाता है; 2) के आसपास कोष्ठक जरूरत नहीं m*a, अपने स्थानों में से किसी में के रूप में *, %है, और /सभी एक ही पूर्वता और बाएं साहचर्य कर रहे हैं; 3) लाइन 3 पर 0 या-डॉट लॉजिक को सरल बनाया जा सकता है "0."[m==1], क्योंकि आप इसे वैसे भी छाप रहे हैं; 4) शायद केवल सेट करने के लिए वर्णों को बचाएगा o=stdout.writeऔर आवश्यकतानुसार बैक्टिक्स के साथ संख्यात्मक तर्कों को स्ट्रिंग में परिवर्तित करेगा ।

— DLosc

इसके अलावा, कोड नकारात्मक के साथ काम नहीं करता है: इसके बजाय 1/-3देता -1.666666666है -0.333333333।

— DLosc