Antecedentes

Recientemente ha sido contratado por una pequeña empresa de contabilidad. El mundo de la contabilidad es algo extraño para usted, por lo que no está seguro de seguir todas las pautas profesionales. En particular, no sabes cuándo debes redondear todos esos números y en qué dirección, por lo que la mayoría de las veces simplemente lo alejas y esperas lo mejor.

Entrada

Su entrada es una sola cadena que representa un cálculo simple. Contiene cierto número de enteros no negativos delimitados por los caracteres +-*/. La cadena se lee de izquierda a derecha y se ignoran las reglas de precedencia normales, por lo que "23+1*3/4"significa "comenzar con 23, sumar 1, multiplicar por 3 y dividir por 4", el resultado es 18. La entrada no contendrá números que comiencen con 0(excepto en 0sí mismo), ni una división por cero.

Salida

En cada etapa del cálculo, puede redondear el resultado hacia arriba o hacia abajo al entero más cercano o mantenerlo como está. Finalmente, redondeas hacia arriba o hacia abajo para obtener un resultado entero. Su salida es la lista de enteros que pueden resultar de dicho cálculo, ordenados y sin duplicados.

Reglas

Puede escribir un programa completo o una función. El conteo de bytes más bajo gana, y las lagunas estándar no se permiten.

Casos de prueba

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

Comenzando desde una lista de 1 elemento, la función mantiene todos los números intermedios posibles en la lista evaluando la siguiente expresión y agregando sus copias redondeadas hacia arriba y hacia abajo.

Jugará más al golf y agregará una explicación mañana. No puedo encontrar formas obvias de jugar más al golf.

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

Pasa todas las pruebas.

Uso:

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

Pruébalo aquí.

Python 2, 220 caracteres

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

Mantiene una lista de todos los números posibles y, en cada paso, genera tres números para cada número de la lista, incluso si hay duplicados. Por lo tanto, la complejidad del tiempo de ejecución es exponencial. Sin embargo, funciona instantáneamente para estos pequeños ejemplos. Los engaños se eliminan al final.

Se utiliza fractions.Fractionpara hacer una división exacta, evitando inexactitudes de coma flotante.

Agregue 5 caracteres ( r=map(X,g)-> r=set(map(X,g))) para aumentar drásticamente el rendimiento.

Python, 421 370 354 bytes

Lo siento, por favor tengan paciencia conmigo. Soy realmente nuevo en Python (solo estaba buscando un lenguaje que admita fractiosn) y utilicé todos los pocos trucos que conocía para acortar el código, pero todavía es un monstruo considerando que hay una solución de Python de casi la mitad del tamaño. Aprendí mucho y pensé en enviarlo de todos modos =)

Nueva versión gracias a @ kirbyfan64sos y @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)))

Versión antigua

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 caracteres

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

Sin golf:

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

Mientras escribía esto, me di cuenta de que hay una forma aún más corta de hacerlo, que agregaré una vez que termine de escribirlo.

VBA, 347 bytes

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