आउट-ऑफ-कंट्रोल राउंडिंग एरर्स

Question

पृष्ठभूमि

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

इनपुट

आपका इनपुट एक एकल स्ट्रिंग है जो एक सरल गणना का प्रतिनिधित्व करता है। इसमें वर्णों द्वारा परिसीमित कुछ संख्या में nonnegative पूर्णांक होते हैं +-*/। स्ट्रिंग बाएं से दाएं पढ़ती है, और सामान्य पूर्ववर्ती नियमों को अनदेखा किया जाता है, इसलिए "23+1*3/4"इसका अर्थ है "23 से शुरू करें, 1 जोड़ें, 3 से गुणा करें और 4 से विभाजित करें", परिणाम 18 हो रहा है। इनपुट में वे नंबर नहीं होंगे जो इसके साथ शुरू होते हैं 0( 0खुद को छोड़कर ), न ही शून्य से एक विभाजन।

उत्पादन

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

नियम

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

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

"42" -> [42]
"2+0+4-0" -> [6]
"23+1*3/4" -> [18]
"5/2" -> [2,3]
"5/2+7/3*6-1" -> [17,18,19,23]
"23/2/2*30-170/3" -> [-7,-6,-2,-1,0,1,3,4]
"1/3*2*2*2*2*2*2" -> [0,16,20,21,22,24,32,64]
"1/3*9" -> [0,3,9]

Comments

क्या कार्यक्रम को सभी संभावित आदानों (संख्या आकार की परवाह किए बिना), एक सीमित आकार के इनपुट, या केवल परीक्षण मामलों के लिए काम करना है?

— orlp

@orlp कम से कम तब काम करना चाहिए जब सभी इनपुट नंबर और इंटरमीडिएट परिणाम नीचे हों, कहते हैं, निरपेक्ष मूल्य में 10 मिलियन। लेखा फर्म छोटा है, सब के बाद।

— जर्गर्ब

परीक्षण के मामले पर ध्यान दें 1/3*9, यदि आप फ़्लोटिंग पॉइंट नंबरों का उपयोग करते हैं तो विफल हो सकते हैं।

— क्लाउडीउ

@ कोलियु धन्यवाद, मैंने इसे चुनौती में जोड़ा।

— जर्गर्ब

Answer 1

जे, 84 बाइट्स

1 एलिमेंट लिस्ट से शुरू होकर फंक्शन एक्सप्रेशन को बढ़ाकर और राउंडेड कॉपियों को जोड़कर लिस्ट में मौजूद सभी संभावित इंटरमीडिएट नंबरों को रखता है।

आगे गोल्फ करेंगे और कल स्पष्टीकरण जोड़ेंगे। यह और अधिक गोल्फ के लिए स्पष्ट तरीके नहीं मिल सकता है।

f=.3 :'/:~~.<.>((,>.,<.)@".@(":@],''x'',;@[))&.>/|.(>@{.;_2<\}.);:y rplc''/'';''%'''

सभी टेस्ट पास करता है।

उपयोग:

   f '1/3*2*2*2*2*2*2'
0 16 20 21 22 24 32 64
   f '1/3*9'
0 3 9

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

Comments

आप उनके साथ तैरने के बजाय तर्क के रूप में कैसे व्यवहार करते हैं - क्या यह जे के लिए बनाया गया है? (पूरा जे नोब यहाँ)

— क्लाउडीउ

xसूची में अंत में पत्र को जोड़कर प्रत्येक निष्कासन पर मैं सटीक संख्या बढ़ाता हूं (इस मामले में तर्कसंगत) ।

— यादृच्छिक

Answer 2

पायथन 2, 220 वर्ण

import re,sys,math as m,fractions as f
X=f.Fraction
M=map
F=['+']+re.split("(\D)",sys.argv[1])
r=[X(0)]
while F:U=[eval('f.'+`n`+F[0]+F[1])for n in r];r=M(X,U+M(m.floor,U)+M(m.ceil,U));F=F[2:]
print sorted(set(M(int,r)))

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

