Traduttore universale di meme spettrale

43

introduzione

Si scopre che gli alieni amano i meme tanto quanto noi. Ogni razza aliena che abbiamo incontrato finora ha la sua versione di 2spooky4me(vedi la domanda seguente ) ed equivalente, tuttavia, con alcune variazioni. Gli abitanti del pianeta CUTE1f non riescono a gestire molti spettri, quindi il loro spook preferito è 1spooky2me, mentre i memer di skeletor7 li adorano, quindi tendono ad usarli 9spooky11me.

Sfida

Tradurre meme è un duro lavoro, quindi ti è stato assegnato il compito di scrivere un traduttore meme universale per aiutare questi ragazzi ad accedere correttamente al memenet. Il tuo programma accetterà un meme e una trasformazione da applicare alle sequenze di cifre in quel meme per renderlo appropriato per gli abitanti di un altro pianeta.

Ingresso

Il tuo programma riceverà due input di stringa:

  1. Il meme di input (ad es 2spooky4me.). Matches [a-zA-Z0-9]+.
  2. La trasformazione da applicare ad essa (ad esempio +1, per passare da 2spooky4mea 3spooky5me). Partite [+\-*/^]\d+(è necessario accettare +, -, *, /, e ^come gli operatori, indipendentemente dalla rappresentazione nativa nella vostra lingua).

Produzione

Il programma deve restituire un output di stringa (stampato su output standard o equivalente) con la trasformazione specificata applicata alle sequenze di cifre nel meme di input. In una strana svolta di eventi, si scopre anche che tutte le razze incontrate finora preferiscono meme integrali rispetto a quelle frazionarie, quindi queste trasformazioni dovrebbero eseguire l'aritmetica dei numeri interi (ad es. 1spooky1me /2Dovrebbe comportare 0spooky0me).

Esempi

Si applicano le operazioni aritmetiche standard:

Input:  2spooky4me +1
Output: 3spooky5me

Input:  2spooky4me -1
Output: 1spooky3me

Input:  2spooky4me *15
Output: 30spooky60me

Input:  10spooky900me /5
Output: 2spooky180me

Le sequenze di cifre sono integrali; il troncamento dei numeri interi dovrebbe avvenire in questi casi:

Input:  idontunderstandmemes3 /2
Output: idontunderstandmemes1

Il tuo input potrebbe non avere sequenze di cifre:

Input:  notreallyafunnymeme *100
Output: notreallyafunnymeme

Devi supportare l'espiazione, anche se non è un'operazione nativa nella tua lingua preferita:

Input:  2spooky4me ^3
Output: 8spooky64me

Non c'è limite alla lunghezza della stringa del numero di sequenze di cifre nella stringa:

Input:  some1meme2sequences3can4be5really6long7 /2
Output: some0meme1sequences1can2be2really3long3

appendice

Se la tua lingua supporta numeri interi di precisione arbitraria come funzionalità della lingua, devi usarli. In caso contrario, non è necessario supportare numeri interi di precisione arbitraria. Ad esempio, è necessario utilizzare Integerin Haskell anziché Intperché è disponibile come parte della lingua; in Java, non è necessario utilizzare BigIntegerperché è una funzione di libreria, non una funzione di lingua.

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

Si tratta di code-golf , quindi le scappatoie standard sono vietate e vince la risposta più breve in byte!

Classifica

Lo snippet di stack nella parte inferiore di questo post genera la classifica dalle risposte a) come un elenco della soluzione più breve per lingua eb) come classifica generale.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, usando il seguente modello Markdown:

## Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

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

Se si desidera includere più numeri nell'intestazione (ad es. Perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

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

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet:

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

Mostra snippet di codice

