La evaluación de una serie de expresiones matemáticas sencillas [cerrada]
https://stackoverflow.com/questions/928563
-
06-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPregunta
Challenge
Aquí es el desafío (de mi propia invención, aunque no me sorprendería si ha aparecido previamente en otro lugar en la web).
Escribir una función que toma un solo argumento de que es una representación de cadena de un simple expresión matemática y evalúa como un valor de punto flotante. UNA "Simple expresión" puede incluir cualquiera de lo siguiente: positivo o negativo números decimales, + , - , * , / , (, ) . Expresiones utilizan (normal) infija notación . Los operadores deben ser evaluados en el orden en que aparecen, es decir, no como en BODMAS , aunque los soportes deben estar correctamente observado, por supuesto. La función debe devolver el resultado correcto para cualquier posible la expresión de esta forma. Sin embargo, la función no tiene para manejar expresiones mal formadas (es decir, aquellos con mala sintaxis).
Los ejemplos de expresiones:
1 + 3 / -8 = -0.5 (No BODMAS) 2*3*4*5+99 = 219 4 * (9 - 4) / (2 * 6 - 2) + 8 = 10 1 + ((123 * 3 - 69) / 100) = 4 2.45/8.5*9.27+(5*0.0023) = 2.68...
Reglas
preveo algún tipo de "trampa" / astucia de aquí, así que por favor déjame prevengo contra ella! Por trampa, me refiero a la utilización de la eval o función equivalente en los lenguajes dinámicos como JavaScript o PHP, o igualmente compilar y ejecutar código sobre la marcha. (Creo que mi especificación de "no BODMAS" prácticamente ha garantizado esto, sin embargo.) Aparte de eso, no hay restricciones. Preveo algunas soluciones expresiones regulares aquí, pero sería agradable ver algo más que eso.
Ahora, estoy principalmente interesado en una solución NET C # /. Aquí, pero cualquier otro idioma sería perfectamente aceptable también (en particular, F # y Python para los enfoques funcionales / mixtos). Todavía no he decidido si voy a aceptar la solución más corta o más ingeniosa (al menos para el lenguaje) como la respuesta, pero me daría la bienvenida a cualquier forma de solución en cualquier idioma , excepto lo que acabo prohibida la práctica!
Mi Solución
Ahora he publicado mi C # solución aquí (403 caracteres). Actualización: Mi nueva solución ha vencido el viejo significativamente a 294 caracteres , con la ayuda de un poco de expresiones regulares preciosa! Yo sospechaba que esto va a conseguir fácilmente golpeado por algunos de los idiomas por ahí con una sintaxis más ligero (en particular los más funcional / dinámicos), y se han dado la razón, pero tengo curiosidad si alguien podría superar esto en C # todavía.
Actualizar
He visto algunas soluciones muy astuto ya. Gracias a todos los que han publicado una. Aunque no he probado ninguno de ellos, sin embargo, voy a confiar en la gente y asumir que al menos trabajar con todos los ejemplos dados.
Sólo por la nota, re-entrada (es decir, el hilo de seguridad) es no un requisito para la función, a pesar de que es una ventaja.
Formato
Por favor enviar todas las respuestas en el siguiente formato con el fin de facilitar la comparación:
Idioma
Número de caracteres: ???
Función totalmente ofuscado:
(code here)Claro / función semi-ofuscado:
(code here)Todas las notas sobre los atajos de algoritmos inteligentes / que adopta.
Solución
Perl (sin eval)
Número de caracteres: 167 106 (ver más abajo para la versión de 106 caracteres)
Función totalmente ofuscado: (167 caracteres si se une a estas tres líneas en una sola)
sub e{my$_="($_[0])";s/\s//g;$n=q"(-?\d++(\.\d+)?+)";
@a=(sub{$1},1,sub{$3*$6},sub{$3+$6},4,sub{$3-$6},6,sub{$3/$6});
while(s:\($n\)|(?<=\()$n(.)$n:$a[7&ord$5]():e){}$_}
Claro / versión deobfuscated:
sub e {
my $_ = "($_[0])";
s/\s//g;
$n=q"(-?\d++(\.\d+)?+)"; # a regex for "number", including capturing groups
# q"foo" in perl means the same as 'foo'
# Note the use of ++ and ?+ to tell perl
# "no backtracking"
@a=(sub{$1}, # 0 - no operator found
1, # placeholder
sub{$3*$6}, # 2 - ord('*') = 052
sub{$3+$6}, # 3 - ord('+') = 053
4, # placeholder
sub{$3-$6}, # 5 - ord('-') = 055
6, # placeholder
sub{$3/$6}); # 7 - ord('/') = 057
# The (?<=... bit means "find a NUM WHATEVER NUM sequence that happens
# immediately after a left paren", without including the left
# paren. The while loop repeatedly replaces "(" NUM WHATEVER NUM with
# "(" RESULT and "(" NUM ")" with NUM. The while loop keeps going
# so long as those replacements can be made.
while(s:\($n\)|(?<=\()$n(.)$n:$a[7&ord$5]():e){}
# A perl function returns the value of the last statement
$_
}
Yo había leído mal las reglas inicialmente, por lo que había presentado una versión con "eval". Aquí hay una versión sin él.
La última poco de conocimiento fue cuando me di cuenta de que el último dígito octal en los códigos de caracteres para +, -, / y * es diferente, y que ord(undef) es 0. Esto me permite configurar la tabla de despacho @a como una matriz, y simplemente invocar el código en la 7 & ord($3) ubicación.
Hay un lugar obvio para cortar un carácter más - q"" cambio en '' -., Pero que haría más difícil de cortar y pegar en la cáscara
Incluso más cortos
Número de caracteres: 124 106
ephemient en cuenta, se ha reducido a 124 caracteres: (unir las dos líneas en una sola)
sub e{$_=$_[0];s/\s//g;$n=q"(-?\d++(\.\d+)?+)";
1while s:\($n\)|$n(.)$n:($1,1,$3*$6,$3+$6,4,$3-$6,6,$6&&$3/$6)[7&ord$5]:e;$_}
Shorter todavía
Número de caracteres: 110 106
La solución rubí abajo me empuja aún más, aunque no puedo llegar a un total de 104 caracteres:
sub e{($_)=@_;$n='( *-?[.\d]++ *)';
s:\($n\)|$n(.)$n:(($1,$2-$4,$4&&$2/$4,$2*$4,$2+$4)x9)[.8*ord$3]:e?e($_):$_}
he tenido que ceder y utilizar ''. Ese truco rubí send es realmente útil para este problema.
Exprimir el agua de una piedra
Número de caracteres: 106
Una pequeña contorsión para evitar la división por cero cheque.
sub e{($_)=@_;$n='( *-?[.\d]++ *)';
s:\($n\)|$n(.)$n:($1,0,$2*$4,$2+$4,0,$2-$4)[7&ord$3]//$2/$4:e?e($_):$_}
Este es el instrumento de prueba para esta función:
perl -le 'sub e{($_)=@_;$n='\''( *-?[.\d]++ *)'\'';s:\($n\)|$n(.)$n:($1,0,$2*$4,$2+$4,0,$2-$4)[7&ord$3]//$2/$4:e?e($_):$_}' -e 'print e($_) for @ARGV' '1 + 3' '1 + ((123 * 3 - 69) / 100)' '4 * (9 - 4) / (2 * 6 - 2) + 8' '2*3*4*5+99' '2.45/8.5*9.27+(5*0.0023) ' '1 + 3 / -8'
Otros consejos
Ensamblador
427 bytes
ofuscado, ensamblado con la excelente A86 en un ejecutable .com:
dd 0db9b1f89h, 081bee3h, 0e8af789h, 0d9080080h, 0bdac7674h, 013b40286h
dd 07400463ah, 0ccfe4508h, 08ce9f675h, 02fc8000h, 013b0057eh, 0feaac42ah
dd 0bedf75c9h, 0ba680081h, 04de801h, 04874f73bh, 04474103ch, 0e8e8b60fh
dd 08e8a003fh, 0e880290h, 0de0153h, 08b57e6ebh, 0d902a93eh, 046d891dh
dd 08906c783h, 05f02a93eh, 03cffcee8h, 057197510h, 02a93e8bh, 08b06ef83h
dd 05d9046dh, 02a93e89h, 03bc9d95fh, 0ac0174f7h, 074f73bc3h, 0f3cac24h
dd 0eed9c474h, 0197f0b3ch, 07cc4940fh, 074f73b09h, 0103cac09h, 0a3ce274h
dd 0e40a537eh, 0e0d90274h, 02a3bac3h, 021cd09b4h, 03e8b20cdh, 0ff8102a9h
dd 0ed7502abh, 0474103ch, 0e57d0b3ch, 0be02a3bfh, 014d903a3h, 0800344f6h
dd 02db00574h, 0d9e0d9aah, 0d9029f2eh, 0bb34dfc0h, 08a0009h, 01c75f0a8h
dd 020750fa8h, 0b0f3794bh, 021e9aa30h, 0de607400h, 08802990eh, 0de07df07h
dd 0c392ebc1h, 0e8c0008ah, 0aa300404h, 0f24008ah, 04baa3004h, 02eb0ee79h
dd 03005c6aah, 0c0d90ab1h, 0e9defcd9h, 02a116deh, 0e480e0dfh, 040fc8045h
dd 0ede1274h, 0c0d90299h, 015dffcd9h, 047300580h, 0de75c9feh, 0303d804fh
dd 03d80fa74h, 04f01752eh, 0240145c6h, 0dfff52e9h, 0d9029906h, 0f73b025fh
dd 03caca174h, 07fed740ah, 0df07889ah, 0277d807h, 047d9c1deh, 0990ede02h
dd 025fd902h, 03130e0ebh, 035343332h, 039383736h, 02f2b2d2eh, 02029282ah
dd 0e9000a09h, 07fc9f9c1h, 04500000fh, 0726f7272h
db 024h, 0abh, 02h
EDIT: fuente Unobfuscated:
mov [bx],bx
finit
mov si,81h
mov di,si
mov cl,[80h]
or cl,bl
jz ret
l1:
lodsb
mov bp,d1
mov ah,19
l2:
cmp al,[bp]
je l3
inc bp
dec ah
jne l2
jmp exit
l3:
cmp ah,2
jle l4
mov al,19
sub al,ah
stosb
l4:
dec cl
jnz l1
mov si,81h
push done
decode:
l5:
call l7
l50:
cmp si,di
je ret
cmp al,16
je ret
db 0fh, 0b6h, 0e8h ; movzx bp,al
call l7
mov cl,[bp+op-11]
mov byte ptr [sm1],cl
db 0deh
sm1:db ?
jmp l50
open:
push di
mov di,word ptr [s]
fstp dword ptr [di]
mov [di+4],bp
add di,6
mov word ptr [s],di
pop di
call decode
cmp al,16
jne ret
push di
mov di,word ptr [s]
sub di,6
mov bp,[di+4]
fld dword ptr [di]
mov word ptr [s],di
pop di
fxch st(1)
cmp si,di
je ret
lodsb
ret
l7: cmp si,di
je exit
lodsb
cmp al,15
je open
fldz
cmp al,11
jg exit
db 0fh, 94h, 0c4h ; sete ah
jl l10
l9:
cmp si,di
je l12
lodsb
cmp al,16
je ret
l10:
cmp al,10
jle l12i
l12:
or ah,ah
je l13
fchs
l13:
ret
exit:
mov dx,offset res
mov ah,9
int 21h
int 20h
done:
mov di,word ptr [s]
cmp di,(offset s)+2
jne exit
cmp al,16
je ok
cmp al,11
jge exit
ok:
mov di,res
mov si,res+100h
fst dword ptr [si]
test byte ptr [si+3],80h
jz pos
mov al,'-'
stosb
fchs
pos:
fldcw word ptr [cw]
fld st(0)
fbstp [si]
mov bx,9
l1000:
mov al,[si+bx]
test al,0f0h
jne startu
test al,0fh
jne startl
dec bx
jns l1000
mov al,'0'
stosb
jmp frac
l12i:
je l11
fimul word ptr [d3]
mov [bx],al
fild word ptr [bx]
faddp
jmp l9
ret
startu:
mov al,[si+bx]
shr al,4
add al,'0'
stosb
startl:
mov al,[si+bx]
and al,0fh
add al,'0'
stosb
dec bx
jns startu
frac:
mov al,'.'
stosb
mov byte ptr [di],'0'
mov cl,10
fld st(0)
frndint
frac1:
fsubp st(1)
ficom word ptr [zero]
fstsw ax
and ah,045h
cmp ah,040h
je finished
fimul word ptr [d3]
fld st(0)
frndint
fist word ptr [di]
add byte ptr [di],'0'
inc di
dec cl
jnz frac1
finished:
dec di
cmp byte ptr [di],'0'
je finished
cmp byte ptr [di],'.'
jne f2
dec di
f2:
mov byte ptr [di+1],'$'
exit2:
jmp exit
l11:
fild word ptr [d3]
fstp dword ptr [bx+2]
l111:
cmp si,di
je ret
lodsb
cmp al,10
je exit2
jg ret
mov [bx],al
fild word ptr [bx]
fdiv dword ptr [bx+2]
faddp
fld dword ptr [bx+2]
fimul word ptr [d3]
fstp dword ptr [bx+2]
jmp l111
d1: db '0123456789.-+/*()', 32, 9
d3: dw 10
op: db 0e9h, 0c1h, 0f9h, 0c9h
cw: dw 0f7fh
zero: dw 0
res:db 'Error$'
s: dw (offset s)+2
Rubí
Número de caracteres: 103
N='( *-?[\d.]+ *)'
def e x
x.sub!(/\(#{N}\)|#{N}([^.\d])#{N}/){$1or(e$2).send$3,e($4)}?e(x):x.to_f
end
Este es un no recursivo versión de la solución de la traviesa de pulgas. Entre paréntesis sub-expresiones se evalúan de abajo hacia arriba en lugar de arriba hacia abajo.
Editar : (. Pesar de que la recursividad no es semánticamente es necesario) La conversión de la 'mientras que' a una recursión + cola condicional ha ahorrado unos cuantos caracteres, por lo que ya no es no recursivo
Editar : El préstamo de la idea de Daniel Martin de la fusión de las expresiones regulares ahorra otro 11 caracteres
Editar : Que la recursividad es aún más útil que pensé por primera vez! x.to_f se puede reescribir como e(x), si x pasa a contener un solo número.
Editar :. El uso de 'or' en lugar de '||' permite a un par de paréntesis que se retiren
Versión larga:
# Decimal number, as a capturing group, for substitution
# in the main regexp below.
N='( *-?[\d.]+ *)'
# The evaluation function
def e(x)
matched = x.sub!(/\(#{N}\)|#{N}([^\d.])#{N}/) do
# Group 1 is a numeric literal in parentheses. If this is present then
# just return it.
if $1
$1
# Otherwise, $3 is an operator symbol and $2 and $4 are the operands
else
# Recursively call e to parse the operands (we already know from the
# regexp that they are numeric literals, and this is slightly shorter
# than using :to_f)
e($2).send($3, e($4))
# We could have converted $3 to a symbol ($3.to_s) or converted the
# result back to string form, but both are done automatically anyway
end
end
if matched then
# We did one reduction. Now recurse back and look for more.
e(x)
else
# If the string doesn't look like a non-trivial expression, assume it is a
# string representation of a real number and attempt to parse it
x.to_f
end
end
C (VS2005)
Número de caracteres: 1360
Abuso de preprocesador y las advertencias para el diseño de código de diversión (desplácese hacia abajo para ver):
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define b main
#define c(a) b(a,0)
#define d -1
#define e -2
#define g break
#define h case
#define hh h
#define hhh h
#define w(i) case i
#define i return
#define j switch
#define k float
#define l realloc
#define m sscanf
#define n int _
#define o char
#define t(u) #u
#define q(r) "%f" t(r) "n"
#define s while
#define v default
#define ex exit
#define W printf
#define x fn()
#define y strcat
#define z strcpy
#define Z strlen
char*p =0 ;k *b (n,o** a){k*f
;j(_){ hh e: i* p==40? (++p,c
(d )) :( f= l( 0,
4) ,m (p ,q (% ),
f,&_), p+=_ ,f ); hh
d:f=c( e);s (1 ){ j(
*p ++ ){ hh 0: hh
41 :i f; hh 43 :*
f+=*c( e) ;g ;h 45:*f= *f-*c(
e);g;h 42 :* f= *f**c( e);g;h
47:*f /=*c (e); g; v: c(0);}
}w(1): if(p&& printf (q (( "\\"))
,* c( d) )) g; hh 0: ex (W
(x )) ;v :p =( p?y: z)(l(p
,Z(1[ a] )+ (p ?Z(p )+
1:1)) ,1 [a ]) ;b (_ -1 ,a
+1 ); g; }i 0;};fn () {n =42,p=
43 ;i "Er" "ro" t( r) "\n";}
Visual Basic.NET
Número de caracteres: 9759
Soy más un jugador de bolos a mí mismo.
NOTA: no toma paréntesis anidados en cuenta. Además, no probado, pero estoy bastante seguro de que funciona.
Imports Microsoft.VisualBasic
Imports System.Text
Imports System.Collections.Generic
Public Class Main
Public Shared Function DoArithmaticFunctionFromStringInput(ByVal MathematicalString As String) As Double
Dim numberList As New List(Of Number)
Dim operationsList As New List(Of IOperatable)
Dim currentNumber As New Number
Dim currentParentheticalStatement As New Parenthetical
Dim isInParentheticalMode As Boolean = False
Dim allCharactersInString() As Char = MathematicalString.ToCharArray
For Each mathChar In allCharactersInString
If mathChar = Number.ZERO_STRING_REPRESENTATION Then
currentNumber.UpdateNumber(mathChar)
ElseIf mathChar = Number.ONE_STRING_REPRESENTATION Then
currentNumber.UpdateNumber(mathChar)
ElseIf mathChar = Number.TWO_STRING_REPRESENTATION Then
currentNumber.UpdateNumber(mathChar)
ElseIf mathChar = Number.THREE_STRING_REPRESENTATION Then
currentNumber.UpdateNumber(mathChar)
ElseIf mathChar = Number.FOUR_STRING_REPRESENTATION Then
currentNumber.UpdateNumber(mathChar)
ElseIf mathChar = Number.FIVE_STRING_REPRESENTATION Then
currentNumber.UpdateNumber(mathChar)
ElseIf mathChar = Number.SIX_STRING_REPRESENTATION Then
currentNumber.UpdateNumber(mathChar)
ElseIf mathChar = Number.SEVEN_STRING_REPRESENTATION Then
currentNumber.UpdateNumber(mathChar)
ElseIf mathChar = Number.EIGHT_STRING_REPRESENTATION Then
currentNumber.UpdateNumber(mathChar)
ElseIf mathChar = Number.NINE_STRING_REPRESENTATION Then
currentNumber.UpdateNumber(mathChar)
ElseIf mathChar = Number.DECIMAL_POINT_STRING_REPRESENTATION Then
currentNumber.UpdateNumber(mathChar)
ElseIf mathChar = Addition.ADDITION_STRING_REPRESENTATION Then
Dim addition As New Addition
If Not isInParentheticalMode Then
operationsList.Add(addition)
numberList.Add(currentNumber)
Else
currentParentheticalStatement.AllNumbers.Add(currentNumber)
currentParentheticalStatement.AllOperators.Add(addition)
End If
currentNumber = New Number
ElseIf mathChar = Number.NEGATIVE_NUMBER_STRING_REPRESENTATION Then
If currentNumber.StringOfNumbers.Length > 0 Then
currentNumber.UpdateNumber(mathChar)
Dim subtraction As New Addition
If Not isInParentheticalMode Then
operationsList.Add(subtraction)
numberList.Add(currentNumber)
Else
currentParentheticalStatement.AllNumbers.Add(currentNumber)
currentParentheticalStatement.AllOperators.Add(subtraction)
End If
currentNumber = New Number
Else
currentNumber.UpdateNumber(mathChar)
End If
ElseIf mathChar = Multiplication.MULTIPLICATION_STRING_REPRESENTATION Then
Dim multiplication As New Multiplication
If Not isInParentheticalMode Then
operationsList.Add(multiplication)
numberList.Add(currentNumber)
Else
currentParentheticalStatement.AllNumbers.Add(currentNumber)
currentParentheticalStatement.AllOperators.Add(multiplication)
End If
currentNumber = New Number
ElseIf mathChar = Division.DIVISION_STRING_REPRESENTATION Then
Dim division As New Division
If Not isInParentheticalMode Then
operationsList.Add(division)
numberList.Add(currentNumber)
Else
currentParentheticalStatement.AllNumbers.Add(currentNumber)
currentParentheticalStatement.AllOperators.Add(division)
End If
currentNumber = New Number
ElseIf mathChar = Parenthetical.LEFT_PARENTHESIS_STRING_REPRESENTATION Then
isInParentheticalMode = True
ElseIf mathChar = Parenthetical.RIGHT_PARENTHESIS_STRING_REPRESENTATION Then
currentNumber = currentParentheticalStatement.EvaluateParentheticalStatement
numberList.Add(currentNumber)
isInParentheticalMode = False
End If
Next
Dim result As Double = 0
Dim operationIndex As Integer = 0
For Each numberOnWhichToPerformOperations As Number In numberList
result = operationsList(operationIndex).PerformOperation(result, numberOnWhichToPerformOperations)
operationIndex = operationIndex + 1
Next
Return result
End Function
Public Class Number
Public Const DECIMAL_POINT_STRING_REPRESENTATION As Char = "."
Public Const NEGATIVE_NUMBER_STRING_REPRESENTATION As Char = "-"
Public Const ZERO_STRING_REPRESENTATION As Char = "0"
Public Const ONE_STRING_REPRESENTATION As Char = "1"
Public Const TWO_STRING_REPRESENTATION As Char = "2"
Public Const THREE_STRING_REPRESENTATION As Char = "3"
Public Const FOUR_STRING_REPRESENTATION As Char = "4"
Public Const FIVE_STRING_REPRESENTATION As Char = "5"
Public Const SIX_STRING_REPRESENTATION As Char = "6"
Public Const SEVEN_STRING_REPRESENTATION As Char = "7"
Public Const EIGHT_STRING_REPRESENTATION As Char = "8"
Public Const NINE_STRING_REPRESENTATION As Char = "9"
Private _isNegative As Boolean
Public ReadOnly Property IsNegative() As Boolean
Get
Return _isNegative
End Get
End Property
Public ReadOnly Property ActualNumber() As Double
Get
Dim result As String = ""
If HasDecimal Then
If DecimalIndex = StringOfNumbers.Length - 1 Then
result = StringOfNumbers.ToString
Else
result = StringOfNumbers.Insert(DecimalIndex, DECIMAL_POINT_STRING_REPRESENTATION).ToString
End If
Else
result = StringOfNumbers.ToString
End If
If IsNegative Then
result = NEGATIVE_NUMBER_STRING_REPRESENTATION & result
End If
Return CType(result, Double)
End Get
End Property
Private _hasDecimal As Boolean
Public ReadOnly Property HasDecimal() As Boolean
Get
Return _hasDecimal
End Get
End Property
Private _decimalIndex As Integer
Public ReadOnly Property DecimalIndex() As Integer
Get
Return _decimalIndex
End Get
End Property
Private _stringOfNumbers As New StringBuilder
Public ReadOnly Property StringOfNumbers() As StringBuilder
Get
Return _stringOfNumbers
End Get
End Property
Public Sub UpdateNumber(ByVal theDigitToAppend As Char)
If IsNumeric(theDigitToAppend) Then
Me._stringOfNumbers.Append(theDigitToAppend)
ElseIf theDigitToAppend = DECIMAL_POINT_STRING_REPRESENTATION Then
Me._hasDecimal = True
Me._decimalIndex = Me._stringOfNumbers.Length
ElseIf theDigitToAppend = NEGATIVE_NUMBER_STRING_REPRESENTATION Then
Me._isNegative = Not Me._isNegative
End If
End Sub
Public Shared Function ConvertDoubleToNumber(ByVal numberThatIsADouble As Double) As Number
Dim numberResult As New Number
For Each character As Char In numberThatIsADouble.ToString.ToCharArray
numberResult.UpdateNumber(character)
Next
Return numberResult
End Function
End Class
Public MustInherit Class Operation
Protected _firstnumber As New Number
Protected _secondnumber As New Number
Public Property FirstNumber() As Number
Get
Return _firstnumber
End Get
Set(ByVal value As Number)
_firstnumber = value
End Set
End Property
Public Property SecondNumber() As Number
Get
Return _secondnumber
End Get
Set(ByVal value As Number)
_secondnumber = value
End Set
End Property
End Class
Public Interface IOperatable
Function PerformOperation(ByVal number1 As Double, ByVal number2 As Number) As Double
End Interface
Public Class Addition
Inherits Operation
Implements IOperatable
Public Const ADDITION_STRING_REPRESENTATION As String = "+"
Public Sub New()
End Sub
Public Function PerformOperation(ByVal number1 As Double, ByVal number2 As Number) As Double Implements IOperatable.PerformOperation
Dim result As Double = 0
result = number1 + number2.ActualNumber
Return result
End Function
End Class
Public Class Multiplication
Inherits Operation
Implements IOperatable
Public Const MULTIPLICATION_STRING_REPRESENTATION As String = "*"
Public Sub New()
End Sub
Public Function PerformOperation(ByVal number1 As Double, ByVal number2 As Number) As Double Implements IOperatable.PerformOperation
Dim result As Double = 0
result = number1 * number2.ActualNumber
Return result
End Function
End Class
Public Class Division
Inherits Operation
Implements IOperatable
Public Const DIVISION_STRING_REPRESENTATION As String = "/"
Public Const DIVIDE_BY_ZERO_ERROR_MESSAGE As String = "I took a lot of time to write this program. Please don't be a child and try to defile it by dividing by zero. Nobody thinks you are funny."
Public Sub New()
End Sub
Public Function PerformOperation(ByVal number1 As Double, ByVal number2 As Number) As Double Implements IOperatable.PerformOperation
If Not number2.ActualNumber = 0 Then
Dim result As Double = 0
result = number1 / number2.ActualNumber
Return result
Else
Dim divideByZeroException As New Exception(DIVIDE_BY_ZERO_ERROR_MESSAGE)
Throw divideByZeroException
End If
End Function
End Class
Public Class Parenthetical
Public Const LEFT_PARENTHESIS_STRING_REPRESENTATION As String = "("
Public Const RIGHT_PARENTHESIS_STRING_REPRESENTATION As String = ")"
Private _allNumbers As New List(Of Number)
Public Property AllNumbers() As List(Of Number)
Get
Return _allNumbers
End Get
Set(ByVal value As List(Of Number))
_allNumbers = value
End Set
End Property
Private _allOperators As New List(Of IOperatable)
Public Property AllOperators() As List(Of IOperatable)
Get
Return _allOperators
End Get
Set(ByVal value As List(Of IOperatable))
_allOperators = value
End Set
End Property
Public Sub New()
End Sub
Public Function EvaluateParentheticalStatement() As Number
Dim result As Double = 0
Dim operationIndex As Integer = 0
For Each numberOnWhichToPerformOperations As Number In AllNumbers
result = AllOperators(operationIndex).PerformOperation(result, numberOnWhichToPerformOperations)
operationIndex = operationIndex + 1
Next
Dim numberToReturn As New Number
numberToReturn = Number.ConvertDoubleToNumber(result)
Return numberToReturn
End Function
End Class
End Class
Haskell
Número de caracteres: 182
No hay intento de inteligencia, sólo algunas de compresión:. 4 líneas, 312 bytes
import Data.Char;import Text.ParserCombinators.Parsec
q=either(error.show)id.runParser t id"".filter(' '/=);t=do
s<-getState;a<-fmap read(many1$oneOf".-"<|>digit)<|>between(char '('>>setState id)(char ')'>>setState s)t
option(s a)$choice(zipWith(\c o->char c>>return(o$s a))"+-*/"[(+),(-),(*),(/)])>>=setState>>t
Y ahora, realmente entrar en el espíritu de golf, 3 líneas y 182 bytes:
q=snd.(`e`id).filter(' '/=)
e s c|[(f,h)]<-readsPrec 0 s=g h(c f);e('(':s)c=g h(c f)where(')':h,f)=e s id
g('+':h)=e h.(+);g('-':h)=e h.(-);g('*':h)=e h.(*);g('/':h)=e h.(/);g h=(,)h
despiece:
-- Strip spaces from the input, evaluate with empty accumulator,
-- and output the second field of the result.
q :: String -> Double
q = snd . flip eval id . filter (not . isSpace)
-- eval takes a string and an accumulator, and returns
-- the final value and what’s left unused from the string.
eval :: (Fractional a, Read a) => String -> (a -> a) -> (String, a)
-- If the beginning of the string parses as a number, add it to the accumulator,
-- then try to read an operator and further.
eval str accum | [(num, rest)] <- readsPrec 0 str = oper rest (accum num)
-- If the string starts parentheses, evaluate the inside with a fresh
-- accumulator, and continue after the closing paren.
eval ('(':str) accum = oper rest (accum num) where (')':rest, num) = eval str id
-- oper takes a string and current value, and tries to read an operator
-- to apply to the value. If there is none, it’s okay.
oper :: (Fractional a, Read a) => String -> a -> (String, a)
-- Handle operations by giving eval a pre-seeded accumulator.
oper ('+':str) num = eval str (num +)
oper ('-':str) num = eval str (num -)
oper ('*':str) num = eval str (num *)
oper ('/':str) num = eval str (num /)
-- If there’s no operation parsable, just return.
oper str num = (str, num)
Python
Número de caracteres: 237
Función totalmente ofuscado:
from operator import*
def e(s,l=[]):
if s:l+=list(s.replace(' ','')+')')
a=0;o=add;d=dict(zip(')*+-/',(0,mul,o,sub,div)));p=l.pop
while o:
c=p(0)
if c=='(':c=e(0)
while l[0]not in d:c+=p(0)
a=o(a,float(c));o=d[p(0)]
return a
Claro / función semi-ofuscado:
import operator
def calc(source, stack=[]):
if source:
stack += list(source.replace(' ', '') + ')')
answer = 0
ops = {
')': 0,
'*': operator.mul,
'+': operator.add,
'-': operator.sub,
'/': operator.div,
}
op = operator.add
while op:
cur = stack.pop(0)
if cur == '(':
cur = calc(0)
while stack[0] not in ops:
cur += stack.pop(0)
answer = op(answer, float(cur))
op = ops[stack.pop(0)]
return answer
Fortran 77 (dialecto gfortran, ahora con soporte g77)
Número de caracteres: 2059
versión ofuscado:
function e(c)
character*99 c
character b
real f(24)
integer i(24)
nf=0
ni=0
20 nf=kf(0.0,nf,f)
ni=ki(43,ni,i)
30 if (isp(c).eq.1) goto 20
h=fr(c)
31 g=fp(nf,f)
j=ip(ni,i)
select case(j)
case (40)
goto 20
case (42)
d=g*h
case (43)
d=g+h
case (45)
d=g-h
case (47)
d=g/h
end select
50 nf=kf(d,nf,f)
60 j=nop(c)
goto (20, 70, 75, 75, 60, 75, 60, 75) (j-39)
65 e=fp(nf,f)
return
70 h=fp(nf,f)
goto 31
75 ni=ki(j,ni,i)
goto 30
end
function kf(v,n,f)
real f(24)
kf=n+1
f(n+1)=v
return
end
function ki(j,n,i)
integer i(24)
ki=n+1
i(n+1)=j
return
end
function fp(n,f)
real f(24)
fp=f(n)
n=n-1
return
end
function ip(n,i)
integer i(24)
ip=i(n)
n=n-1
return
end
function nop(s)
character*99 s
l=1
do while(s(l:l).eq." ".and.l.lt.99)
l=l+1
enddo
nop=ichar(s(l:l))
s(l:l)=" "
return
end
function isp(s)
character*99 s
isp=0
l=1
do while(s(l:l).eq." ".and.l.lt.99)
l=l+1
enddo
isp=41-ichar(s(l:l))
if (isp.eq.1) s(l:l)=" "
return
end
function fr(s)
character*99 s
m=1
n=1
i=1
do while(i.le.99)
j=ichar(s(i:i))
if (j.eq.32) goto 90
if (j.ge.48.and.j.lt.58) goto 89
if (j.eq.43.or.j.eq.45) goto (89,80) m
if (j.eq.46) goto (83,80) n
80 exit
83 n=2
89 m=2
90 i=i+1
enddo
read(s(1:i-1),*) fr
do 91 j=1,i-1
s(j:j)=" "
91 continue
return
end
versión Clear: (3340 caracteres con el andamio)
program infixeval
character*99 c
do while (.true.)
do 10 i=1,99
c(i:i)=" "
10 continue
read(*,"(A99)") c
f=e(c)
write(*,*)f
enddo
end
function e(c)
character*99 c
character b
real f(24) ! value stack
integer i(24) ! operator stack
nf=0 ! number of items on the value stack
ni=0 ! number of items on the operator stack
20 nf=pushf(0.0,nf,f)
ni=pushi(43,ni,i) ! ichar(+) = 43
D write (*,*) "'",c,"'"
30 if (isp(c).eq.1) goto 20
h=fr(c)
D write (*,*) "'",c,"'"
31 g=fpop(nf,f)
j=ipop(ni,i)
D write(*,*) "Opperate ",g," ",char(j)," ",h
select case(j)
case (40)
goto 20
case (42) ! "*"
d=g*h
case (43) ! "+"
d=g+h
case (45) ! "-"
d=g-h
case (47) ! "*"
d=g/h
end select
50 nf=pushf(d,nf,f)
60 j=nop(c)
D write(*,*) "Got op: ", char(j)
goto (20, 70, 75, 75, 60, 75, 60, 75) (j-39)
65 e=fpop(nf,f)
return
70 h=fpop(nf,f) ! Encountered a "("
goto 31
75 ni=pushi(j,ni,i)
goto 30
end
c push onto a real stack
c OB as kf
function pushf(v,n,f)
real f(24)
pushf=n+1
f(n+1)=v
D write(*,*) "Push ", v
return
end
c push onto a integer stack
c OB as ki
function pushi(j,n,i)
integer i(24)
pushi=n+1
i(n+1)=j
D write(*,*) "Push ", char(j)
return
end
c pop from real stack
c OB as fp
function fpop(n,f)
real f(24)
fpop=f(n)
n=n-1
D write (*,*) "Pop ", fpop
return
end
c pop from integer stack
c OB as ip
function ipop(n,i)
integer i(24)
ipop=i(n)
n=n-1
D write (*,*) "Pop ", char(ipop)
return
end
c Next OPerator: returns the next nonws character, and removes it
c from the string
function nop(s)
character*99 s
l=1
do while(s(l:l).eq." ".and.l.lt.99)
l=l+1
enddo
nop=ichar(s(l:l))
s(l:l)=" "
return
end
c IS an open Paren: return 1 if the next non-ws character is "("
c (also overwrite it with a space. Otherwise return not 1
function isp(s)
character*99 s
isp=0
l=1
do while(s(l:l).eq." ".and.l.lt.99)
l=l+1
enddo
isp=41-ichar(s(l:l))
if (isp.eq.1) s(l:l)=" "
return
end
c Float Read: return the next real number in the string and removes the
c character
function fr(s)
character*99 s
m=1 ! No sign (Minus or plus) so far
n=1 ! No decimal so far
i=1
do while(i.le.99)
j=ichar(s(i:i))
if (j.eq.32) goto 90 ! skip spaces
if (j.ge.48.and.j.lt.58) goto 89
if (j.eq.43.or.j.eq.45) goto (89,80) m
if (j.eq.46) goto (83,80) n
c not part of a number
80 exit
83 n=2
89 m=2
90 i=i+1
enddo
read(s(1:i-1),*) fr
do 91 j=1,i-1
s(j:j)=" "
91 continue
return
end
Notas Esta versión editada es bastante más mal que mi primer intento. Mismo algoritmo, pero ahora en línea con una maraña horrible gotos. He deshice de los co-rutinas, pero ahora estoy usando un par de sabores de ramas computados. Todo comprobación de errores y presentación de informes ha sido eliminado, pero esta versión serán en silencio recuperarse de algunas clases de personajes inesperados en la entrada. Esta versión también compila con G77.
Los límites primarios están todavía de Fortran formato rígido, palabras clave largas y ubicuos, y primitivas simples.
C99
Número de caracteres: 239 (véase más adelante para 209 )
función comprimido:
#define S while(*e==32)++e
#define F float
F strtof();char*e;F v();F g(){S;return*e++-40?strtof(e-1,&e):v();}F v(){F b,a=g();for(;;){S;F o=*e++;if(!o|o==41)return a;b=g();a=o==43?a+b:o==45?a-b:o==42?a*b:a/b;}}F f(char*x){e=x;return v();}
Función descomprimido:
float strtof();
char* e;
float v();
float g() {
while (*e == ' ') ++e;
return *e++ != '(' ? strtof(e-1, &e) : v();
}
float v() {
float b, a = g();
for (;;) {
while (*e == ' ') ++e;
float op = *e++;
if (op == 0 || op == ')') return a;
b = g();
a = op == '+' ? a + b : op == '-' ? a - b : op == '*' ? a * b : a / b;
}
}
float eval(char* x) {
e = x;
return v();
}
Función no es reentrante.
EDITAR de Chris Lutz : No me gusta pisotear código de otro hombre, pero aquí es un 209 -character versión:
#define S for(;*e==32;e++)
#define X (*e++-40?strtof(e-1,&e):v())
float strtof();char*e;float v(){float o,a=X;for(;;){S;o=*e++;if(!o|o==41)return a;S;a=o-43?o-45?o-42?a/X:a*X:a-X:a+X;}}
#define f(x) (e=x,v())
lectura mecánica (bueno, no realmente muy fácil de leer, pero descomprimido):
float strtof();
char *e;
float v() {
float o, a = *e++ != '(' ? strtof(e - 1, &e) : v();
for(;;) {
for(; *e == ' '; e++);
o = *e++;
if(o == 0 || o==')') return a;
for(; *e == ' '; e++);
// I have no idea how to properly indent nested conditionals
// and this is far too long to fit on one line.
a = o != '+' ?
o != '-' ?
o != '*' ?
a / (*e++ != '(' ? strtof(e - 1, &e) : v()) :
a * (*e++ != '(' ? strtof(e - 1, &e) : v()) :
a - (*e++ != '(' ? strtof(e - 1, &e) : v()) :
a + (*e++ != '(' ? strtof(e - 1, &e) : v());
}
}
#define f(x) (e = x, v())
Sí, f() es una macro, no una función, pero funciona. La versión legible tiene algo de la lógica reescrito pero no reordenados (como o != '+' en lugar de o - '+'), pero por lo demás sólo una versión sangría (y preprocesado) de la otra. Sigo tratando de simplificar la parte if(!o|o==41)return a; en el bucle for(), pero nunca hace que sea más corto. Todavía creo que se puede hacer, pero he terminado de jugar al golf. Si trabajo sobre esta cuestión más, que será en el lenguaje que no debe ser nombrado .
Common Lisp
(SBCL)
Número de caracteres: 251
(defun g(e)(if(numberp e)e(let((m (g (pop e)))(o(loop for x in e by #'cddr collect x))(n(loop for x in (cdr e)by #'cddr collect (g x))))(mapcar(lambda(x y)(setf m(apply x(list m y))))o n)m)))(defun w(e)(g(read-from-string(concatenate'string"("e")"))))
versión adecuada (387 caracteres):
(defun wrapper (exp) (golf-eval (read-from-string (concatenate 'string "(" exp ")"))))
(defun golf-eval (exp)
(if (numberp exp)
exp
(let ((mem (golf-eval (pop exp)))
(op-list (loop for x in exp by #'cddr collect x))
(num-list (loop for x in (cdr exp) by #'cddr collect (golf-eval x))))
(mapcar (lambda (x y) (setf mem (apply x (list mem y)))) op-list num-list)
mem)))
La entrada es w() forma, que toma un argumento de serie. Se utiliza el truco que nums / operandos y los operadores están en el patrón N O N O N ... y de forma recursiva evalúa todos los operandos, y por lo tanto conseguir que anidan muy barato. ;)
JavaScript (No es compatible IE)
Número de caracteres: 268/260
Función totalmente ofuscado:
function e(x){x=x.replace(/ /g,'')+')'
function P(n){return x[0]=='('?(x=x.substr(1),E()):(n=/^[-+]?[\d.]+/(x)[0],x=x.substr(n.length),+n)}function E(a,o,b){a=P()
for(;;){o=x[0]
x=x.substr(1)
if(o==')')return a
b=P()
a=o=='+'?a+b:o=='-'?a-b:o=='*'?a*b:a/b}}return E()}
o, en JavaScript 1.8 (Firefox 3), se puede ahorrar unos cuantos caracteres mediante el uso de cierres de expresión:
e=function(x,P,E)(x=x.replace(/ /g,'')+')',P=function(n)(x[0]=='('?(x=x.substr(1),E()):(n=/^[-+]?[\d.]+/(x)[0],x=x.substr(n.length),+n)),E=function(a,o,b){a=P()
for(;;){o=x[0]
x=x.substr(1)
if(o==')')return a
b=P()
a=o=='+'?a+b:o=='-'?a-b:o=='*'?a*b:a/b}},E())
Claro / función semi-ofuscado:
function evaluate(x) {
x = x.replace(/ /g, "") + ")";
function primary() {
if (x[0] == '(') {
x = x.substr(1);
return expression();
}
var n = /^[-+]?\d*\.?\d*/.exec(x)[0];
x = x.substr(n.length);
return +n;
}
function expression() {
var a = primary();
for (;;) {
var operator = x[0];
x = x.substr(1);
if (operator == ')') {
return a;
}
var b = primary();
a = (operator == '+') ? a + b :
(operator == '-') ? a - b :
(operator == '*') ? a * b :
a / b;
}
}
return expression();
}
Ninguna de las versiones funcionará en IE, ya que utilizan subíndices estilo-matriz en la cadena. Si reemplaza dos apariciones de x[0] con x.charAt(0), el primero de ellos debería funcionar en todas partes.
corté algunos caracteres más desde la primera versión girando variables en los parámetros de función y la sustitución de otra sentencia if con el operador condicional.
C # con Regex Love
Número de caracteres: 384
totalmente ofuscado:
float E(string i){i=i.Replace(" ","");Regex b=new Regex(@"\((?>[^()]+|\((?<D>)|\)(?<-D>))*(?(D)(?!))\)");i=b.Replace(i,m=>Eval(m.Value.Substring(1,m.Length-2)).ToString());float r=0;foreach(Match m in Regex.Matches(i,@"(?<=^|\D)-?[\d.]+")){float f=float.Parse(m.Value);if(m.Index==0)r=f;else{char o=i[m.Index-1];if(o=='+')r+=f;if(o=='-')r-=f;if(o=='*')r*=f;if(o=='/')r/=f;}}return r;}
No-ofuscado:
private static float Eval(string input)
{
input = input.Replace(" ", "");
Regex balancedMatcher = new Regex(@"\(
(?>
[^()]+
|
\( (?<Depth>)
|
\) (?<-Depth>)
)*
(?(Depth)(?!))
\)", RegexOptions.IgnorePatternWhitespace);
input = balancedMatcher.Replace(input, m => Eval(m.Value.Substring(1, m.Length - 2)).ToString());
float result = 0;
foreach (Match m in Regex.Matches(input, @"(?<=^|\D)-?[\d.]+"))
{
float floatVal = float.Parse(m.Value);
if (m.Index == 0)
{
result = floatVal;
}
else
{
char op = input[m.Index - 1];
if (op == '+') result += floatVal;
if (op == '-') result -= floatVal;
if (op == '*') result *= floatVal;
if (op == '/') result /= floatVal;
}
}
return result;
}
Aprovecha las expresiones regulares de .NET característica de grupo equilibrio .
PHP
Número de caracteres: 284
ofuscado:
function f($m){return c($m[1]);}function g($n,$m){$o=$m[0];$m[0]=' ';return$o=='+'?$n+$m:($o=='-'?$n-$m:($o=='*'?$n*$m:$n/$m));}function c($s){while($s!=($t=preg_replace_callback('/\(([^()]*)\)/',f,$s)))$s=$t;preg_match_all('![-+/*].*?[\d.]+!',"+$s",$m);return array_reduce($m[0],g);}
legibles:
function callback1($m) {return c($m[1]);}
function callback2($n,$m) {
$o=$m[0];
$m[0]=' ';
return $o=='+' ? $n+$m : ($o=='-' ? $n-$m : ($o=='*' ? $n*$m : $n/$m));
}
function c($s){
while ($s != ($t = preg_replace_callback('/\(([^()]*)\)/','callback1',$s))) $s=$t;
preg_match_all('![-+/*].*?[\d.]+!', "+$s", $m);
return array_reduce($m[0], 'callback2');
}
$str = ' 2.45/8.5 * -9.27 + ( 5 * 0.0023 ) ';
var_dump(c($str));
# float(-2.66044117647)
debería funcionar con cualquier entrada válida (incluidos los números negativos y espacios en blanco arbitrario)
SQL (SQL Server 2008)
Número de caracteres: 4202
Función totalmente ofuscado:
WITH Input(id,str)AS(SELECT 1,'1 + 3 / -8'UNION ALL SELECT 2,'2*3*4*5+99'UNION ALL SELECT 3,'4 * (9 - 4)/ (2 * 6 - 2)+ 8'UNION ALL SELECT 4,'1 + ((123 * 3 - 69)/ 100)'UNION ALL SELECT 5,'2.45/8.5*9.27+(5*0.0023)'),Separators(i,ch,str_src,priority)AS(SELECT 1,'-',1,1UNION ALL SELECT 2,'+',1,1UNION ALL SELECT 3,'*',1,1UNION ALL SELECT 4,'/',1,1UNION ALL SELECT 5,'(',0,0UNION ALL SELECT 6,')',0,0),SeparatorsStrSrc(str,i)AS(SELECT CAST('['AS varchar(max)),0UNION ALL SELECT str+ch,SSS.i+1FROM SeparatorsStrSrc SSS INNER JOIN Separators S ON SSS.i=S.i-1WHERE str_src<>0),SeparatorsStr(str)AS(SELECT str+']'FROM SeparatorsStrSrc WHERE i=(SELECT COUNT(*)FROM Separators WHERE str_src<>0)),ExprElementsSrc(id,i,tmp,ele,pre_ch,input_str)AS(SELECT id,1,CAST(LEFT(str,1)AS varchar(max)),CAST(''AS varchar(max)),CAST(' 'AS char(1)),SUBSTRING(str,2,LEN(str))FROM Input UNION ALL SELECT id,CASE ele WHEN''THEN i ELSE i+1 END,CAST(CASE WHEN LEFT(input_str,1)=' 'THEN''WHEN tmp='-'THEN CASE WHEN pre_ch LIKE(SELECT str FROM SeparatorsStr)THEN tmp+LEFT(input_str,1)ELSE LEFT(input_str,1)END WHEN LEFT(input_str,1)IN(SELECT ch FROM Separators)OR tmp IN(SELECT ch FROM Separators)THEN LEFT(input_str,1)ELSE tmp+LEFT(input_str,1)END AS varchar(max)),CAST(CASE WHEN LEFT(input_str,1)=' 'THEN tmp WHEN LEFT(input_str,1)='-'THEN CASE WHEN tmp IN(SELECT ch FROM Separators)THEN tmp ELSE''END WHEN LEFT(input_str,1)IN(SELECT ch FROM Separators)OR tmp IN(SELECT ch FROM Separators)THEN CASE WHEN tmp='-'AND pre_ch LIKE(SELECT str FROM SeparatorsStr)THEN''ELSE tmp END ELSE''END AS varchar(max)),CAST(LEFT(ele,1)AS char(1)),SUBSTRING(input_str,2,LEN(input_str))FROM ExprElementsSrc WHERE input_str<>''OR tmp<>''),ExprElements(id,i,ele)AS(SELECT id,i,ele FROM ExprElementsSrc WHERE ele<>''),Scanner(id,i,val)AS(SELECT id,i,CAST(ele AS varchar(max))FROM ExprElements WHERE ele<>''UNION ALL SELECT id,MAX(i)+1,NULL FROM ExprElements GROUP BY id),Operator(op,priority)AS(SELECT ch,priority FROM Separators WHERE priority<>0),Calc(id,c,i,pop_count,s0,s1,s2,stack,status)AS(SELECT Scanner.id,1,1,0,CAST(scanner.val AS varchar(max)),CAST(NULL AS varchar(max)),CAST(NULL AS varchar(max)),CAST(''AS varchar(max)),CAST('init'AS varchar(max))FROM Scanner WHERE Scanner.i=1UNION ALL SELECT Calc.id,Calc.c+1,Calc.i,3,NULL,NULL,NULL,CASE Calc.s1 WHEN'+'THEN CAST(CAST(Calc.s2 AS real)+CAST(Calc.s0 AS real)AS varchar(max))WHEN'-'THEN CAST(CAST(Calc.s2 AS real)-CAST(Calc.s0 AS real)AS varchar(max))WHEN'*'THEN CAST(CAST(Calc.s2 AS real)*CAST(Calc.s0 AS real)AS varchar(max))WHEN'/'THEN CAST(CAST(Calc.s2 AS real)/CAST(Calc.s0 AS real)AS varchar(max))ELSE NULL END+' '+stack,CAST('calc '+Calc.s1 AS varchar(max))FROM Calc INNER JOIN Scanner NextVal ON Calc.id=NextVal.id AND Calc.i+1=NextVal.i WHERE Calc.pop_count=0AND ISNUMERIC(Calc.s2)=1AND Calc.s1 IN(SELECT op FROM Operator)AND ISNUMERIC(Calc.s0)=1AND(SELECT priority FROM Operator WHERE op=Calc.s1)>=COALESCE((SELECT priority FROM Operator WHERE op=NextVal.val),0)UNION ALL SELECT Calc.id,Calc.c+1,Calc.i,3,NULL,NULL,NULL,s1+' '+stack,CAST('paren'AS varchar(max))FROM Calc WHERE pop_count=0AND s2='('AND ISNUMERIC(s1)=1AND s0=')'UNION ALL SELECT Calc.id,Calc.c+1,Calc.i,Calc.pop_count-1,s1,s2,CASE WHEN LEN(stack)>0THEN SUBSTRING(stack,1,CHARINDEX(' ',stack)-1)ELSE NULL END,CASE WHEN LEN(stack)>0THEN SUBSTRING(stack,CHARINDEX(' ',stack)+1,LEN(stack))ELSE''END,CAST('pop'AS varchar(max))FROM Calc WHERE Calc.pop_count>0UNION ALL SELECT Calc.id,Calc.c+1,Calc.i+1,Calc.pop_count,CAST(NextVal.val AS varchar(max)),s0,s1,coalesce(s2,'')+' '+stack,cast('read'as varchar(max))FROM Calc INNER JOIN Scanner NextVal ON Calc.id=NextVal.id AND Calc.i+1=NextVal.i WHERE NextVal.val IS NOT NULL AND Calc.pop_count=0AND((Calc.s0 IS NULL OR calc.s1 IS NULL OR calc.s2 IS NULL)OR NOT(ISNUMERIC(Calc.s2)=1AND Calc.s1 IN(SELECT op FROM Operator)AND ISNUMERIC(calc.s0)=1AND (SELECT priority FROM Operator WHERE op=Calc.s1)>=COALESCE((SELECT priority FROM Operator WHERE op=NextVal.val),0))AND NOT(s2='('AND ISNUMERIC(s1)=1AND s0=')')))SELECT Calc.id,Input.str,Calc.s0 AS result FROM Calc INNER JOIN Input ON Calc.id=Input.id WHERE Calc.c=(SELECT MAX(c)FROM Calc calc2 WHERE Calc.id=Calc2.id)ORDER BY id
Claro / función semi-ofuscado:
WITH
Input(id, str) AS (
SELECT 1, '1 + 3 / -8'
UNION ALL SELECT 2, '2*3*4*5+99'
UNION ALL SELECT 3, '4 * (9 - 4) / (2 * 6 - 2) + 8'
UNION ALL SELECT 4, '1 + ((123 * 3 - 69) / 100)'
UNION ALL SELECT 5, '2.45/8.5*9.27+(5*0.0023)'
)
, Separators(i, ch, str_src, priority) AS (
SELECT 1, '-', 1, 1
UNION ALL SELECT 2, '+', 1, 1
UNION ALL SELECT 3, '*', 1, 1
UNION ALL SELECT 4, '/', 1, 1
UNION ALL SELECT 5, '(', 0, 0
UNION ALL SELECT 6, ')', 0, 0
)
, SeparatorsStrSrc(str, i) AS (
SELECT CAST('[' AS varchar(max)), 0
UNION ALL
SELECT
str + ch
, SSS.i + 1
FROM
SeparatorsStrSrc SSS
INNER JOIN Separators S ON SSS.i = S.i - 1
WHERE
str_src <> 0
)
, SeparatorsStr(str) AS (
SELECT str + ']' FROM SeparatorsStrSrc
WHERE i = (SELECT COUNT(*) FROM Separators WHERE str_src <> 0)
)
, ExprElementsSrc(id, i, tmp, ele, pre_ch, input_str) AS (
SELECT
id
, 1
, CAST(LEFT(str, 1) AS varchar(max))
, CAST('' AS varchar(max))
, CAST(' ' AS char(1))
, SUBSTRING(str, 2, LEN(str))
FROM
Input
UNION ALL
SELECT
id
, CASE ele
WHEN '' THEN i
ELSE i + 1
END
, CAST(
CASE
WHEN LEFT(input_str, 1) = ' '
THEN ''
WHEN tmp = '-'
THEN CASE
WHEN pre_ch LIKE (SELECT str FROM SeparatorsStr)
THEN tmp + LEFT(input_str, 1)
ELSE LEFT(input_str, 1)
END
WHEN LEFT(input_str, 1) IN (SELECT ch FROM Separators)
OR
tmp IN (SELECT ch FROM Separators)
THEN LEFT(input_str, 1)
ELSE tmp + LEFT(input_str, 1)
END
AS varchar(max))
, CAST(
CASE
WHEN LEFT(input_str, 1) = ' '
THEN tmp
WHEN LEFT(input_str, 1) = '-'
THEN CASE
WHEN tmp IN (SELECT ch FROM Separators)
THEN tmp
ELSE ''
END
WHEN LEFT(input_str, 1) IN (SELECT ch FROM Separators)
OR
tmp IN (SELECT ch FROM Separators)
THEN CASE
WHEN tmp = '-' AND pre_ch LIKE (SELECT str FROM SeparatorsStr)
THEN ''
ELSE tmp
END
ELSE ''
END
AS varchar(max))
, CAST(LEFT(ele, 1) AS char(1))
, SUBSTRING(input_str, 2, LEN(input_str))
FROM
ExprElementsSrc
WHERE
input_str <> ''
OR
tmp <> ''
)
, ExprElements(id, i, ele) AS (
SELECT
id
, i
, ele
FROM
ExprElementsSrc
WHERE
ele <> ''
)
, Scanner(id, i, val) AS (
SELECT
id
, i
, CAST(ele AS varchar(max))
FROM
ExprElements
WHERE
ele <> ''
UNION ALL
SELECT
id
, MAX(i) + 1
, NULL
FROM
ExprElements
GROUP BY
id
)
, Operator(op, priority) AS (
SELECT
ch
, priority
FROM
Separators
WHERE
priority <> 0
)
, Calc(id, c, i, pop_count, s0, s1, s2, stack, status) AS (
SELECT
Scanner.id
, 1
, 1
, 0
, CAST(scanner.val AS varchar(max))
, CAST(NULL AS varchar(max))
, CAST(NULL AS varchar(max))
, CAST('' AS varchar(max))
, CAST('init' AS varchar(max))
FROM
Scanner
WHERE
Scanner.i = 1
UNION ALL
SELECT
Calc.id
, Calc.c + 1
, Calc.i
, 3
, NULL
, NULL
, NULL
, CASE Calc.s1
WHEN '+' THEN CAST(CAST(Calc.s2 AS real) + CAST(Calc.s0 AS real) AS varchar(max))
WHEN '-' THEN CAST(CAST(Calc.s2 AS real) - CAST(Calc.s0 AS real) AS varchar(max))
WHEN '*' THEN CAST(CAST(Calc.s2 AS real) * CAST(Calc.s0 AS real) AS varchar(max))
WHEN '/' THEN CAST(CAST(Calc.s2 AS real) / CAST(Calc.s0 AS real) AS varchar(max))
ELSE NULL
END
+ ' '
+ stack
, CAST('calc ' + Calc.s1 AS varchar(max))
FROM
Calc
INNER JOIN Scanner NextVal ON Calc.id = NextVal.id
AND Calc.i + 1 = NextVal.i
WHERE
Calc.pop_count = 0
AND ISNUMERIC(Calc.s2) = 1
AND Calc.s1 IN (SELECT op FROM Operator)
AND ISNUMERIC(Calc.s0) = 1
AND (SELECT priority FROM Operator WHERE op = Calc.s1)
>= COALESCE((SELECT priority FROM Operator WHERE op = NextVal.val), 0)
UNION ALL
SELECT
Calc.id
, Calc.c + 1
, Calc.i
, 3
, NULL
, NULL
, NULL
, s1 + ' ' + stack
, CAST('paren' AS varchar(max))
FROM
Calc
WHERE
pop_count = 0
AND s2 = '('
AND ISNUMERIC(s1) = 1
AND s0 = ')'
UNION ALL
SELECT
Calc.id
, Calc.c + 1
, Calc.i
, Calc.pop_count - 1
, s1
, s2
, CASE
WHEN LEN(stack) > 0
THEN SUBSTRING(stack, 1, CHARINDEX(' ', stack) - 1)
ELSE NULL
END
, CASE
WHEN LEN(stack) > 0
THEN SUBSTRING(stack, CHARINDEX(' ', stack) + 1, LEN(stack))
ELSE ''
END
, CAST('pop' AS varchar(max))
FROM
Calc
WHERE
Calc.pop_count > 0
UNION ALL
SELECT
Calc.id
, Calc.c + 1
, Calc.i + 1
, Calc.pop_count
, CAST(NextVal.val AS varchar(max))
, s0
, s1
, coalesce(s2, '') + ' ' + stack
, cast('read' as varchar(max))
FROM
Calc
INNER JOIN Scanner NextVal ON Calc.id = NextVal.id
AND Calc.i + 1 = NextVal.i
WHERE
NextVal.val IS NOT NULL
AND Calc.pop_count = 0
AND (
(Calc.s0 IS NULL or calc.s1 is null or calc.s2 is null)
OR
NOT(
ISNUMERIC(Calc.s2) = 1
AND Calc.s1 IN (SELECT op FROM Operator)
AND ISNUMERIC(calc.s0) = 1
AND (SELECT priority FROM Operator WHERE op = Calc.s1)
>= COALESCE((SELECT priority FROM Operator WHERE op = NextVal.val), 0)
)
AND NOT(s2 = '(' AND ISNUMERIC(s1) = 1 AND s0 = ')')
)
)
SELECT
Calc.id
, Input.str
, Calc.s0 AS result
FROM
Calc
INNER JOIN Input ON Calc.id = Input.id
WHERE
Calc.c = (SELECT MAX(c) FROM Calc calc2
WHERE Calc.id = Calc2.id)
ORDER BY
id
No es más corto. Pero creo que es muy flexible para SQL. Es fácil añadir nuevos operadores. Es fácil cambiar la prioridad de los operadores.
F #
Número de caracteres: 327
OP estaba buscando una versión # F, aquí está. Se puede hacer mucho más agradable ya que estoy abusando de un ref aquí para salvar caracteres. Se ocupa de la mayoría de cosas tales como - (1,0) , 3 - -3 e incluso 0 -. 0.5 etc
let g s=
let c=ref[for x in System.Text.RegularExpressions.Regex.Matches(s,"[0-9.]+|[^\s]")->x.Value]
let rec e v=if (!c).IsEmpty then v else
let h=(!c).Head
c:=(!c).Tail
match h with|"("->e(e 0.0)|")"->v|"+"->e(v+(e 0.0))|"-"->e(v-(e 0.0))|"/"->e(v/(e 0.0))|"*"->e(v*(e 0.0))|x->float x
e(e 0.0)
J
Número de caracteres: 208
Después del comentario Jeff Moser 's, me di cuenta de que me había olvidado por completo de esta lengua ... No soy un experto , pero mi primer intento fue bastante bien.
e=:>@{:@f@;:
f=:''&(4 :0)
'y x'=.x g y
while.($y)*-.')'={.>{.y do.'y x'=.(x,>(-.'/'={.>{.y){('%';y))g}.y end.y;x
)
g=:4 :0
z=.>{.y
if.z='('do.'y z'=.f}.y else.if.z='-'do.z=.'_',>{.}.y end.end.(}.y);":".x,z
)
Es un poco molesto, tener que asignar x/y y -z en x%y y _z de J. Sin eso, tal vez el 50% de este código podría desaparecer.
Python (sin importar nada)
Número de caracteres: 222
He ganado muchos trucos de respuesta de Dave, pero me las arreglé para cortar algunos caracteres más.
def e(s,l=0,n=0,f='+'):
if s:l=[c for c in s+')'if' '!=c]
while f!=')':
p=l.pop;m=p(0)
if m=='(':m=e(0,l)
while l[0]not in'+-*/)':m+=p(0)
m=float(m);n={'+':n+m,'-':n-m,'*':n*m,'/':n/(m or 1)}[f];f=p(0)
return n
versión comentada:
def evaluate(stringexpr, listexpr=0, n=0, f_operation='+'):
# start out as taking 0 + the expression... (or could use 1 * ;)
# We'll prefer to keep the expression as a list of characters,
# so we can use .pop(0) to eat up the expression as we go.
if stringexpr:
listexpr = [c for c in stringexpr+')' if c!=' ']
# use ')' as sentinel to return the answer
while f_operation != ')':
m_next = listexpr.pop(0)
if m_next == '(':
# lists are passed by reference, so this call will eat the (parexp)
m_next = evaluate(None, listexpr)
else:
# rebuild any upcoming numeric chars into a string
while listexpr[0] not in '+-*/)':
m_next += listexpr.pop(0)
# Update n as the current answer. But never divide by 0.
m = float(m_next)
n = {'+':n+m, '-':n-m, '*':n*m, '/':n/(m or 1)}[f_operation]
# prepare the next operation (known to be one of '+-*/)')
f_operation = listexpr.pop(0)
return n
C #
Número de caracteres: 403
Así que aquí está mi solución ... todavía estoy esperando a alguien para enviar una en C # que se puede superar. (Marc Gravell estaba cerca, y sin embargo puede hacerlo mejor que yo después de un poco más de retoques.)
Función totalmente ofuscado:
float e(string x){float v=0;if(float.TryParse(x,out v))return v;x+=';';int t=0;
char o,s='?',p='+';float n=0;int l=0;for(int i=0;i<x.Length;i++){o=s;if(
x[i]!=' '){s=x[i];if(char.IsDigit(x[i])|s=='.'|(s=='-'&o!='1'))s='1';if(s==')')
l--;if(s!=o&l==0){if(o=='1'|o==')'){n=e(x.Substring(t,i-t));if(p=='+')v+=n;
if(p=='-')v-=n;if(p=='*')v*=n;if(p=='/')v/=n;p=x[i];}t=i;if(s=='(')t++;}
if(s=='(')l++;}}return v;}
función semi-ofuscado:
public static float Eval(string expr)
{
float val = 0;
if (float.TryParse(expr, out val))
return val;
expr += ';';
int tokenStart = 0;
char oldState, state = '?', op = '+';
float num = 0;
int level = 0;
for (int i = 0; i < expr.Length; i++)
{
oldState = state;
if (expr[i] != ' ')
{
state = expr[i];
if (char.IsDigit(expr[i]) || state == '.' ||
(state == '-' && oldState != '1'))
state = '1';
if (state == ')')
level--;
if (state != oldState && level == 0)
{
if (oldState == '1' || oldState == ')')
{
num = Eval(expr.Substring(tokenStart, i - tokenStart));
if (op == '+') val += num;
if (op == '-') val -= num;
if (op == '*') val *= num;
if (op == '/') val /= num;
op = expr[i];
}
tokenStart = i;
if (state == '(')
tokenStart++;
}
if (state == '(')
level++;
}
}
return val;
}
Nada demasiado inteligente pasando aquí, que parece woul. La función Sin embargo, tiene la ventaja de ser re-entrante (es decir thread-safe).
También estoy razonablemente satisfecho con el número de caracteres, dado que está escrito en C # (XHTML 1.0, 2.0 y 3.0 creo).
Aquí viene otro:
Shell script (usando sed + awk)
Número de caracteres: 295
ofuscado:
e(){ a="$1";while echo "$a"|grep -q \(;do eval "`echo "$a"|sed 's/\(.*\)(\([^()]*\))\(.*\)/a="\1\`e \"\2\"\`\3"/'`";done; echo "$a"|sed 's/\([-+*/]\) *\(-\?\) */ \1 \2/g'|awk '{t=$1;for(i=2;i<NF;i+=2){j=$(i+1);if($i=="+") t+=j; else if($i=="-") t-=j; else if($i=="*") t*=j; else t/=j}print t}';}
legible
e () {
a="$1"
# Recursively process bracket-expressions
while echo "$a"|grep -q \(; do
eval "`echo "$a"|
sed 's/\(.*\)(\([^()]*\))\(.*\)/a="\1\`e \"\2\"\`\3"/'`"
done
# Compute expression without brackets
echo "$a"|
sed 's/\([-+*/]\) *\(-\?\) */ \1 \2/g'|
awk '{
t=$1;
for(i=2;i<NF;i+=2){
j=$(i+1);
if($i=="+") t+=j;
else if($i=="-") t-=j;
else if($i=="*") t*=j;
else t/=j
}
print t
}'
}
Prueba:
str=' 2.45 / 8.5 * 9.27 + ( 5 * 0.0023 ) '
echo "$str"|bc -l
e "$str"
Resultados:
2.68344117647058823526
2.68344
MATLAB (v7.8.0)
Número de caracteres: 239
Función ofuscado:
function [v,s]=m(s),r=1;while s,s=regexp(s,'( ?)(?(1)-?)[\.\d]+|\S','match');c=s{end};s=[s{1:end-1}];if any(c>47),v=str2num(c);elseif c>41,[l,s]=m(s);v=[l/v l*v l+v l-v];v=v(c=='/*+-');if r,break;end;r=1;elseif c<41,break;end;r=r&c~=41;end
Borrar la función (er):
function [value,str] = math(str)
returnNow = 1;
while str,
str = regexp(str,'( ?)(?(1)-?)[\.\d]+|\S','match');
current = str{end};
str = [str{1:end-1}];
if any(current > 47),
value = str2num(current);
elseif current > 41,
[leftValue,str] = math(str);
value = [leftValue/value leftValue*value ...
leftValue+value leftValue-value];
value = value(current == '/*+-');
if returnNow,
break;
end;
returnNow = 1;
elseif current < 41,
break;
end;
returnNow = returnNow & (c ~= 41);
end
Prueba:
>> [math('1 + 3 / -8'); ...
math('2*3*4*5+99'); ...
math('4 * (9 - 4) / (2 * 6 - 2) + 8'); ...
math('1 + ((123 * 3 - 69) / 100)'); ...
math('2.45/8.5*9.27+(5*0.0023)')]
ans =
-0.5000
219.0000
10.0000
4.0000
2.6834
Sinopsis: Una mezcla de expresiones regulares y recursión. Más o menos lo mejor que he podido hacer hasta ahora, sin trampas y el uso de EVAL.
Rubí
Número de caracteres: 170
ofuscado:
def s(x)
while x.sub!(/\(([^\(\)]*?)\)/){s($1)}
x.gsub!('--','')
end
while x.sub!(/(-?[\d.]+)[ ]*([+\-*\/])[ ]*(-?[\d.]+)/){$1.to_f.send($2,$3.to_f)}
end
x.strip.to_f
end
Legible:
def s(x)
while x.sub!(/\(([^\(\)]*?)\)/){s($1)}
x.gsub!('--','')
end
while x.sub!(/(-?[\d.]+)[ ]*([+\-*\/])[ ]*(-?[\d.]+)/){$1.to_f.send($2,$3.to_f)}
end
x.strip.to_f
end
[
['1 + 3 / -8', -0.5],
['2*3*4*5+99', 219],
['4 * (9 - 4) / (2 * 6 - 2) + 8', 10],
['1 + ((123 * 3 - 69) / 100)', 4],
['2.45/8.5*9.27+(5*0.0023)',2.68344117647059],
['(3+7) - (5+2)', 3]
].each do |pair|
a,b = s(String.new(pair[0])),pair[1]
print pair[0].ljust(25), ' = ', b, ' (', a==b, ')'
puts
end
No hay ofuscación real a éste, que he decidido publicar fresco ya que es tremendamente diferente de la primera. Debería haber visto esto desde el principio. El proceso es un proceso muy simple de eliminación: detectar y resolver el más alto par de paréntesis (el más anidada) en un número hasta que se encuentren no más, a continuación, resolver todos los números y las operaciones existentes en el resultado. Y, si bien la resolución de declaraciones entre paréntesis tengo que tira de todos los dobles guiones (Float.to_f no sabe qué hacer con ellos).
Así, es compatible con números positivos y negativos (+3, 3 y -3) e incluso negados sub-expresiones dentro del paréntesis simplemente por el orden de procesamiento. La aplicación única más corto es el Perl (w / o eval) uno.
Editar Todavía estoy persiguiendo Perl, pero esta es la respuesta segundo más pequeño en este momento. He encogido a los cambios introducidos la segunda expresión regular y cambiando el tratamiento de la cadena a ser destructivo (sustituye a la antigua cadena). Esto elimina la necesidad de duplicar la cadena, lo que me pareció ser sólo un nuevo puntero a la cadena. Y cambiar el nombre de la función a s de resolver salvaron unos pocos caracteres.
Python con expresiones regulares
Número de caracteres: 283
Función totalmente ofuscado:
import re
from operator import*
def c(e):
O=dict(zip("+-/*()",(add,sub,truediv,mul)))
a=[add,0];s=a
for v,o in re.findall("(-?[.\d]+)|([+-/*()])",e):
if v:s=[float(v)]+s
elif o=="(":s=a+s
elif o!=")":s=[O[o]]+s
if v or o==")":s[:3]=[s[1](s[2],s[0])]
return s[0]
No ofuscado:
import re
from operator import *
def compute(s):
operators = dict(zip("+-/*()", (add, sub, truediv, mul)))
stack = [add, 0]
for val, op in re.findall("(-?[.\d]+)|([+-/*()])", s):
if val:
stack = [float(val)] + stack
elif op == "(":
stack = [add, 0] + stack
elif op != ")":
stack = [operators[op]] + stack
if val or op == ")":
stack[:3] = [stack[1](stack[2], stack[0])]
return stack[0]
quería ver si CAB vencer a los de otras soluciones de Python usando expresiones regulares.
No se pudo.
La expresión regular que estoy usando crea una lista de pares (val, op), donde sólo un elemento de cada par es válido. El resto del código es un analizador basado en pila en lugar de serie con un truco de la sustitución de las 3 celdas superiores en la pila con el resultado del cálculo utilizando la sintaxis de lista de asignación Python. Haciendo de este trabajo con números negativos requiere sólo dos caracteres adicionales (-? En la expresión regular).
Python
Número de caracteres: 382
Sin embargo, otra solución Python, en gran medida mediante la sustitución de expresiones regulares. Cada carrera a través del bucle de las expresiones más sencillas son calculados y los resultados se ponen de nuevo en la cadena.
Este es el código unobfuscated, a menos que se tiene en cuenta las expresiones regulares para ser ofuscado.
import re
from operator import *
operators = dict(zip("+-/*", (add, sub, truediv, mul)))
def compute(s):
def repl(m):
v1, op, v2 = m.groups()
return str(operators[op](float(v1), float(v2)))
while not re.match("^\d+\.\d+$", s):
s = re.sub("([.\d]+)\s*([+-/*])\s*([.\d]+)", repl, s)
s = re.sub("\(([.\d]+)\)", r"\1", s)
return s
tuvo la idea justo cuando estaba dando vueltas y no podía dejarlo ir hasta que lo escribí y lo hizo trabajar.
C #
Número de caracteres: 396 (actualizado)
(pero no resiste que agregó con "/ -8", y no estoy inclinado a solucionarlo ...
static float Eval(string s){int i,j;s=s.Trim();while((i=s.IndexOf(')'))>=0){j=s.LastIndexOf('(',i,i);s=s.Substring(0,j++)+Eval(s.Substring(j,i-j))+s.Substring(i+1);}if((i=s.LastIndexOfAny("+-*/".ToCharArray()))<0) return float.Parse(s);var r=float.Parse(s.Substring(i+1));var l=i>0?Eval(s.Substring(0,i)):(float?)null;return s[i]=='+'?(l??0)+r:(s[i]=='-'?(l??0)-r:(s[i]=='/'?(l??1)/r:(l??1)*r));}
De:
static float Eval(string s)
{
int i, j;
s = s.Trim();
while ((i = s.IndexOf(')')) >= 0)
{
j = s.LastIndexOf('(', i, i);
s = s.Substring(0, j++) + Eval(s.Substring(j, i - j)) + s.Substring(i + 1);
}
if ((i = s.LastIndexOfAny("+-*/".ToCharArray())) < 0) return float.Parse(s);
var r = float.Parse(s.Substring(i + 1));
var l = i > 0 ? Eval(s.Substring(0, i)) : (float?)null;
return s[i] == '+'
? (l ?? 0) + r
: (s[i] == '-'
? (l ?? 0) - r
: (s[i] == '/'
? (l ?? 1) / r
: (l ?? 1) * r));
}
Python
Número de caracteres: 235
Función totalmente ofuscado:
def g(a):
i=len(a)
while i:
try:m=g(a[i+1:]);n=g(a[:i]);a=str({'+':n+m,'-':n-m,'*':n*m,'/':n/(m or 1)}[a[i]])
except:i-=1;j=a.rfind('(')+1
if j:k=a.find(')',j);a=a[:j-1]+str(g(a[j:k]))+a[k+1:]
return float(a.replace('--',''))
-Semi ofuscado:
def g(a):
i=len(a);
# do the math
while i:
try:
# recursively evaluate left and right
m=g(a[i+1:])
n=g(a[:i])
# try to do the math assuming that a[i] is an operator
a=str({'+':n+m,'-':n-m,'*':n*m,'/':n/(m or 1)}[a[i]])
except:
# failure -> next try
i-=1
j=a.rfind('(')+1
# replace brackets in parallel (this part is executed first)
if j:
k=a.find(')',j)
a=a[:j-1]+str(g(a[j:k]))+a[k+1:]
return float(a.replace('--',''))
Fwiw, el n + solución Python 1 Tes. En una situación de abuso de try-excepto utilizo un enfoque de ensayo y error. Se debe manejar adecuadamente todos los casos incluyendo cosas como -(8), --8 y g('-(1 - 3)'). Es reentrante. Sin soporte para el caso -- la que muchas implementaciones no son compatibles, es en 217 caracteres (véase la revisión anterior).
Gracias por una hora interesante en un domingo y otros 30 minutos el lunes. Gracias a krubo por su agradable dict.
Rubí
Número de caracteres: 217 179
Esta es la solución de rubí más corto hasta ahora (uno en gran medida basado en RegExp produce respuestas incorrectas cuando cadena contiene unos grupos de paréntesis) - ya no es así. Las soluciones basadas en expresiones regulares y la sustitución son más cortos. Éste se basa en la pila de acumuladores y analiza toda la expresión de izquierda a derecha. Es reentrante, y no modifica la cadena de entrada. Podría ser acusado de romper las reglas de no usar eval, ya que llama a los métodos de Float con nombres idénticos a sus mnemónicos matemáticos. (+, -, /, *)
código ofuscado (versión antigua, ajustado a continuación)
def f(p);a,o=[0],['+']
p.sub(/-/,'+-').scan(/(?:(-?\d+(?:\.\d+)?)|(.))\s*/).each{|n|
q,w=n;case w;when'(';a<<0;o<<'+';when')';q=a.pop;else;o<<w
end if q.nil?;a[-1]=a[-1].method(o.pop).call(q.to_f) if !q.nil?};a[0];end
Más de código ofuscado:
def f(p);a,o=[0],[:+]
p.scan(/(?:(-?\d+(?:\.\d+)?)|(.))\s*/).each{|n|q,w=n;case w
when'(';a<<0;o<<:+;when')';q=a.pop;else;o<<w;end if !q
a<<a.pop.send(o.pop,q.to_f)if q};a[0];end
Código Limpio:
def f(p)
accumulators, operands = [0], ['+']
p.gsub(/-/,'+-').scan(/(?:(-?\d+(?:\.\d+)?)|(.))\s*/).each do |n|
number, operand = n
case operand
when '('
accumulators << 0
operands << '+'
when ')'
number = accumulators.pop
operands.pop
else
operands[-1] = operand
end if number.nil?
accumulators[-1] = accumulators.last.method(operands[-1]).call(number.to_f) unless number.nil?
end
accumulators.first
end
Rubí 1.8.7
Número de caracteres: 620
No tratar de tomarlo con calma en mi aplicación, que es la primera vez que he escrito un analizador de expresiones en mi vida! Te garantizo que no es la mejor.
ofuscado:
def solve_expression(e)
t,r,s,c,n=e.chars.to_a,[],'','',''
while(c=t.shift)
n=t[0]
if (s+c).match(/^(-?)[.\d]+$/) || (!n.nil? && n.match(/\d/) && c=='-')
s+=c
elsif (c=='-' && n=='(') || c=='('
m,o,x=c=='-',1,''
while(c=t.shift)
o+=1 if c=='('
o-=1 if c==')'
x+=c unless c==')' && o==0
break if o==0
end
r.push(m ? -solve_expression(x) : solve_expression(x))
s=''
elsif c.match(/[+\-\/*]/)
r.push(c) and s=''
else
r.push(s) if !s.empty?
s=''
end
end
r.push(s) unless s.empty?
i=1
a=r[0].to_f
while i<r.count
b,c=r[i..i+1]
c=c.to_f
case b
when '+': a=a+c
when '-': a=a-c
when '*': a=a*c
when '/': a=a/c
end
i+=2
end
a
end
Legible:
def solve_expression(expr)
chars = expr.chars.to_a # characters of the expression
parts = [] # resulting parts
s,c,n = '','','' # current string, character, next character
while(c = chars.shift)
n = chars[0]
if (s + c).match(/^(-?)[.\d]+$/) || (!n.nil? && n.match(/\d/) && c == '-') # only concatenate when it is part of a valid number
s += c
elsif (c == '-' && n == '(') || c == '(' # begin a sub-expression
negate = c == '-'
open = 1
subExpr = ''
while(c = chars.shift)
open += 1 if c == '('
open -= 1 if c == ')'
# if the number of open parenthesis equals 0, we've run to the end of the
# expression. Make a new expression with the new string, and add it to the
# stack.
subExpr += c unless c == ')' && open == 0
break if open == 0
end
parts.push(negate ? -solve_expression(subExpr) : solve_expression(subExpr))
s = ''
elsif c.match(/[+\-\/*]/)
parts.push(c) and s = ''
else
parts.push(s) if !s.empty?
s = ''
end
end
parts.push(s) unless s.empty? # expression exits 1 character too soon.
# now for some solutions!
i = 1
a = parts[0].to_f # left-most value is will become the result
while i < parts.count
b,c = parts[i..i+1]
c = c.to_f
case b
when '+': a = a + c
when '-': a = a - c
when '*': a = a * c
when '/': a = a / c
end
i += 2
end
a
end
Ruby 1.9
(debido a la expresión regular)
Número de caracteres: 296
def d(s)
while m = s.match(/((?<pg>\((?:\\[()]|[^()]|\g<pg>)*\)))/)
s.sub!(m[:pg], d(m[:pg][1,m[:pg].size-2]))
end
while m = s.match(/(-?\d+(\.\d+)?)\s*([*+\-\/])\s*(-?\d+(\.\d+)?)/)
r=m[1].to_f.send(m[3],m[4].to_f) if %w{+ - * /}.include?m[3]
s.sub!(m[0], r.to_s)
end
s
end
EDIT: incluye la optimización de Martin
.SNOBOL4
Número de caracteres: 232
a = pos(0) | '('
n = span('0123456789.')
j = '!+;!-;!*;!/; output = e'
d j '!' len(1) . y = " e a . q n . l '" y "' n . r = q (l " y " r) :s(p)" :s(d)
k = code(j)
e = input
s e ' ' = :s(s)
p e ('(' n . i ')') = i :s(p)f<k>
end
Este es un semi-trampas. Utiliza code() (una variante de eval) para de-comprimir en sí, pero no para evaluar la expresión de entrada.
versión De-ofuscado, sin code:
prefix = pos(0) | '('
num = span('0123456789.')
expr = input
spaces expr ' ' = '' :s(spaces)
paren expr ('(' num . x ')') = x :s(paren)
add expr (prefix . pfx) (num . l) '+' (num . r) = pfx (l + r) :s(paren)
sub expr (prefix . pfx) (num . l) '-' (num . r) = pfx (l - r) :s(paren)
mul expr (prefix . pfx) (num . l) '*' (num . r) = pfx (l * r) :s(paren)
div expr (prefix . pfx) (num . l) '/' (num . r) = pfx (l / r) :s(paren)
output = expr
end
Estrategia:
- En primer lugar, eliminar todos los espacios (
spaces) - Siempre que sea posible, eliminar paréntesis que rodean un número (
paren) - En caso contrario, encontrar una expresión simple que involucra dos números, con el prefijo
'('o al comienzo de la cadena - Si ninguna de las reglas anteriores se aplican, la expresión está completamente evaluado. Ahora bien, si la entrada fue bien formada que debe quedar con un número.
Ejemplo:
-
1 + (2 * 3) + 4 -
1+(2*3)+4[spaces] -
1+(6)+4[mul] -
1+6+4[paren] -
7+4[add] -
11[add]
C #
Número de caracteres: 355
noldorin respuesta y lo modificó, por lo que dar noldorin 99% del crédito para esto. Mejor que podía hacer con el algoritmo estaba usando era de 408 caracteres. Ver de noldorin respuesta para la versión de código más claro.
Los cambios realizados:
Cambiar las comparaciones char a comparar con los números.
Eliminado algunas declaraciones por defecto y combinado mismo tipo de declaraciones.
Re-trabajado algunos de los si statments.
float q(string x){float v,n;if(!float.TryParse(x,out v)){x+=';';int t=0,l=0,i=0;char o,s='?',p='+';for(;i<x.Length;i++){o=s;if(x[i]!=32){s=x[i];if(char.IsDigit(x[i])|s==46|(s==45&o!=49))s='1';if(s==41)l--;if(s!=o&l==0){if(o==49|o==41){n=q(x.Substring(t,i-t));v=p==43?v+n:p==45?v-n:p==42?v*n:p==47?v/n:v;p=x[i];}t=i;if(s==40)t++;}if(s==40)l++;}}}return v;}
Edit: lo tiró hacia abajo un poco más a las 361 a 355, mediante la eliminación de una de las declaraciones provistas de retorno
.