Introducción

Resulta que los extraterrestres aman los memes tanto como nosotros. Sin embargo, cada raza alienígena que hemos encontrado hasta ahora tiene su propia versión 2spooky4me(ver la siguiente pregunta ) y equivalente, con alguna variación. Los habitantes del planeta CUTE1f no pueden manejar mucho espectro, por lo que su espectro preferido es 1spooky2me, mientras que los miembros de skeletor7 les aman un poco de miedo, por lo que tienden a usarlo 9spooky11me.

Reto

Traducir memes es un trabajo duro, por lo que se le ha encomendado la tarea de escribir un traductor universal de memes para ayudar a estos tipos a acceder a la memenet correctamente. Su programa aceptará un meme y una transformación para aplicar a las secuencias de dígitos en ese meme para que sea apropiado para los habitantes de un planeta diferente.

Entrada

Su programa recibirá dos entradas de cadena:

1. El meme de entrada (p 2spooky4me. Ej .). Partidos [a-zA-Z0-9]+.
2. La transformación para aplicarle (por ejemplo +1, ir de 2spooky4mea 3spooky5me). Partidos [+\-*/^]\d+(Debe aceptar +, -, *, /, y ^como operadores, independientemente de la representación nativa en su idioma).

Salida

Su programa debe devolver una salida de cadena (impresa a la salida estándar o equivalente) con la transformación dada aplicada a las secuencias de dígitos en el meme de entrada. En un extraño giro de los acontecimientos, también resulta que todas las razas encontradas hasta ahora prefieren memes integrales a los fraccionarios, por lo que estas transformaciones deberían realizar una aritmética de enteros (por ejemplo, 1spooky1me /2deberían resultar en 0spooky0me).

Ejemplos

Se aplican operaciones aritméticas estándar:

Input:  2spooky4me +1
Output: 3spooky5me

Input:  2spooky4me -1
Output: 1spooky3me

Input:  2spooky4me *15
Output: 30spooky60me

Input:  10spooky900me /5
Output: 2spooky180me

Las secuencias de dígitos son integrales; el truncamiento de enteros debería ocurrir en casos como este:

Input:  idontunderstandmemes3 /2
Output: idontunderstandmemes1

Su entrada puede no tener ninguna secuencia de dígitos:

Input:  notreallyafunnymeme *100
Output: notreallyafunnymeme

Debe admitir la exponenciación, incluso si no es una operación nativa en el idioma de su elección:

Input:  2spooky4me ^3
Output: 8spooky64me

No hay límite en la longitud de la cadena del número de secuencias de dígitos en la cadena:

Input:  some1meme2sequences3can4be5really6long7 /2
Output: some0meme1sequences1can2be2really3long3

Apéndice

Si su idioma admite enteros de precisión arbitraria como una función de idioma, debe usarlos. Si no es así, no necesita admitir enteros de precisión arbitraria. Por ejemplo, debe usar Integeren Haskell en lugar de Intporque está disponible como parte del lenguaje; en Java, no es obligatorio usarlo BigIntegerporque es una función de biblioteca, no una función de idioma.

Input:  2000000000000000000000000000000000000000000000000000000000000000000000000000000‌​000000000000000000000000000000000spooky4me /2
Output: 1000000000000000000000000000000000000000000000000000000000000000000000000000000‌​000000000000000000000000000000000spooky2me

Este es el código de golf , por lo que las lagunas estándar están prohibidas, ¡y la respuesta más corta en bytes gana!

Tabla de clasificación

El Fragmento de pila al final de esta publicación genera la tabla de clasificación a partir de las respuestas a) como una lista de la solución más corta por idioma yb) como una tabla de clasificación general.

Para asegurarse de que su respuesta se muestre, comience con un título, utilizando la siguiente plantilla de Markdown:

## Language Name, N bytes

¿Dónde Nestá el tamaño de su envío? Si mejora su puntaje, puede mantener los puntajes antiguos en el título, tachándolos. Por ejemplo:

## Ruby, <s>104</s> <s>101</s> 96 bytes