code-golf  string  math  subsequence 
— Itai Ferber
fonte
3
Il tuo ultimo test case è sbagliato. Hai uno zero in eccesso nell'output perché sia ​​/ 5.
— Nic Hartley,
5
Prima di tutto questo è un primo post ragionevolmente ben messo insieme, quindi complimenti :) Nota che abbiamo un Sandbox in cui puoi pubblicare la tua sfida per un feedback prima che diventi live.
— FryAmTheEggman,
3
Benvenuto in PPCG (anche se apparentemente sei qui da più di 2 anni). Bella prima sfida. L'addendum sugli interi di precisione arbitraria impone che, ad esempio, Java debba utilizzare BigIntegerper i suoi calcoli?
— AdmBorkBork,
18
Ogni razza aliena che abbiamo incontrato finora ... È assolutamente vero! :-)
— Luis Mendo,
2
È la tua sfida e alla fine dipende da te, ma non è proprio giusto nei confronti delle lingue che usano una sintassi diversa.
— Dennis,

Risposte:

10

Jolf, 15 14 byte

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

Provalo qui!

Spiegazione

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

Divertente da notare, ho aggiornato Jolf dopo questa sfida, aggiungendo alcuni built-in RegExp. Questo potrebbe essere 12 11 byte:

ρiLRdC!6+HI
— Conor O'Brien
fonte
24

Rubino, 50 44 43 byte

Risposta di FGITW. Devo andare veloce!

Grazie a @Neil per aver salvato 6 byte.

Oh giusto, barrato 44 è ancora 44

->m,t{m.gsub(/\d+/){eval$&+t.sub(?^,'**')}}
— Value Ink
fonte
Oh, l'uomo, questo è quasi esattamente la risposta che stavo colpendo via a: a=gets;$><<gets.gsub(/\d+/){eval$&+a}. Il mio ha mancato la cosa ^! = **, tuttavia, ed è probabilmente un po 'più lungo.
— Nic Hartley,
3
+1 per avere l'intera soluzione più corta di 4 byte rispetto a quella necessaria in PowerShell solo per gestirla ^. : D
— AdmBorkBork,
15

Perl, 36 34 byte

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

Il codice sorgente è lungo 30 byte e richiede gli switch -pi( +4 byte ). Prende il primo input da STDIN, il secondo input come argomento per -i.

Grazie a @DenisIbaev per il golf off 2 byte!

Provalo su Ideone .

— Dennis
fonte
Sì, ho pensato che se qualcuno potesse battere la mia risposta su Ruby, sarebbe Dennis e / o essere in Perl, e alla fine hai soddisfatto entrambe le aspettative
— Value Ink,
1
-piè di 4 byte?
— CalculatorFeline
@CatsAreFluffy Il consenso attuale è quello di contare la distanza di modifica dall'invocazione senza le bandiere. Ciò include uno spazio per separare -pidal resto del comando.
— Dennis,
"0|$&"è più corto di "0|".$&.
— Denis Ibaev,
@DenisIbaev Poiché l'input è alfanumerico, "0|$&$^I"funziona anche. Grazie!
— Dennis,
9

PowerShell v2 +, 139 137 byte

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 byte solo per tener conto del ^fatto che non è un operatore nativo in PowerShell. Salvato 2 byte grazie a @TessellatingHeckler.

Prende come ingresso $a=<word>, $b=<operation>come .\universal-spooky-meme.ps1 2spooky4me ^3. Siamo -split $asu cifre, racchiudendoli tra parentesi in modo da mantenere i delimitatori e reindirizzare l'array risultante attraverso un ciclo |%{...}. Se il pezzo corrente è un numero, siamo nel primo if. Dobbiamo verificare se il primo carattere di $bè ^. In caso contrario, concateniamo semplicemente il nostro pezzo corrente $be lo inviamo a iex(simile a eval), quindi lo lasciamo sulla pipeline. Altrimenti, dobbiamo creare una stringa di esponenziazione con "$_*"*$b.Trim('^')+1e pipe a quella iex, e lasciarla sulla pipeline. Per l' 2spooky4me ^3esempio dato , questo sarà 2*2*2*1e 4*4*4*1, rispettivamente.

