introduction

Il s'avère que les extraterrestres aiment les mèmes tout autant que nous. Chaque race extraterrestre que nous avons rencontrée jusqu'à présent a sa propre version de 2spooky4me(voir la question suivante ) et son équivalent, avec quelques variantes. Les habitants de la planète CUTE1f ne peuvent pas gérer beaucoup de spook, alors leur spook préféré est 1spooky2me, tandis que les membres de skeletor7 aiment les spook, ils ont donc tendance à les utiliser 9spooky11me.

Défi

La traduction de memes est un travail difficile, vous avez donc été chargé d'écrire un traducteur de memes universel pour aider ces personnes à accéder correctement au memenet. Votre programme acceptera un meme et une transformation à appliquer aux séquences de chiffres de ce meme afin de l'adapter aux habitants d'une autre planète.

Contribution

Votre programme recevra deux entrées de chaîne:

1. Le meme d'entrée (par exemple 2spooky4me). Matches [a-zA-Z0-9]+.
2. La transformation à appliquer (par exemple +1, aller de 2spooky4meà 3spooky5me). Matches [+\-*/^]\d+(vous devez accepter +, -, *, /et ^que les opérateurs, quelle que soit la représentation native dans votre langue).

Sortie

Votre programme doit renvoyer une sortie chaîne (imprimée sur une sortie standard ou équivalente) avec la transformation donnée appliquée aux séquences de chiffres du mément d’entrée. Dans une tournure des événements bizarre, il s'avère également que toutes les races rencontrées jusqu'à présent préfèrent les mèmes intégraux aux fractions fractionnaires, de sorte que ces transformations doivent effectuer une arithmétique entière (par exemple, elles 1spooky1me /2devraient en résulter 0spooky0me).

Exemples

Les opérations arithmétiques standard s'appliquent:

Input:  2spooky4me +1
Output: 3spooky5me

Input:  2spooky4me -1
Output: 1spooky3me

Input:  2spooky4me *15
Output: 30spooky60me

Input:  10spooky900me /5
Output: 2spooky180me

Les séquences numériques sont intégrales; la troncature d'un entier devrait se produire dans les cas suivants:

Input:  idontunderstandmemes3 /2
Output: idontunderstandmemes1

Votre entrée peut ne pas avoir de séquence de chiffres:

Input:  notreallyafunnymeme *100
Output: notreallyafunnymeme

Vous devez prendre en charge l’exponentiation, même s’il ne s’agit pas d’une opération native dans la langue de votre choix:

Input:  2spooky4me ^3
Output: 8spooky64me

Il n'y a pas de limite à la longueur de chaîne du nombre de séquences de chiffres dans la chaîne:

Input:  some1meme2sequences3can4be5really6long7 /2
Output: some0meme1sequences1can2be2really3long3

Addenda

Si votre langue prend en charge les entiers à précision arbitraire comme langue, vous devez les utiliser. Si ce n'est pas le cas, vous n'avez pas besoin de prendre en charge les entiers de précision arbitraire. Par exemple, vous devez utiliser IntegerHaskell au lieu de, Intcar il est disponible dans le langage. Dans Java, vous n'êtes pas obligé d'utiliser BigIntegercar c'est une fonctionnalité de bibliothèque, pas une fonctionnalité de langue.

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

C'est du code-golf , donc les échappatoires standard sont interdites, et la réponse la plus courte en octets est gagnante!

Classement

Le fragment de pile au bas de cet article génère le classement à partir des réponses a) sous forme de liste des solutions les plus courtes par langue et b) sous forme de classement global.

Pour vous assurer que votre réponse apparaît, commencez votre réponse par un titre, en utilisant le modèle Markdown suivant:

## Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores en les effaçant. Par exemple:

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

Si vous souhaitez inclure plusieurs numéros dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou si vous souhaitez répertorier séparément les pénalités d'indicateur d'interprétation), assurez-vous que le score réel est le dernier numéro de l'en-tête:

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

Vous pouvez également faire du nom de la langue un lien qui apparaîtra ensuite dans l'extrait de code:

## [><>](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 octets

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

Essayez-le ici!

Explication

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