Si desea incluir varios números en su encabezado (por ejemplo, porque su puntaje es la suma de dos archivos o desea enumerar las penalizaciones de la bandera del intérprete por separado), asegúrese de que el puntaje real sea el último número en el encabezado:

## Perl, 43 + 2 (-p flag) = 45 bytes

También puede hacer que el nombre del idioma sea un enlace que luego aparecerá en el fragmento:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

<style>body { text-align: left !important} #answer-list { padding: 10px; width: 290px; float: left; } #language-list { padding: 10px; width: 290px; float: left; } table thead { font-weight: bold; } table td { padding: 5px; }</style><script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="language-list"> <h2>Shortest Solution by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr> </thead> <tbody id="languages"> </tbody> </table> </div> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr> </thead> <tbody id="answers"> </tbody> </table> </div> <table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table><script>var QUESTION_ID = 79809; var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe"; var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk"; var OVERRIDE_USER = 45941; var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page; function answersUrl(index) { return "https://api.stackexchange.com/2.2/questions/" + QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER; } function commentUrl(index, answers) { return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER; } function getAnswers() { jQuery.ajax({ url: answersUrl(answer_page++), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { answers.push.apply(answers, data.items); answers_hash = []; answer_ids = []; data.items.forEach(function(a) { a.comments = []; var id = +a.share_link.match(/\d+/); answer_ids.push(id); answers_hash[id] = a; }); if (!data.has_more) more_answers = false; comment_page = 1; getComments(); } }); } function getComments() { jQuery.ajax({ url: commentUrl(comment_page++, answer_ids), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { data.items.forEach(function(c) { if (c.owner.user_id === OVERRIDE_USER) answers_hash[c.post_id].comments.push(c); }); if (data.has_more) getComments(); else if (more_answers) getAnswers(); else process(); } }); } getAnswers(); var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/; var OVERRIDE_REG = /^Override\s*header:\s*/i; function getAuthorName(a) { return a.owner.display_name; } function process() { var valid = []; answers.forEach(function(a) { var body = a.body; a.comments.forEach(function(c) { if(OVERRIDE_REG.test(c.body)) body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>'; }); var match = body.match(SCORE_REG); if (match) valid.push({ user: getAuthorName(a), size: +match[2], language: match[1], link: a.share_link, }); else console.log(body); }); valid.sort(function (a, b) { var aB = a.size, bB = b.size; return aB - bB }); var languages = {}; var place = 1; var lastSize = null; var lastPlace = 1; valid.forEach(function (a) { if (a.size != lastSize) lastPlace = place; lastSize = a.size; ++place; var answer = jQuery("#answer-template").html(); answer = answer.replace("{{PLACE}}", lastPlace + ".") .replace("{{NAME}}", a.user) .replace("{{LANGUAGE}}", a.language) .replace("{{SIZE}}", a.size) .replace("{{LINK}}", a.link); answer = jQuery(answer); jQuery("#answers").append(answer); var lang = a.language; lang = jQuery('<a>'+lang+'</a>').text(); languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang.toLowerCase(), user: a.user, size: a.size, link: a.link}; }); var langs = []; for (var lang in languages) if (languages.hasOwnProperty(lang)) langs.push(languages[lang]); langs.sort(function (a, b) { if (a.lang_raw > b.lang_raw) return 1; if (a.lang_raw < b.lang_raw) return -1; return 0; }); for (var i = 0; i < langs.length; ++i) { var language = jQuery("#language-template").html(); var lang = langs[i]; language = language.replace("{{LANGUAGE}}", lang.lang) .replace("{{NAME}}", lang.user) .replace("{{SIZE}}", lang.size) .replace("{{LINK}}", lang.link); language = jQuery(language); jQuery("#languages").append(language); } }</script>

Jolf, 15 14 bytes

ρi«\d+»dC!6+HI

Pruébalo aquí!

Explicación