Altrimenti, lasciamo la stringa così com'è sulla pipeline.

Tutti questi risultati vengono raccolti dalla pipeline con le parentesi incapsulanti prima di essere -joinrimessi insieme in una stringa. Questo è il ri-lasciato sulla pipeline e l'output è implicito al termine del programma.

Esempi

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
fonte
Ho scritto le mie prima di guardare le risposte, poi ho anche preso alcune delle tue idee - grazie. Penso che potresti sostituirlo Floor(("$_$b"|iex))con Floor((iex $_$b))per salvare un paio, o forse iex $_+$b.
— TessellatingHeckler,
@TessellatingHeckler Grazie per i due byte!
— AdmBorkBork,
8

JavaScript (ES7), 58 57 byte

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

Modifica: salvato 1 byte quando mi sono ricordato che replacefunziona anche su stringhe letterali.

— Neil
fonte
Bene, sto lavorando a una soluzione ES6
— Bálint,
Puoi curry per salvare un byte?
— gcampbell,
1
@gcampbell Sì, ma sono troppo pigro per.
— Neil,
6

Pyth, 29

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

Funziona estraendo ogni numero dal meme, quindi interleaving ( .i) seguito da uno spazio e racchiuso in un elenco con l'altro argomento. Quindi, se il nostro numero è 7e abbiamo avuto ^20avremmo ottenere l'elenco: ["^", "7 ", "20"]. Appiattire e usare Pyth's eval( .v) su questo dà sempre l'operazione che vogliamo. Alla fine questi valori vengono interlacciati con la stringa originale divisa in occorrenze di numeri.

Potrebbe essere un byte più breve se entrambi gli input fossero racchiusi tra virgolette o due byte più brevi se solo uno di essi potesse essere citato.

Provalo qui o esegui una Test Suite

— FryAmTheEggman
fonte
6

Python 2, 156 89 88 87 byte

Ispirato dalle altre risposte che usano la funzione di sostituzione delle loro lingue con un gestore di funzioni per elaborare le parti numeriche della lunga istringa di oinput con il peratore. Sfortunato per Python, ^deve essere sostituito da **, il che costa ben 18 byte. La .group(0)chiamata solo per accedere alla rappresentazione della stringa dell'oggetto match non migliora le cose ...

Grazie a QPaysTaxes per aver individuato uno spazio spurio e RootTwo per l'argomento inutile .group!

import re
lambda i,o:re.sub(r'\d+',lambda p:str(eval(p.group()+o.replace('^','**'))),i)
— ojdo
fonte
Penso che puoi liberarti dello spazio dopoi,o:
— Nic Hartley,
È possibile salvare altri due byte: (1) utilizzando p.group(). (il valore predefinito è 0); e (2) inserire r=re.sub;sostituire la prima re.subchiamata con re quindi utilizzare r('^','**',o)invece dio.replace(...)
— RootDue
@RootTwo: Per me, r('^','**',o)allora è necessario scappare ^per \^abbinare il personaggio, non l'inizio di o, il risparmio netto senza byte :-( - ma grazie per aver sottolineato l'inutile 0!
— ojdo,
5

Javascript (ES6) 99 byte

Un altro esempio, perché odiamo aspettare che ES7 ottenga la compatibilità

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

Esempio eseguibile:

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