यह fractions.Fractionसटीक विभाजन करने के लिए उपयोग करता है, फ्लोटिंग पॉइंट अनुभवहीनता से बचता है।

नाटकीय रूप से प्रदर्शन बढ़ाने के लिए 5 अक्षर ( r=map(X,g)-> r=set(map(X,g))) जोड़ें ।

Comments

यहाँ शुरू करने के लिए एक आसान गोल्फ है: \Dगैर-अंकों के मिलान के लिए एक पूर्वनिर्धारित चरित्र वर्ग है

— Sp3000

@orlp: अब ठीक है! (मुझे लगता है ..)

— क्लाउडीउ

@ कलौदी: जो r"(\D)"या तो होना चाहिए "(\\D)"। इसके अलावा, अगर आप अजगर 3 का उपयोग करें, आप अनुक्रमण में जगह ले सकता है Fतारांकित काम, जैसे के साथ: A,B,*F=F, उपयोग Aऔर Bके बजाय F[0]और F[1], और से छुटकारा पाने के F=F[2:]।

— Mac

@ मैक: "\D"वैसे भी काम करना समाप्त कर देता है और यह छोटा होता है। यह एक वैध भागने का क्रम नहीं है इसलिए पायथन में सिर्फ \ और Dशब्दशः शामिल हैं। अच्छा पायथन 3 टिप वास्तव में, मैं इसकी जांच करूंगा, हालांकि मुझे बैकटिक्स को बदलना होगा repr()और mapपरिणाम को सूची में बदलना होगा । तारांकित असाइनमेंट कुछ ऐसा है जो मैं चाहता हूं कि अजगर 2 था ..

— क्लाउडी

Answer 3

पायथन, 421 370 354 बाइट्स

क्षमा करें, कृपया मेरे साथ सहन करें। मैं वास्तव में अजगर के लिए नया हूं (मैं बस एक ऐसी भाषा की तलाश कर रहा था जो फ्रैक्चर का समर्थन करता है) और कोड को छोटा करने के लिए मैं जानता था कि सभी कुछ तरकीबों का इस्तेमाल किया है लेकिन यह अभी भी एक राक्षस है जो यह विचार करता है कि लगभग आधे आकार का एक अजगर समाधान है। मैंने बहुत कुछ सीखा और सोचा कि मैं इसे वैसे भी जमा कर दूंगा =)

नया संस्करण @ kirbyfan64sos और @Zgarb के लिए धन्यवाद

from fractions import*
from math import*
import re,operator as z
s=input()
N=re.split(r'[\*\/\-\+]',s)
O=re.split(r'[0-9]+',s)[1:-1]
d={'+':z.add,'-':z.sub,'*':z.mul,'/':z.truediv}
l=[int(N[0])]#list of inters up to now
for i in range(len(O)): #iterate over all operations
    n=set()
    for f in l:
        f=d[O[i]](f,Fraction(int(N[i+1])))
        n.update([floor(f),ceil(f),f])
    l=n
print(set(map(floor,n)))

पुराना संस्करण

from fractions import Fraction as F
from math import floor,ceil
import re
s=input()
N=re.split(r'[\*\/\-\+]',s)   #Numbers
O=re.split(r'[0-9]+',s)[1:-1] #Operators
l=[int(N[0])]
for i in range(len(O)): #Iterate over all operators
    n=set()
    for f in l:           #Iterate over all possible numbers
        g=F(int(N[i+1]))
        o=O[i]
        if o=='/':
            f/=g
        elif o=='*':
            f*=g
        elif o=='-':
            f-=g
        else:
            f+=g
        n.add(floor(f))  #Add all possible numbers to a new set 
        n.add(ceil(f))   # the 'set' structure prevents from having multiple copies
        n.add(f)         # which is a really nice feature
    l=n                #repeat
print(set([floor(k) for k in n])) #also remove the unrounded ones

Comments