ρi«\d+»dC!6+HI
ρ «\d+»         replace all digits
 i              in the input
       d        (functional replace)
         !6     eval (using jolf's custom infix eval)
           +H   the number as a string plus
             I  the second input
        C       floor the result (integer truncate)

Es divertido notar que actualicé a Jolf después de este desafío, agregando algunas incorporaciones RegExp. Esto podría ser 12 11 bytes:

ρiLRdC!6+HI

Ruby, 50 44 43 bytes

FGITW responde. ¡Tengo que ir rápido!

Gracias a @Neil por guardar 6 bytes.

Oh cierto, tachado 44 sigue siendo 44

->m,t{m.gsub(/\d+/){eval$&+t.sub(?^,'**')}}

Perl, 36 34 bytes

s/\d+/"0|$&$^I"=~s#\^#**#r/gee

El código fuente tiene 30 bytes de longitud y requiere los conmutadores -pi( +4 bytes ). Toma la primera entrada de STDIN, la segunda entrada como argumento para -i.

¡Gracias a @DenisIbaev por jugar golf en 2 bytes!

Pruébalo en Ideone .

PowerShell v2 +, 139137 bytes

param($a,$b)-join($a-split"(\d+)"|%{if($_-match"\d+"){if($b[0]-ne'^'){[math]::Floor((iex $_$b))}else{"$_*"*$b.Trim('^')+1|iex}}else{$_}})

Ooof ... 47 bytes solo para tener en cuenta ^ya que ese no es un operador nativo en PowerShell. Guardado 2 bytes gracias a @TessellatingHeckler.

Toma de entrada como $a=<word>, $b=<operation>, como .\universal-spooky-meme.ps1 2spooky4me ^3. Estamos -split $aen dígitos, encerrándolos en parens para mantener los delimitadores y canalizar la matriz resultante a través de un bucle |%{...}. Si la pieza actual es un número, estamos en el primero if. Necesitamos verificar si el primer carácter de $bes ^. Si no es así, simplemente concatenamos nuestra pieza actual $by la enviamos a iex(similar a eval), luego la dejamos en la tubería. De lo contrario, necesitamos crear una cadena de exponenciación con "$_*"*$b.Trim('^')+1y canalizar eso iex, y dejarlo en la tubería. Para el 2spooky4me ^3ejemplo dado , esto será 2*2*2*1y 4*4*4*1, respectivamente.

De lo contrario, simplemente dejamos la cadena como está en la tubería.

Todos esos resultados se recopilan de la tubería con los paréntesis encapsulantes antes de -joinvolver a unirlos en una sola cadena. Esa es la izquierda en la tubería, y la salida está implícita en la terminación del programa.

Ejemplos

PS C:\Tools\Scripts\golfing> .\universal-spooky-meme.ps1 2spooky4me ^5
32spooky1024me

PS C:\Tools\Scripts\golfing> .\universal-spooky-meme.ps1 2spooky4me /3
0spooky1me

JavaScript (ES7), 58 57 bytes

(s,t)=>s.replace(/\d+/g,n=>0|eval(n+t.replace('^','**')))

Editar: guardado 1 byte cuando recordé que replacetambién funciona en cadenas literales.

Pyth, 29

Jws.i:zK"\d+"3m.vs.iJ]+d;:zK1

Esto funciona extrayendo cada número del meme y luego intercalando ( .i) seguido de un espacio y envuelto en una lista con el otro argumento. Así que si es nuestro número 7y tuvimos ^20que obtendríamos la lista: ["^", "7 ", "20"]. Acoplar y usar Pyth's eval( .v) en esto siempre da la operación que queremos. Finalmente, estos valores se entrelazan con la cadena original dividida en casos de números.

Esto podría ser un byte más corto si ambas entradas estaban rodeadas por caracteres de comillas, o dos bytes más cortos si solo se pudiera citar uno de ellos.

Pruébelo aquí o ejecute un Test Suite

Python 2, 156 89 88 87 bytes

Inspirado por las otras respuestas que usan la función de sustitución de sus idiomas con un controlador de funciones para procesar las partes numéricas de la icadena de entrada larga con el operador. Desafortunado para Python, ^debe ser reemplazado por **, lo que cuesta la friolera de 18 bytes. La .group(0)llamada solo para acceder a la representación de cadena del objeto de coincidencia no mejora las cosas ...