— Bálint
fonte
Le tue regex corrispondenti sembrano essere un po 'fuori. Nell'esempio eseguibile, si tralasciano lettere maiuscole, che le rimuove dal risultato ("2spooky4ME", "+1" => "3spooky5"), e nel primo esempio si combina con \d+|\D+, che equivale a .+. [a-zA-Z0-9]+è la regex che vuoi, no? O [a-zA-Z]+|[0-9]+se la scissione fa la differenza?
— Itai Ferber,
Probabilmente sarebbe più facile invocare Math.powdirettamente in quanto è necessario in ogni caso. Inoltre, stai utilizzando la divisione intera?
— Neil,
@Neil L'ho dimenticato, minuto
— Bálint,
@Neil c'è un modo migliore per il soffitto?
— Bálint,
1
@ItaiFerber \d+|\D+Non è esattamente lo stesso di .+. Non sono gli stessi perché l'espansione kleene avviene prima del or. Sarebbe lo stesso se sembrasse (\d|\D)+, ma così com'è, non corrisponderebbe a tutti 2ain un gruppo, sarebbe due gruppi separati.
— FryAmTheEggman,
5

Julia, 71 59 54 byte

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

Il requisito da utilizzare bigse disponibile lo rende molto più lungo di quanto potrebbe essere ...

Provalo online!

— Dennis
fonte
4

Kotlin, 416 413 byte

La mancanza di un eval()in Kotlin ha davvero aumentato il conteggio dei byte ...

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

Provalo online!

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
fonte
4

PowerShell (v4), 124 120 byte

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

(le nuove righe sono qui solo per evitare lo scorrimento orizzontale, funzionano quando vengono salvate come una riga).

Commenti e versione non golfata richiesta:

$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 libreria di regex .Net può eseguire una sostituzione con uno scriptblock che viene eseguito sul contenuto della corrispondenza e PowerShell lancia stringhe di tipi in numeri ed iexè simile eval()in altre lingue. Fa solo "2spooky" "+3"->eval("2+3")
  • Tranne ... non può gestire l' ^operatore o qualsiasi altra esponenziale conveniente come **, può usare solo la [math]::Pow()chiamata in libreria quindi c'è un grosso blocco per gestire quel ramo.
    • La versione aggiornata ruba un'idea a @TimmyD e fa invece la moltiplicazione delle stringhe - "2*" * nche diventa "2*2*2*2*"e quindi aggiunge +1alla fine di moltiplicarsi per una invece di lamentarsi del trailing *.
  • Tranne ... .Net esegue l'arrotondamento del banco che si arrotonda al numero pari più vicino per impostazione predefinita e 3/2 = 2 anziché 3/2 = 1. Questa sfida richiede il troncamento e ciò significa [math]::Truncate(). Invece, salvo i caratteri usando -replaceper tagliare un punto decimale e qualsiasi cosa dopo.

Casi 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. Nell'ultimo test i numeri traboccano [BigInteger]automaticamente nel tipo , ma vengono resi in notazione scientifica. Fortunatamente, ogni razza nota in grado di comunicare tra le stelle ha abbastanza sviluppo scientifico per essere in grado di elaborare la notazione scientifica senza problemi.

— TessellatingHeckler
fonte
1
In altre risposte puoi vedere come forniscono una versione golf illeggibile e quindi una versione non golf separata per esaminare il comportamento del codice. Dovresti farlo con il tuo (vale a dire, rimuovere le newline nella versione golfata).
— jpmc26,
Grazie per il merito, ma non per il mio trucco: l'ho estratto dal thread dei suggerimenti di PowerShell.
— AdmBorkBork,
Apparentemente, mi interessa abbastanza per lasciare un commento, e qualcun altro si preoccupa abbastanza per votare il mio commento. ;)
— jpmc26,
No, ho detto che dovresti avere una versione completamente giocata a golf e una versione completamente non giocata. Quello golfizzato richiederà lo scorrimento. Il non golfizzato non sarà e sarà più leggibile di quello che hai.
— jpmc26,
1
@ jpmc26 Ok, l'ho modificato in una versione non commentata e commentata.
— TessellatingHeckler,
3

Coreutils Bash + GNU, 144 byte

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