एक बात के लिए, आप कुछ जगह के संकेत को टैब से बदल सकते हैं (यह आम तौर पर बेकार है, लेकिन कोड गोल्फ में अच्छा काम करता है: एक टैब == 1 वर्ण)। आप कई ifएस ( d={'+': operator.add, '-': operator.sub, ...}; d[op](a, b)) के बजाय एक हुक का उपयोग कर सकते हैं । इसके अलावा, [floor(k) for k in n]को छोटा किया जा सकता है map(floor, n), और n.addकॉल बन सकते हैं n.extend([floor(f), ceil(f), f])।

— kirbyfan64sos

वाह बहुत बहुत धन्यवाद, मैं कोशिश कर रहा हूँ और उन्हें लागू! मैंने पहले ही इंडेंट्स को टैब के रूप में गिना था लेकिन मुझे उन्हें यहां स्पेस में बदलना पड़ा।

— दोष

आप केवल एकल रिक्त स्थान का उपयोग कर सकते हैं; उन्हें काम करना चाहिए।

— kirbyfan64sos

जहां तक ​​मैं देख सकता हूं, आप Fकेवल एक बार उपयोग करते हैं, इसलिए आप from fractions import*कुछ बाइट्स कर सकते हैं और बचा सकते हैं । उसी के साथ math। चारों ओर रिक्त स्थान निकालें =, वे अनावश्यक हैं। इसके अलावा, आपको sहार्ड-कोडिंग के बजाय इनपुट असाइन करना चाहिए ।

— जर्गर्ब

@flawr हर वैकल्पिक स्थान को निकालें। साथ ही, आपको किसी भी इनपुट को स्वीकार करने में सक्षम होना चाहिए । s=input()इसके बजाय का उपयोग करें s = "1/3*9", अपनी टिप्पणियों को हटा दें, आदि

— mbomb007

Answer 4

गणितज्ञ, १३४

Union@Flatten@{Floor@#,Ceiling@#}&@ToExpression@StringReplace[#,x:("+"|"-"|"*"|"/"~~NumberString):>"//{Floor@#,#,Ceiling@#}"~~x~~"&"]&

Answer 5

MATLAB, 283 वर्ण

function[u]=w(s)
s=[' ' strsplit(regexprep(s,'\D',' $& '))];s=reshape(s,[2,size(s,2)/2]);o=s(1,:);d=cellfun(@str2num,s(2,:));a=d(1);for n=2:size(o,2)switch o{n}case'+';a=a+d(n);case'-'a=a-d(n);case'/'a=a/d(n);case'*'a=a*d(n);end;a=[ceil(a);a;floor(a)];end;u=unique(a(mod(a,1)==0))end

Ungolfed:

function [u] = WingitRound(i)
    i=[' ' strsplit(regexprep(i,'\D',' $& '))];
    i=reshape(i,[2,size(i,2)/2]);

    o=i(1,:);
    n=cellfun(@str2num,i(2,:));

    a=n(1);

    for n=2:size(o,2)
        switch o{n}
            case '+'
                a = a + n(n);
            case '-'
                a = a - n(n);
            case '/'
                a = a / n(n);
            case '*'
                a = a * n(n);
        end
        a = [ceil(a);a;floor(a)];
    end

    u=unique(a(mod(a,1)==0)));
end

इसे लिखते समय, मुझे एहसास हुआ कि ऐसा करने का एक और भी छोटा तरीका है, जिसे मैं लिखने के बाद जोड़ दूंगा।

Answer 6

VBA, 347 बाइट्स

Function OoCRE(inp As String)
ct = 0
i = 1
Do While i < Len(inp)
c = Mid(inp, i, 1)
If Not IsNumeric(c) Then
ct = ct + 1
If ct = 2 Then
inp = Round(Application.Evaluate(Left(inp, i - 1))) & Right(inp, Len(inp) - (i - 1))
i = InStr(1, inp, c)
ct = 1
End If
End If
OoCRE = Round(Application.Evaluate(inp))
i = i + 1
Loop
End Function

Comments

यहाँ पर बहुत अधिक गोल्फिंग की जाती है, मुख्यतः सुपरफ़्लस व्हाट्सएप को हटाने और छोटे var नाम चुनने के लिए

— cat