¡Gracias a QPaysTaxes por detectar un espacio espurio y a RootTwo por el argumento innecesario .group!

import re
lambda i,o:re.sub(r'\d+',lambda p:str(eval(p.group()+o.replace('^','**'))),i)

Javascript (ES6) 99 bytes

Otro ejemplo, por qué odiamos esperar a que ES7 obtenga compatibilidad

(a,b)=>a.match(/\d+|\D+/g).map(_=>(d=- -_)?eval(b[0]=="\^"?Math.pow(_,b.slice(1)):d+b)|0:_).join``

Ejemplo ejecutable:

f=(a,b)=>a.match(/\d+|\D+/g).map(_=>(d=- -_)?Math.ceil(eval(b[0]=="\^"?Math.pow(_,b.slice(1)):d+b)):_).join``

alert(f(prompt("Enter string!"), prompt("Enter operation!")));

Julia, 71 59 54 bytes

/ =÷
x%y=replace(x,r"\d+",t->"big($t)"y|>parse|>eval)

El requisito de usar bigsi está disponible hace que esto sea mucho más largo de lo que podría ser ...

Pruébalo en línea!

Kotlin, 416413 bytes

La falta de un eval()Kotlin realmente aumentó ese número de bytes ...

fun main(a:Array<String>){var r=Regex("\\d+");var i=a[0];var n=a[1].takeLast(a[1].length-1).toInt();when(a[1][0]){'+'->print(r.replace(i,{m->""+(m.value.toInt()+n)}));'*'->print(r.replace(i,{m->""+(m.value.toInt()*n)}));'/'->print(r.replace(i,{m->""+(m.value.toInt()/n)}));'-'->print(r.replace(i,{m->""+(m.value.toInt()-n)}));'^'->print(r.replace(i,{m->""+(Math.pow(m.value.toDouble(),n.toDouble())).toInt()}));}}

Pruébalo en línea!

Sin golf

fun main(a: Array<String>) {
    var r = Regex("""\d+""")
    var i = a[0]
    var n = a[1].takeLast(a[1].length - 1).toInt()
    when (a[1][0]) {
        '+' -> print(r.replace(i, { m -> "" + (m.value.toInt() + n) }))
        '*' -> print(r.replace(i, { m -> "" + (m.value.toInt() * n) }))
        '/' -> print(r.replace(i, { m -> "" + (m.value.toInt() / n) }))
        '-' -> print(r.replace(i, { m -> "" + (m.value.toInt() - n) }))
        '^' -> print(r.replace(i, { m -> "" + (Math.pow(m.value.toDouble(), n.toDouble())).toInt() }))
    }
}

PowerShell (v4), 124 120 bytes

# New 120 byte version:
$s,$a=$args;[regex]::Replace($s,'\d+',{($(if($a-ne($a=$a.Trim('^'))){
"$args*"*$a+1}else{"$args$a"})|iex)-replace'\..*'})

# Previous 124 byte version
$s,$a=$args;[regex]::Replace($s,'\d+',{if($a[0]-eq'^'){
[math]::pow("$args",$a.Trim('^'))}else{iex "$args$a-replace'\..*'"}})

(las nuevas líneas solo están aquí para evitar el desplazamiento horizontal, funcionan cuando se guardan como una línea).

Comentarios, y se solicitó una versión sin golf:

$meme, $instruction = $args

# Scriptblock which processes the numbers
# to be replaced. $args is the input number.
$replacement = {

    # Generates a string of the calculation, by:
    # Removing leading ^ character, if present.
    # ^3 -> 3,      +3 -> +3
    # See if it was present, and switch code paths.
    # (Can be one combined step in the golf)
    # Switch code paths for "raise to the power of",
    # or basic arithmetic.
    $trimmedInstruction = $instruction.Trim('^')
    $tmp = if ( $instruction -ne $trimmedInstruction ) {

        # String multiplication, changes
        # function input "45" and instruction "3" into
        # "45*45*45*+1". The "3" implicitly casts to [int]
        # the +1 is there to make the trailing * not crash.
        "$args*" * $instruction + 1

    } else {
        # Cobble the basic math together as a string
        # "45" and "+10" becomes
        # "45+10"
        "$args$instruction"
    }

    # eval() the generated string (e.g. "45+10" or "45*45*45*+1")
    $tmp = Invoke-Expression $tmp      # iex

    # Use a regex golf to replace trailing .23423
    # decimals in case of division with remainder.
    # Acts as [math]::floor(), harmless on other numbers.
    $tmp -replace'\..*'
}