Questo esamina l'alterazione tra cifre e non cifre, ecco perché un carattere di input (virgola) non valido casuale viene aggiunto alla stringa di input. Questa virgola viene quindi ignorata nell'output. La convenzione dell'OP segue esattamente la sintassi bcutilizzata qui per eseguire la matematica.

— rexkogitans
fonte
A proposito a causa della discussione nella soluzione PowerShell di @TessellatingHeckler: Nella mia soluzione, è possibile tradurre il programma in una singola riga sostituendo le interruzioni di riga in punti e virgola, che non cambia la sua lunghezza.
— rexkogitans,
3

Lua, 145 93 byte

r=io.read;m=r()o=r()m=m:gsub("%d",function(n)return loadstring("return..."..o)(n)end)print(m)
— spifferare
fonte
Perché non pubblicare semplicemente una funzione?
— Bálint,
2

R, 163 byte

Come qualcuno che sta imparando le espressioni regolari e la sostituzione delle stringhe in R, questa si è rivelata una sfida piuttosto difficile. Soprattutto perché abbinare i numeri è facile ma non sono riuscito a trovare un modo per utilizzare più sostituzioni gsub. Inoltre, non so se eval(parse(paste0(...sia il modo più efficiente per passare da una operazione all'altra. Forse la funzione switchè più adatta qui.

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

Spiegazione

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
fonte
Penso che puoi risparmiare un sacco di byte se usi gsub con una chiusura sulle partite, che è ciò a cui hai accennato nel tuo commento. Non so come farlo in R però. Ho lottato anche con quello finché non ho scoperto come farlo in Groovy; era praticamente un punto di svolta.
— Magic Octopus Urn,
2

Javascript (ES6), 85 byte

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
fonte
Qualcuno sa se posso dividere gli spazi usando l'operatore Spread? Da questo s.split (""); a ["" ... s]; Almeno questa è l'idea.
— Bladimir Ruiz,
Non hai bisogno ()dell'argomento lambda, non è necessario var, e dovresti usare parentesi e l'operatore virgola anziché parentesi graffe ereturn
— Cyoce
Inoltre, ^è un caso speciale di JavaScript, è un XOR bit a bit invece diMath.pow
— Sunny Pun
2

Groovy, 64 60 byte

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

Sostituisce tutte le istanze di cifre con una chiusura che valuta l'operazione sulle porzioni di cifre della parola passata. Se viene passata una funzione esponente, la sostituisce con la notazione corretta. Groovy gestisce implicitamente la conversione BigInteger / BigDecimal quando viene utilizzato Eval.me()perché le stringhe analizzate possono potenzialmente essere fuori 2^32-1dall'intervallo.

spiegato

{a,b->...} - Chiusura con due argomenti.

a.replaceAll(/\d+/,{...}) - Cerca tutte le sequenze di cifre nella stringa e sostituiscile con una chiusura.

{Eval.me(it+b.replace("^","**"))} - Più specificamente, una chiusura con ogni partita a cui è stata aggiunta l'operazione, quindi valutata come codice groovy.

.replace("^","**")- Sostituire la prima istanza di ^con l'operatore esponente scanalato **nell'operazione fornita. Se vuoi che funzioni con stringhe di equazioni complete che usano esponenti, usa replaceAll()invece una penalità di +3 byte.

La nota a margine divertente è uno scenario di test valido:
(22348952345238905290858906209862398036spooky409552me, /200*4943^8-23939+((100/203)+600)

— Urna di polpo magico
fonte
1

RProgN , 39 byte

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

spiegato

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

Risposta tecnicamente non valida, perché questa lingua non esisteva per essa. Tuttavia, non è stato progettato specificamente per esso, né alcuna aggiunta particolare. Quindi lo sto eseguendo. Fammi causa.

Provalo online!

— ATACO
fonte
0

Perl 6, 111 byte

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

Purtroppo EVALè disabilitato per impostazione predefinita. Inoltre, è necessario utilizzare divper la divisione di numeri interi.

— bb94
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.