Universal Spooky Meme Translator

43

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

Mostrar fragmento de código

code-golf  string  math  subsequence 
— Itai Ferber
fuente
3
Tu último caso de prueba está mal. Tiene demasiados ceros en la salida para que sea / 5.
— Nic Hartley
55
En primer lugar, esta es una primera publicación razonablemente bien organizada, así que felicidades :) Tenga en cuenta que tenemos un Sandbox donde puede publicar su desafío para obtener comentarios antes de que se publique.
— FryAmTheEggman
3
Bienvenido a PPCG (aunque aparentemente has estado aquí por más de 2 años). Bonito primer desafío. ¿El apéndice sobre enteros de precisión arbitraria exige que, por ejemplo, Java deba usar BigIntegerpara sus cálculos?
— AdmBorkBork
18
Cada raza alienígena que hemos encontrado hasta ahora ... ¡ Eso es totalmente cierto! :-)
— Luis Mendo
2
Es su desafío y, en última instancia, depende de usted, pero eso no es realmente justo con los idiomas que utilizan una sintaxis diferente.
— Dennis

Respuestas:

10

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
— Conor O'Brien
fuente
24

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(?^,'**')}}
— Tinta de valor
fuente
Oh, hombre, esto es casi exactamente una respuesta que estaba metiendo, en: a=gets;$><<gets.gsub(/\d+/){eval$&+a}. Sin embargo, el mío perdió la cosa ^! = **, y probablemente sea un poco más largo.
— Nic Hartley
3
+1 para que toda su solución sea 4 bytes más corta de lo que se necesita en PowerShell solo para manejar ^. : D
— AdmBorkBork
15

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 .

— Dennis
fuente
Sí, pensé que si alguien podría superar mi respuesta de Ruby, sería Dennis y / o estaría en Perl, y terminaste cumpliendo ambas expectativas al mismo tiempo
— Value Ink
1
-pies de 4 bytes?
— CalculatorFeline
@CatsAreFluffy El consenso actual es contar la distancia de edición desde la invocación sin las banderas. Eso incluye un espacio para separarse -pidel resto del comando.
— Dennis
"0|$&"es más corto que "0|".$&.
— Denis Ibaev
@DenisIbaev Dado que la entrada es alfanumérica, "0|$&$^I"también funciona. ¡Gracias!
— Dennis
9

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
— AdmBorkBork
fuente
Escribí el mío antes de buscar respuestas, luego pellizqué algunas de sus ideas también, gracias. Creo que se podría reemplazar Floor(("$_$b"|iex))con Floor((iex $_$b))ahorrar un par, o tal vez iex $_+$b.
— TessellatingHeckler
@TessellatingHeckler ¡Gracias por los dos bytes!
— AdmBorkBork
8

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.

— Neil
fuente
Genial, estoy trabajando en una solución ES6
— Bálint
¿Puedes curry para salvar un byte?
— gcampbell
1
@gcampbell Sí, pero soy demasiado vago para hacerlo.
— Neil
6

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

— FryAmTheEggman
fuente
6

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)
— ojdo
fuente
Creo que puedes deshacerte del espacio despuési,o:
— Nic Hartley
Puede guardar dos bytes más: (1) utilizando p.group(). (el valor predeterminado es 0); y (2) insertar r=re.sub;reemplazar la primera re.subllamada con ry luego usar en r('^','**',o)lugar deo.replace(...)
— RootTwo
@RootTwo: Para mí, r('^','**',o)entonces requiere escapar ^para \^coincidir con el carácter, no el comienzo de o, ahorro neto sin bytes :-( - ¡pero gracias por señalar lo innecesario 0!
— ojdo
5

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!")));
Expandir fragmento

— Bálint
fuente
Sus expresiones regulares coincidentes parecen estar un poco apagadas. En el ejemplo ejecutable, deja de lado las letras mayúsculas, lo que las quita del resultado ("2spooky4ME", "+1" => "3spooky5"), y en el primer ejemplo, coincide con \d+|\D+, que es equivalente a .+. [a-zA-Z0-9]+es la expresión regular que quieres, no? ¿O [a-zA-Z]+|[0-9]+si la división hace la diferencia?
— Itai Ferber
Probablemente sería más fácil invocar Math.powdirectamente ya que de todos modos tendrá que hacer un caso especial. Además, ¿estás usando la división de enteros?
— Neil
@Neil, lo olvidé, minuto
— Bálint
@Neil, ¿hay una mejor manera de techo?
— Bálint
1
@ItaiFerber \d+|\D+no es lo mismo que .+. No son lo mismo porque la expansión de Kleene ocurre antes del or. Sería lo mismo si lo pareciera (\d|\D)+, pero como es, no coincidiría con todo lo que se dice 2aen un grupo, serían dos grupos separados.
— FryAmTheEggman
5

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!

— Dennis
fuente
4

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() }))
    }
}
— The_Lone_Devil
fuente
4

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.

— TessellatingHeckler
fuente
1
Puede ver en otras respuestas cómo proporcionan una versión de golf bastante ilegible y luego una versión separada no protegida para examinar el comportamiento del código. Debe hacer esto con los suyos (es decir, eliminar las nuevas líneas en la versión de golf).
— jpmc26
Gracias por el crédito, pero no por mi truco: lo saqué del hilo de consejos de PowerShell.
— AdmBorkBork
Aparentemente, me preocupo lo suficiente como para dejar un comentario, y alguien más se preocupa lo suficiente como para votar mi comentario. ;)
— jpmc26
No, dije que deberías tener una versión totalmente golfizada y una versión completamente no golfista. El golfizado requerirá desplazamiento. El no golfista no será y será más legible que el que tienes.
— jpmc26
1
@ jpmc26 Ok, he editado en una versión no comentada y comentada.
— TessellatingHeckler
3

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.

— rexkogitans
fuente
Por cierto, debido a la discusión en la solución PowerShell por @TessellatingHeckler: En mi solución, puede traducir el programa a una sola línea reemplazando los saltos de línea a punto y coma, lo que no cambia su longitud.
— rexkogitans
3

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)
— Cotilla
fuente
¿Por qué no solo publicar una función?
— Bálint
2

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
}
— Billywob
fuente
Creo que puede ahorrar una tonelada de bytes si usa gsub con un cierre en las coincidencias, que es lo que insinuó en su comentario. Sin embargo, no sé cómo hacerlo en R. Luché con eso también hasta que descubrí cómo hacerlo en Groovy; fue más o menos un cambio de juego.
— Urna mágica de pulpo
2

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"));
— Bladimir Ruiz
fuente
¿Alguien sabe si puedo dividir espacios usando el operador Spread? De este s.split (""); a ["" ... s]; Al menos esa es la idea.
— Bladimir Ruiz
No necesita ()alrededor del argumento lambda, no necesita var, y debe usar parens y el operador de coma en lugar de llaves yreturn
— Cyoce
Además, ^es un caso especial para JavaScript, es un XOR bit a bit en lugar deMath.pow
— Sunny Pun
2

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)

— Urna de pulpo mágico
fuente
1

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!

— Un taco
fuente
0

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.

— bb94
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.