# A regular expression replacement which picks out all 
# the numbers (\d+) and runs them through the
# replacement function. Returns a string which 
# ends up on stdout
[regex]::Replace($meme, '\d+', $replacement)

• La biblioteca de expresiones regulares .Net puede reemplazarse con un bloque de script que se ejecuta en el contenido de la coincidencia, y PowerShell convierte las cadenas de tipos en números, y iexes como eval()en otros idiomas. Simplemente lo hace "2spooky" "+3"->eval("2+3")
• Excepto ... no puede manejar el ^operador o cualquier otra exponenciación conveniente **, solo puede usar la [math]::Pow()llamada a la biblioteca, por lo que hay un gran bloque para manejar esa rama.
  • La versión actualizada le roba una idea a @TimmyD y, en su lugar, multiplica la cadena, "2*" * nque se convierte "2*2*2*2*"y luego agrega +1al final para multiplicar por uno en lugar de quejarse por el final *.
• Excepto ... .Net realiza el redondeo bancario que redondea al número par más cercano por defecto, y 3/2 = 2 en lugar de 3/2 = 1. Este desafío requiere truncamiento, y eso significa [math]::Truncate(). En cambio, guardo caracteres mediante el uso -replacede recortar un punto decimal y cualquier cosa después.

Casos de prueba:

PS D:\> .\meme.ps1 2spooky4me +1
3spooky5me

PS D:\> .\meme.ps1 2spooky4me -1
1spooky3me

PS D:\> .\meme.ps1 2spooky4me *15
30spooky60me

PS D:\> .\meme.ps1 10spooky900me /5
2spooky180me

PS D:\> .\meme.ps1 idontunderstandememes3 /2
idontunderstandememes1

PS D:\> .\meme.ps1 "idontunderstandememes3" "/2"
idontunderstandememes1

PS D:\> .\meme.ps1 "notreallyafunnymeme" "*100"
notreallyafunnymeme

PS D:\> .\meme.ps1 "2spooky4me" "^3"
8spooky64me

PS D:\> .\meme.ps1 "some1meme2sequences3can4be5really6long7" "/2"
some0meme1sequences1can2be2really3long3

PS D:\> .\meme.ps1 2000000000000000000000000000000000000000000000000000000000000000000000000000000‌​000000000000000000000000000000000spooky4me /2
1E+78‌​0spooky2me

NÓTESE BIEN. En la última prueba, los números se desbordan [BigInteger]automáticamente, pero se representan en notación científica. Afortunadamente, cada raza conocida capaz de comunicarse entre las estrellas tiene suficiente desarrollo científico para poder procesar la notación científica sin problemas.

Bash + GNU coreutils, 144 Bytes

