Arka fon

Kısa bir süre önce küçük bir muhasebe firması tarafından işe alındınız. Muhasebe dünyası sizin için biraz yabancıdır, bu nedenle tüm profesyonel yönergelere uyup uymadığınızdan emin değilsiniz. Özellikle, tüm bu sayıları ne zaman yuvarlamanız gerektiğini ve hangi yönde yuvarlamanız gerektiğini bilmiyorsunuz, bu yüzden çoğu zaman kanatlandırıyorsunuz ve en iyisini umuyorsunuz.

Giriş

Girişiniz, basit bir hesaplamayı temsil eden tek bir dizedir. Karakterler tarafından sınırlanan bazı negatif olmayan tamsayılar içerir +-*/. Dize soldan sağa okunur ve normal öncelik kuralları yok sayılır, yani "23+1*3/4""23 ile başla, 1 ekle, 3 ile çarp ve 4 ile böl", sonuç 18 olur. Girdi ile başlayan sayılar içermez 0( 0kendisi hariç ) veya sıfıra bölme.

Çıktı

Hesaplamanın her aşamasında, sonucu en yakın tamsayıya yukarı veya aşağı yuvarlayabilir veya olduğu gibi tutabilirsiniz. Son olarak, bir tamsayı sonucu elde etmek için yukarı veya aşağı yuvarlarsınız. Çıktınız, böyle bir hesaplamadan kaynaklanabilen, yinelenen ve yinelenmeyen tamsayıların listesidir.

kurallar

Tam bir program veya bir işlev yazabilirsiniz. En düşük bayt sayısı kazanır ve standart boşluklara izin verilmez.

Test Durumları

"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]

J, 84 bayt

1 elemanlı bir listeden başlayarak, fonksiyon bir sonraki ifadeyi değerlendirip yukarı ve aşağı yuvarlak kopyalar ekleyerek listede olası tüm ara numaraları tutar.

Daha fazla golf olacak ve yarın açıklama ekleyecek. Daha fazla golf için belirgin yollar bulamıyorum.

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

Tüm testleri geçer.

Kullanımı:

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

Burada deneyin.

Python 2, 220 karakter

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)))

Olası tüm sayıların bir listesini tutar ve her adımda, kopyalar olsa bile listedeki her sayı için üç sayı üretir. Dolayısıyla, çalışma zamanı karmaşıklığı üsteldir. Ancak, bu küçük örnekler için anında çalışır. Sonunda dupes çıkarılır.

fractions.FractionTam bölme yapmak için, kayan nokta hatalarından kaçınmak için kullanır .

Performansı önemli ölçüde artırmak için 5 karakter ( r=map(X,g)-> r=set(map(X,g))) ekleyin .

Python, 421 370 354 bayt

Üzgünüm, lütfen benimle kal. Python için gerçekten yeniyim (sadece fractiosn'u destekleyen bir dil arıyordum) ve kodu kısaltmak için bildiğim birkaç hileyi kullandım ama neredeyse yarısı büyüklüğünde bir python çözümü olduğunu düşünüyoruz. Çok şey öğrendim ve yine de sunacağımı düşündüm =)

@ Kirbyfan64sos ve @Zgarb sayesinde yeni sürüm

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)))

Eski versiyon

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

Mathematica, 134

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

MATLAB, 283 karakter

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

Bunu yazarken, yazmayı bitirdikten sonra ekleyeceğim, bunu yapmanın daha kısa bir yolu olduğunu fark ettim.

VBA, 347 bayt

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