Il est amusant de noter que j’ai mis à jour Jolf après ce défi, en y ajoutant des commandes intégrées RegExp. Cela pourrait être 12 11 octets:

ρiLRdC!6+HI

Ruby, 50 44 43 octets

Réponse FGITW. Dois aller vite!

Merci à @Neil d'avoir économisé 6 octets.

Oh oui, barré 44 c'est encore 44

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

Perl, 36 34 octets

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

Le code source a une longueur de 30 octets et nécessite les commutateurs -pi( +4 octets ). Il prend la première entrée de STDIN, la deuxième entrée comme argument -i.

Merci à @DenisIbaev pour le golf de 2 octets!

Testez-le sur Ideone .

PowerShell v2 +, 139 137 octets

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 octets à expliquer, car il ^ne s'agit pas d'un opérateur natif dans PowerShell. Sauvegardé 2 octets grâce à @TessellatingHeckler.

Prend entrée comme $a=<word>, $b=<operation>comme .\universal-spooky-meme.ps1 2spooky4me ^3. Nous -split $autilisons des chiffres, qui sont entre parenthèses afin de conserver les délimiteurs et de diriger le tableau résultant dans une boucle |%{...}. Si la pièce actuelle est un nombre, nous sommes dans le premier if. Nous devons vérifier si le premier caractère de $best ^. Si ce n'est pas le cas, nous concaténons simplement notre document actuel $bet l'envoyons à iex(similaire à eval), puis nous le conservons dans le pipeline. Sinon, nous devons créer une chaîne d'exponentiation avec "$_*"*$b.Trim('^')+1et le diriger vers iexet le laisser dans le pipeline. Pour l' 2spooky4me ^3exemple donné , ce sera 2*2*2*1et 4*4*4*1, respectivement.

Sinon, nous laissons la chaîne telle quelle dans le pipeline.

Tous ces résultats sont rassemblés à partir du pipeline avec les parens encapsulants avant d'être -joinrassemblés dans une chaîne. C’est le reste sur le pipeline et la sortie est implicite à la fin du programme.

Exemples

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 octets

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

Edit: Sauvegardé 1 octet quand je me souvenais que cela replacefonctionne également sur les chaînes littérales.

Pyth, 29

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

Cela fonctionne en extrayant chaque numéro du meme, puis en l'entrelacant ( .i), suivi d'un espace et d'une liste avec l'autre argument. Donc , si notre numéro est 7et nous avions ^20nous obtiendrions la liste: ["^", "7 ", "20"]. L'aplatissement et l'utilisation de Pyth's eval( .v) sur ceci donne toujours l'opération souhaitée. Enfin, ces valeurs sont entrelacées avec la chaîne d'origine divisée en occurrences de nombres.

Cela pourrait être un octet plus court si les deux entrées étaient entourées de guillemets, ou deux octets plus courts si un seul d'entre eux pouvait être cité.

Essayez-le ici ou lancez une suite de tests

Python 2, 156 89 88 87 octets

Inspiré par les autres réponses qui utilisent la fonction de substitution de leurs langues avec un gestionnaire de fonctions pour traiter les parties numériques de la longue ichaîne de caractères avec le operateur. Pas de chance pour Python, le ^doit être remplacé par **, ce qui coûte un énorme 18 octets. L' .group(0)appel juste pour accéder à la représentation sous forme de chaîne de l' objet match ne améliore pas les choses ...

Merci à QPaysTaxes pour avoir repéré un espace parasite et à RootTwo pour l’argument inutile de .group!

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

Javascript (ES6) 99 octets

Autre exemple, pourquoi nous détestons attendre qu'ES7 soit compatible

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

Exemple exécutable:

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 octets

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

La nécessité d'utiliser bigsi disponible rend cela beaucoup plus long que cela pourrait être ...

Essayez-le en ligne!

Kotlin, 416 413 octets

L'absence de eval()code dans Kotlin a vraiment augmenté le nombre d'octets ...

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()}));}}

Essayez-le en ligne!

Ungolfed

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 octets

# 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'\..*'"}})