d=
u=$1,
for((i=0;i<${#u};i++)){ l=${u:i:1}
[[ "$l" =~ [0-9] ]]&&d=$d$l||{ [ -z $d ]||echo -n `bc<<<$d$2`&&{ [ $l != , ]&&echo -n $l; };d=; }
}

Esto analiza la alteración entre dígitos y no dígitos, por eso se agrega un carácter de entrada (coma) no válido al azar a la cadena de entrada. Esta coma se ignora en la salida. La convención del OP sigue exactamente la sintaxis de la bccual se usa aquí para hacer los cálculos.

Lua, 145 93 bytes

r=io.read;m=r()o=r()m=m:gsub("%d",function(n)return loadstring("return..."..o)(n)end)print(m)

R, 163 bytes

Como alguien que está aprendiendo expresiones regulares y sustitución de cuerdas en R, esto resultó ser un desafío bastante difícil. Especialmente porque hacer coincidir los números es fácil, pero no pude encontrar una manera de usar múltiples sustituciones con gsub. Además, no sé si eval(parse(paste0(...es la forma más eficiente de cambiar entre operaciones. Quizás la switchfunción sea más adecuada aquí.

function(s,o){p=strsplit;y=p(gsub("\\d+","?",s),"?")[[1]];x=na.omit(as.integer(p(s,"[a-zA-Z]+")[[1]]));y[y=="?"]=floor(eval(parse(,,paste0("x",o))));cat(y,sep="")}

Explicación

f=function(s,o){
    p=strsplit                                    # alias for stringsplit    
    y=p(gsub("\\d+","?",s),"?")[[1]]              # substitute numbers with "?" and split into vector on "?"
    x=na.omit(as.integer(p(s,"[a-zA-Z]+")[[1]]))  # split at alphabetical char, return vector with numbers to be operated on
    y[y=="?"]=floor(eval(parse(,,paste0("x",o)))) # replace inserted "?" with vector of numbers operated on
    cat(y,sep="")                                 # print concatenated vector
}

Javascript (ES6), 85 bytes

x=(s)=>{var a=s.split(" ");return[...a[0]].map(x=>(!isNaN(x))?eval(x+a[1]):x).join``}

console.log(x("2spookie5me +1"));

Sin golf:

x = (s) => {
  var a = s.split(" ");
  return [...a[0]].map(x => (!isNaN(x)) ? eval(x + a[1]) : x).join ``
}
console.log(x("2spookie5me +1"));

Groovy, 64 60 Bytes

{a,b->a.replaceAll(/\d+/,{Eval.me(it+b.replace("^","**"))})}

Reemplaza todas las instancias de dígitos con un cierre que evalúa la operación en las porciones de dígitos de la palabra pasada. Si se pasa una función de exponente, la reemplaza con la notación adecuada. Groovy maneja implícitamente la conversión BigInteger / BigDecimal cuando se usa Eval.me()porque las cadenas analizadas pueden estar potencialmente fuera del 2^32-1rango.

Explicado

{a,b->...} - Cierre con dos argumentos.

a.replaceAll(/\d+/,{...}) - Buscar todas las secuencias de dígitos en cadena y reemplazar con un cierre.

{Eval.me(it+b.replace("^","**"))} - Más específicamente, un cierre con cada partido con la operación adjunta, luego evaluado como código maravilloso.

.replace("^","**")- Reemplace la primera instancia de ^con el operador exponente maravilloso **en la operación proporcionada. Si desea que esto funcione con cadenas de ecuaciones completas que usan exponentes, use replaceAll()en su lugar para una penalización de +3 bytes.

La nota al margen divertida es un escenario de prueba válido:
(22348952345238905290858906209862398036spooky409552me, /200*4943^8-23939+((100/203)+600)

RProgN , 39 Bytes

►x='%d+'§x'%D+'''Rx'%d+'''Rg'y'=y_}R

Explicado

►x='%d+'§x'%D+'''Rx'%d+'''Rg'y'=y_}R
►                                       # Spaceless segment.
 x=                                     # Assign the top value of the stack '[+*/-]\d+' 
   '$d+'§                         }R     # Replace everything in the pattern %d+ (all numbers) based on an anonymous function 
         x'%D+'''R                      # Replace all Non-digits in the modifer with nothing, leaving just the second argument for the operator.
                  x'%d+'''R             # Snip all digits, separating our operator from our digits such that digit operator exists in the stack.
                           g'y'=        # Grab the function that is represented by the top of the stack (the operator in this case)
                                y       # Run it
                                 _      # Floor the result. 

Respuesta técnicamente inválida, porque este lenguaje no existía para ello. Sin embargo, no fue diseñado específicamente para ello, ni ninguna adición particular. Entonces lo estoy ejecutando. Demándame.

Pruébalo en línea!

Perl 6, 111 bytes

{/(\w+)\s(<[+\-*/^]>)(\d+)/&&my \b=+$2;my \o=(*+b,*-b,* *b,*div b,* **b)[index "+-*/^",$1];$0.subst(/\d+/,o):g}

Lamentablemente EVALestá deshabilitado por defecto. Además, debe usar divpara la división de enteros.