Universal Spooky Meme Translator

43

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

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

Itai Ferber
la source
3
Votre dernier cas de test est faux. Vous avez trop de zéros dans la sortie pour que ce soit / 5.
Nic Hartley
5
Tout d’abord, c’est un premier poste assez bien rédigé, alors félicitations :) Notez que nous avons un bac à sable où vous pouvez poster votre défi pour commentaires avant sa mise en ligne.
FryAmTheEggman
3
Bienvenue à PPCG (même si, apparemment, vous êtes ici depuis plus de 2 ans). Beau premier défi. L'addenda relatif aux entiers à précision arbitraire indique-t-il que Java doit par exemple utiliser BigIntegerses calculs?
AdmBorkBork
18
Toutes les races extraterrestres que nous avons rencontrées jusqu'à présent ... C'est totalement vrai! :-)
Luis Mendo
2
C'est votre défi et, en fin de compte, à vous de décider, mais ce n'est pas vraiment juste envers les langages qui utilisent une syntaxe différente.
Dennis

Réponses:

10

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
Conor O'Brien
la source
24

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(?^,'**')}}
Valeur d'encre
la source
Oh, l' homme, ce qui est presque exactement une réponse que je poussais loin à: a=gets;$><<gets.gsub(/\d+/){eval$&+a}. Le mien a raté le ^! = **, cependant, et est probablement un peu plus long.
Nic Hartley
3
+1 pour que votre solution entière soit plus courte de 4 octets que ce qui est nécessaire dans PowerShell, rien que pour le gérer ^. : D
AdmBorkBork
15

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 .

Dennis
la source
Oui, j'ai pensé que si quelqu'un pouvait battre ma réponse Ruby, ce serait Dennis et / ou être en Perl, et vous avez fini par satisfaire les deux attentes en même temps
Value Ink
1
-piest 4 octets?
CalculatriceFeline
@CatsAreFluffy Le consensus actuel est de compter la distance d'édition depuis l'invocation sans les drapeaux. Cela inclut un espace pour se séparer -pidu reste de la commande.
Dennis
"0|$&"est plus court que "0|".$&.
Denis Ibaev
@DenisIbaev Puisque l'entrée est alphanumérique, "0|$&$^I"fonctionne aussi. Merci!
Dennis
9

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
AdmBorkBork
la source
J'ai écrit le mien avant de regarder les réponses, puis j'ai aussi pincé certaines de vos idées - merci. Je pense que vous pourriez remplacer Floor(("$_$b"|iex))par Floor((iex $_$b))sauver un couple, ou peut-être iex $_+$b.
TessellatingHeckler
@TessellatingHeckler Merci pour les deux octets!
AdmBorkBork,
8

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.

Neil
la source
Cool, je travaille sur une solution ES6
Bálint
Pouvez-vous curry pour sauver un octet?
Gcampbell
1
@ gcampbell Oui, mais je suis trop paresseux pour.
Neil
6

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

FryAmTheEggman
la source
6

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)
ojdo
la source
Je pense que vous pouvez vous débarrasser de l'espace aprèsi,o:
Nic Hartley
Vous pouvez enregistrer deux autres octets: (1) en utilisant p.group(). (la valeur par défaut est 0); et (2) insérez, r=re.sub;remplacez le premier re.subappel avec rpuis utilisez à la r('^','**',o)place deo.replace(...)
RootTwo
@RootTwo: Pour moi, r('^','**',o)il faut alors s'évader ^pour \^faire correspondre le personnage, pas le début de o, ne pas enregistrer d'économies nettes :-( - mais merci de signaler l'inutile 0!
ojdo
5

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

Bálint
la source
Vos expressions rationnelles correspondantes semblent être un peu en retrait. Dans l'exemple exécutable, vous omettez les lettres majuscules, ce qui les supprime du résultat ("2spooky4ME", "+1" => "3spooky5") et, dans le premier exemple, vous comparez \d+|\D+, ce qui équivaut à .+. [a-zA-Z0-9]+est la regex que vous voulez, non? Ou [a-zA-Z]+|[0-9]+si le fractionnement fait une différence?
Itai Ferber
Il serait probablement plus facile d'invoquer Math.powdirectement, car vous devez quand même le faire dans des cas particuliers. Aussi, utilisez-vous la division entière?
Neil
@Neil J'ai oublié ça, minute
Bálint
@ Neil est-il un meilleur moyen de plafond?
Bálint
1
@ ItaiFerber \d+|\D+n'est pas tout à fait la même chose que .+. Ils ne sont pas les mêmes parce que l 'expansion de kleene se produit avant le or. Ce serait la même chose si cela ressemblait (\d|\D)+, mais comme cela, cela ne correspondrait pas à tous, disons 2adans un groupe, ce serait deux groupes séparés.
FryAmTheEggman
5

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!

Dennis
la source
4

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() }))
    }
}
The_Lone_Devil
la source
4

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.

TessellatingHeckler
la source
1
Vous pouvez voir dans d'autres réponses comment ils fournissent une version golfée plutôt illisible, puis une version séparée non-lue pour examiner le comportement du code. Vous devriez le faire avec le vôtre (notamment, supprimer les nouvelles lignes de la version jouée au golf).
JPMc26
Merci pour le crédit, mais pas mon astuce - je l'ai extraite du fil PowerShell Tips.
AdmBorkBork
Apparemment, je me soucie suffisamment de laisser un commentaire, et quelqu'un d'autre se soucie assez de relire mon commentaire. ;)
jpmc26
Non, j'ai dit que vous devriez avoir une version entièrement golfée et une version totalement non-golfée. Le golfé nécessitera un défilement. Le non-golfé ne sera pas et sera plus lisible que celui que vous avez.
JPMc26
1
@ jpmc26 Ok, j'ai édité une version commentée et non unie.
TessellatingHeckler
3

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.

rexkogitans
la source
A propos, en raison de discussions dans la solution PowerShell de @TessellatingHeckler: Dans ma solution, vous pouvez traduire le programme en une seule ligne en remplaçant les sauts de ligne par des points-virgules, ce qui ne modifie pas sa longueur.
rexkogitans
3

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)
Jaser
la source
Pourquoi ne pas simplement poster une fonction?
Bálint,
2

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
}
Billywob
la source
Je pense que vous pouvez économiser une tonne d'octets si vous utilisez gsub avec une fermeture sur les allumettes, ce que vous avez laissé entendre dans votre commentaire. Je ne sais pas comment le faire dans R cependant. J'ai eu du mal avec ça aussi jusqu'à ce que j'ai découvert comment faire ça dans Groovy; était à peu près un changeur de jeu.
Urne magique Octopus
2

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"));
Bladimir Ruiz
la source
Quelqu'un sait si je peux diviser des espaces en utilisant l'opérateur Spread? De ce s.split (""); to ["" ... s]; Au moins c'est l'idée.
Bladimir Ruiz
Vous n'avez pas besoin de ()contourner l'argument lambda, vous n'avez pas besoin var, et vous devriez utiliser parens et l'opérateur virgule au lieu d'accolades etreturn
Cyoce
En outre, ^est un cas spécial pour JavaScript, il est un bitwise XOR au lieu deMath.pow
Sunny Pun
2

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)

Urne Magique De Pieuvre
la source
1

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!

ATaco
la source
0

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.

bb94
la source