(les nouvelles lignes ne sont là que pour éviter le défilement horizontal, elles fonctionnent lorsqu'elles sont enregistrées sur une seule ligne).

Commentaires, et la version non-golfée a été demandée:

$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 bibliothèque de regex .Net peut remplacer le script par un script qui s’exécute sur le contenu de la correspondance. PowerShell convertit les chaînes de types en nombres, iexcomme eval()dans d’autres langues. C'est juste "2spooky" "+3"->eval("2+3")
• Sauf que ... il ne peut pas gérer l' ^opérateur ou toute autre exponentiation commode **, il ne peut utiliser que l'appel de la [math]::Pow()bibliothèque, il y a donc un gros bloc pour gérer cette branche.
  • La version mise à jour vole une idée de @TimmyD et effectue à la place une multiplication de chaînes - "2*" * nqui devient "2*2*2*2*"et ajoute +1à la fin pour multiplier par un au lieu de se plaindre de la fin *.
• Sauf que ... .Net fait l'arrondi de Banker qui arrondit au nombre pair le plus proche par défaut, et 3/2 = 2 au lieu de 3/2 = 1. Ce défi appelle la troncature, et cela signifie [math]::Truncate(). Au lieu de cela, je sauve des personnages en utilisant -replacepour couper un point décimal et tout ce qui suit.

Cas de test:

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

NB Dans le dernier test, les nombres débordent [BigInteger]automatiquement dans le type , mais ils sont restitués en notation scientifique. Heureusement, chaque race connue capable de communiquer entre les étoiles possède suffisamment de développement scientifique pour pouvoir traiter la notation scientifique sans problème.

Bash + coreutils GNU, 144 octets

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=; }
}

Cela examine la modification entre chiffres et non-chiffres, c'est pourquoi un caractère de saisie aléatoire non valide (virgule) est ajouté à la chaîne de saisie. Cette virgule est alors ignorée dans la sortie. La convention de l'OP suit exactement la syntaxe bcutilisée ici pour faire le calcul.

Lua, 145 93 octets

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

R, 163 octets

En tant que personne qui apprend les expressions régulières et la substitution de chaînes dans R, cela s’est avéré être un défi assez difficile. Surtout parce que faire correspondre les chiffres est facile mais je ne pouvais pas trouver un moyen d'utiliser plusieurs substitutions avec gsub. De plus, je ne sais pas si eval(parse(paste0(...c’est le moyen le plus efficace de passer d’une opération à l’autre. Peut-être que la switchfonction est mieux adaptée ici.

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="")}

Explication

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 octets

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

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

Ungolfed:

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 octets

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

Remplace toutes les occurrences de chiffres par une fermeture qui évalue l'opération sur les portions de chiffres du mot passé. Si une fonction exposant est passée, elle la remplace par la notation appropriée. Groovy gère implicitement la conversion BigInteger / BigDecimal lorsqu’il est utilisé, Eval.me()car les chaînes analysées peuvent être potentiellement hors de la 2^32-1plage.

A expliqué

{a,b->...} - Fermeture avec deux arguments.

a.replaceAll(/\d+/,{...}) - Recherchez toutes les séquences de chiffres dans la chaîne et remplacez-les par une fermeture.

{Eval.me(it+b.replace("^","**"))} - Plus spécifiquement, une fermeture à chaque match ayant l'opération annexée, puis évaluée comme un code groovy.

.replace("^","**")- Remplacez la première instance de ^l'opérateur groovy exposant **dans l'opération fournie. Si vous voulez que cela fonctionne avec des chaînes d'équation complètes qui utilisent des exposants, utilisez replaceAll()plutôt une pénalité de +3 octets.

Fun side-note his est un scénario de test valide:
(22348952345238905290858906209862398036spooky409552me, /200*4943^8-23939+((100/203)+600)

RProgN , 39 octets

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

A expliqué

►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. 

Réponse techniquement invalide, parce que cette langue n’existait pas pour elle. Cependant, il n'a pas été spécifiquement conçu pour cela, ni aucun ajout particulier. Donc je le lance. Me poursuivre en justice.

Essayez-le en ligne!

Perl 6, 111 octets

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

Malheureusement, il EVALest désactivé par défaut. En outre, vous devez utiliser divpour la division entière.