Universal Spooky Meme Translator

43

Introdução

Acontece que os alienígenas amam memes tanto quanto nós. Toda raça alienígena que encontramos até agora tem sua própria versão 2spooky4me(veja a pergunta seguinte ) e equivalente, no entanto, com algumas variações. Os habitantes do planeta CUTE1f não conseguem lidar com muito fantasma, então o 1spooky2mefantasma preferido deles é , enquanto os membros do skeletor7 os amam, então eles tendem a usar 9spooky11me.

Desafio

Traduzir memes é um trabalho árduo, então você foi encarregado de escrever um tradutor universal de memes para ajudar esses caras a acessar o memenet corretamente. Seu programa aceitará um meme e uma transformação para aplicar às seqüências de dígitos desse meme para torná-lo apropriado para os habitantes de um planeta diferente.

Entrada

Seu programa receberá duas entradas de sequência:

  1. O meme de entrada (por exemplo 2spooky4me). Jogos [a-zA-Z0-9]+.
  2. A transformação a ser aplicada a ela (por exemplo +1, para passar de 2spooky4mepara 3spooky5me). Jogos [+\-*/^]\d+(você deve aceitar +, -, *, /, e ^como operadores, independentemente da representação nativa na sua língua).

Resultado

Seu programa deve retornar uma saída de sequência (impressa na saída padrão ou equivalente) com a transformação fornecida aplicada às seqüências de dígitos no meme de entrada. Em uma mudança estranha de eventos, também acontece que todas as raças encontradas até agora preferem memes integrais a memes fracionários, portanto essas transformações devem executar aritmética inteira (por exemplo, 1spooky1me /2deve resultar em 0spooky0me).

Exemplos

As operações aritméticas padrão se aplicam:

Input:  2spooky4me +1
Output: 3spooky5me

Input:  2spooky4me -1
Output: 1spooky3me

Input:  2spooky4me *15
Output: 30spooky60me

Input:  10spooky900me /5
Output: 2spooky180me

Sequências de dígitos são integrais; truncamento inteiro deve ocorrer em casos como este:

Input:  idontunderstandmemes3 /2
Output: idontunderstandmemes1

Sua entrada pode não ter nenhuma sequência de dígitos:

Input:  notreallyafunnymeme *100
Output: notreallyafunnymeme

Você deve oferecer suporte à exponenciação, mesmo que não seja uma operação nativa no idioma de sua escolha:

Input:  2spooky4me ^3
Output: 8spooky64me

Não há limite para o comprimento da string do número de seqüências de dígitos na string:

Input:  some1meme2sequences3can4be5really6long7 /2
Output: some0meme1sequences1can2be2really3long3

Termo aditivo

Se seu idioma suportar números inteiros de precisão arbitrária como um recurso de idioma, você deverá usá-los. Caso contrário, não é necessário oferecer suporte a números inteiros de precisão arbitrária. Por exemplo, você deve usar o IntegerHaskell em vez de Intestar disponível como parte do idioma; em Java, você não precisa usar BigIntegerporque é um recurso de biblioteca, não um recurso de idioma.

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

Isso é código-golfe , portanto , brechas comuns são proibidas e a resposta mais curta em bytes vence!

Entre os melhores

O snippet de pilha na parte inferior desta postagem gera o cabeçalho das respostas a) como uma lista da solução mais curta por idioma eb) como um cabeçalho geral.

Para garantir que sua resposta seja exibida, inicie-a com um título, usando o seguinte modelo de remarcação:

## Language Name, N bytes

onde Nestá o tamanho do seu envio. Se você melhorar sua pontuação, poderá manter as pontuações antigas no título, identificando-as. Por exemplo:

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

Se você quiser incluir vários números no cabeçalho (por exemplo, porque sua pontuação é a soma de dois arquivos ou você deseja listar as penalidades do sinalizador de intérpretes separadamente), verifique se a pontuação real é o último número no cabeçalho:

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

Você também pode transformar o nome do idioma em um link que será exibido no snippet:

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

Mostrar snippet de código

code-golf  string  math  subsequence 
— Itai Ferber
fonte
3
Seu último caso de teste está errado. Você tem muitos zeros na saída para que seja / 5.
— Nic Hartley
5
Antes de tudo, este é um primeiro post razoavelmente bem organizado, então parabéns :) Observe que temos um Sandbox onde você pode postar seu desafio para receber feedback antes que ele seja publicado.
— FryAmTheEggman
3
Bem-vindo ao PPCG (mesmo que você esteja aqui há mais de 2 anos). Bom primeiro desafio. O adendo sobre números inteiros de precisão arbitrários exige que, por exemplo, Java deva usar BigIntegerpara seus cálculos?
— AdmBorkBork
18
Toda raça alienígena que encontramos até agora ... Isso é totalmente verdade! :-)
— Luis Mendo
2
É seu desafio e, em última instância, depende de você, mas isso não é realmente justo com idiomas que usam uma sintaxe diferente.
— Dennis

Respostas:

10

Jolf, 15 14 bytes

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

Experimente aqui!

Explicação

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

É interessante notar que atualizei o Jolf após esse desafio, adicionando alguns recursos internos do RegExp. Pode ser 12 11 bytes:

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

Ruby, 50 44 43 bytes

Resposta FGITW. Tenho que ir rápido!

Obrigado a @Neil por salvar 6 bytes.

Oh certo, riscado 44 ainda é 44

->m,t{m.gsub(/\d+/){eval$&+t.sub(?^,'**')}}
— Value Ink
fonte
Oh, cara, isso é quase exatamente uma resposta que eu estava cutucando afastado em: a=gets;$><<gets.gsub(/\d+/){eval$&+a}. A minha perdeu a coisa ^! = ** e, provavelmente, é um pouco mais longa.
— Nic Hartley
3
+1 por ter toda a sua solução quatro bytes mais curta do que o necessário no PowerShell para lidar ^. : D
— AdmBorkBork
15

Perl, 36 34 bytes

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

O código fonte tem 30 bytes e requer os comutadores -pi( +4 bytes ). Leva a primeira entrada de STDIN, a segunda entrada como argumento para -i.

Graças a @DenisIbaev por jogar fora 2 bytes!

Teste em Ideone .

— Dennis
fonte
Sim, eu percebi que se alguém poderia bater minha resposta Ruby, seria Dennis e / ou estar em Perl, e você acabou cumprindo tanto as expectativas, ao mesmo tempo
— Valor Ink
1
-pié de 4 bytes?
— CalculatorFeline
@CatsAreFluffy O consenso atual é contar a distância de edição da chamada sem os sinalizadores. Isso inclui um espaço para separar -pio resto do comando.
— Dennis
"0|$&"é mais curto que "0|".$&.
— Denis Ibaev 16/05
@ DenisIbaev Como a entrada é alfanumérica, "0|$&$^I"também funciona. Obrigado!
— Dennis
9

PowerShell v2 +, 139 137 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 apenas para explicar, ^pois esse não é um operador nativo no PowerShell. Economizou 2 bytes graças a @TessellatingHeckler.

Toma de entrada como $a=<word>, $b=<operation>, como .\universal-spooky-meme.ps1 2spooky4me ^3. Colocamos os -split $adígitos entre parênteses para manter os delimitadores e canalizar a matriz resultante através de um loop |%{...}. Se a peça atual é um número, estamos na primeira if. Precisamos verificar se o primeiro caractere de $bé ^. Caso contrário, concatenamos nossa peça atual $be a enviamos para iex(semelhante a eval), deixando-a no pipeline. Caso contrário, precisamos criar uma cadeia de exponenciação com "$_*"*$b.Trim('^')+1e canalizar isso para iex, e deixá-lo no pipeline. Para o 2spooky4me ^3exemplo dado , este será 2*2*2*1e 4*4*4*1, respectivamente.

Caso contrário, deixamos a string como está no pipeline.

Todos esses resultados são coletados do pipeline com os parênteses de encapsulamento antes de serem -joinreunidos novamente em uma sequência. Essa é a re-esquerda no pipeline e a saída está implícita na finalização do programa.

Exemplos

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
Eu escrevi as minhas antes de olhar para as respostas, e também belisquei algumas de suas idéias - obrigado. Eu acho que você poderia substituir Floor(("$_$b"|iex))por Floor((iex $_$b))salvar um casal, ou talvez iex $_+$b.
— TessellatingHeckler
@TessellatingHeckler Obrigado pelos dois bytes!
— AdmBorkBork
8

JavaScript (ES7), 58 57 bytes

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

Edit: Salvo 1 byte quando me lembrei que replacetambém funciona em seqüências de caracteres literais.

— Neil
fonte
Legal, eu estou trabalhando em uma solução ES6
— Bálint
Você pode curry para salvar um byte?
— Gcampbell 15/05
1
@ gcampbell Sim, mas estou com preguiça de.
— Neil
6

Pyth, 29

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

Isso funciona extraindo cada número do meme e, em seguida, intercalando ( .i), seguido de um espaço e envolvido em uma lista com o outro argumento. Portanto, se o nosso número é 7e tivemos ^20que iria obter a lista: ["^", "7 ", "20"]. Achatar e usar Pyth's eval( .v) sempre dão a operação que queremos. Finalmente, esses valores são intercalados com a string original dividida nas ocorrências de números.

Pode ser um byte mais curto se as duas entradas estiverem entre caracteres de aspas ou dois bytes mais curto se apenas uma delas puder ser citada.

Experimente aqui ou execute um Conjunto de Testes

— FryAmTheEggman
fonte
6

Python 2, 156 89 88 87 bytes

Inspirado nas outras respostas que usam a função de substituição de seus idiomas com um manipulador de funções para processar as partes numéricas da icadeia de caracteres de entrada longa com o operator. Para azar do Python, ele ^deve ser substituído por **, que custa 18 bytes. A .group(0)chamada apenas para acessar a representação de string do objeto de correspondência não melhora as coisas ...

Obrigado ao QPaysTaxes por detectar um espaço falso e ao RootTwo pelo argumento desnecessário .group!

import re
lambda i,o:re.sub(r'\d+',lambda p:str(eval(p.group()+o.replace('^','**'))),i)
— ojdo
fonte
Eu acho que você pode se livrar do espaço depoisi,o:
— Nic Hartley
Você pode salvar mais dois bytes: (1) usando p.group(). (o padrão é 0); e (2) inserir r=re.sub;substituir primeira re.subchamada com re, em seguida, utilizar r('^','**',o)em vez deo.replace(...)
— RootTwo
@RootTwo: Para mim, o r('^','**',o)então precise de escapar ^para \^a fim de coincidir com o personagem, não o início de olíquido não poupando bytes :-( - mas Obrigado por apontar o desnecessário 0!
— ojdo
5

Javascript (ES6) 99 bytes

Outro exemplo, por que odiamos esperar que o ES7 obtenha compatibilidade

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

Exemplo executável:

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 snippet

— Bálint
fonte
Suas expressões regulares parecem estar um pouco erradas. No exemplo executável, você deixa de fora letras maiúsculas, o que as remove do resultado ("2spooky4ME", "+1" => "3spooky5") e, no primeiro exemplo, você faz a correspondência \d+|\D+, o que é equivalente a .+. [a-zA-Z0-9]+é o regex que você quer, não? Ou [a-zA-Z]+|[0-9]+se a divisão faz a diferença?
— Itai Ferber
Provavelmente seria mais fácil invocar Math.powdiretamente, já que você está precisando fazer um caso especial. Além disso, você está usando divisão inteira?
— Neil
@Neil eu esqueci que, minutos
— Bálint
@ Neil existe uma maneira melhor de teto?
— Bálint
1
@ItaiFerber \d+|\D+Não é exatamente o mesmo que .+. Eles não são os mesmos porque a expansão kleene acontece antes da or. Seria o mesmo se parecesse (\d|\D)+, mas, como é, não corresponderia a todos, digamos, 2aem um grupo, seriam dois grupos separados.
— FryAmTheEggman
5

Julia, 71 59 54 bytes

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

O requisito de uso, bigse disponível, torna isso muito mais longo do que poderia ser ...

Experimente online!

— Dennis
fonte
4

Kotlin, 416 413 bytes

A falta de um eval()em Kotlin realmente aumentou a contagem 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()}));}}

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

(as novas linhas estão aqui apenas para evitar a rolagem horizontal; elas funcionam quando salvas como uma linha).

Foram solicitados comentários e versão ungolfed:

$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)
  • A biblioteca regex .Net pode substituir por um bloco de script que é executado no conteúdo da correspondência, e o PowerShell converte seqüências de caracteres de tipos em números e iexé como eval()em outros idiomas. Apenas faz "2spooky" "+3"->eval("2+3")
  • Exceto ... ele não pode lidar com o ^operador ou qualquer outra exponenciação conveniente como **, ele só pode usar a [math]::Pow()chamada de biblioteca para que haja um grande bloco para lidar com esse ramo.
    • A versão atualizada rouba uma ideia do @TimmyD e, em vez disso, multiplica as strings - "2*" * nque se torna "2*2*2*2*"e depois adiciona +1ao final a multiplicação por uma, em vez de reclamar sobre o final *.
  • Exceto ... .Net faz o arredondamento do banqueiro, que arredonda para o número par mais próximo por padrão e 3/2 = 2 em vez de 3/2 = 1. Esse desafio exige truncamento, e isso significa [math]::Truncate(). Em vez disso, salvei caracteres usando -replacepara aparar um ponto decimal e qualquer coisa depois dele.

Casos de teste:

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 No último teste, os números [BigInteger]passam para o tipo automaticamente, mas são renderizados em notação científica. Felizmente, toda raça conhecida, capaz de se comunicar entre as estrelas, tem desenvolvimento científico suficiente para processar a notação científica sem problemas.

— TessellatingHeckler
fonte
1
Você pode ver em outras respostas como eles fornecem uma versão em golfe bastante ilegível e, em seguida, uma versão em separado, não destruída, para examinar o comportamento do código. Você deve fazer isso com o seu (a saber, remover as novas linhas na versão em golfe).
— Jpmc26
Obrigado pelo crédito, mas não pelo meu truque - retirei-o do tópico Dicas do PowerShell.
— AdmBorkBork 16/05
Aparentemente, eu me importo o suficiente para deixar um comentário, e outra pessoa se importa o suficiente para aprovar meu comentário. ;)
— jpmc26 16/05
Não, eu disse que você deveria ter uma versão totalmente golfe e uma versão totalmente não destruída. O jogador de golfe precisará de rolagem. O não-golpeado não será e será mais legível do que o que você possui.
— Jpmc26 16/05/2019
1
@ jpmc26 Ok, editei em uma versão comentada e não-gasta.
— TessellatingHeckler
3

Coreutils do Bash + GNU, 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=; }
}

Isso examina a alteração entre dígitos e não dígitos, é por isso que um caractere de entrada inválido aleatório (vírgula) é anexado à sequência de entrada. Essa vírgula é então ignorada na saída. A convenção do OP segue exatamente a sintaxe bcusada aqui para fazer as contas.

— rexkogitans
fonte
A propósito, devido à discussão na solução do PowerShell por @TessellatingHeckler: Na minha solução, você pode converter o programa em uma única linha substituindo as quebras de linha por ponto e vírgula, o que não altera seu tamanho.
— Rexkogitans 17/05/19
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)
— Blab
fonte
Por que não postar apenas uma função?
— Bálint
2

R, 163 bytes

Como alguém que está aprendendo expressões regulares e substituição de cordas em R, isso provou ser um desafio bastante difícil. Especialmente porque combinar os números é fácil, mas não consegui encontrar uma maneira de usar várias substituições gsub. Além disso, não sei se eval(parse(paste0(...é a maneira mais eficiente de alternar entre operações. Talvez a switchfunção-seja mais adequada aqui.

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

Explicação

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
Acho que você pode economizar uma tonelada de bytes se usar o gsub com um encerramento nas correspondências, que é o que você sugeriu no seu comentário. Eu não sei como fazê-lo em R. Eu lutei com isso também até descobrir como fazer isso no Groovy; foi praticamente um divisor de águas.
— Magic Octopus Urn
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"));

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
Alguém sabe se posso dividir espaços usando o operador Spread? A partir deste s.split (""); para% s]; Pelo menos essa é a ideia.
— Bladimir Ruiz 13/10
Você não precisa ()ao redor do argumento lambda, você não precisa var, e você deve usar parênteses e o operador de vírgula em vez de chaves ereturn
— Cyoce
Além disso, ^é um caso especial para JavaScript, é um XOR bit a bit em vez de #Math.pow
— Sunny Pun
2

Groovy, 64 60 bytes

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

Substitui todas as instâncias de dígitos por um fechamento que avalia a operação nas partes dos dígitos da palavra passada. Se aprovada uma função de expoente, ela será substituída pela notação adequada. O Groovy manipula implicitamente a conversão BigInteger / BigDecimal ao usá-lo Eval.me()porque as seqüências de caracteres analisadas podem estar fora do 2^32-1intervalo.

Explicado

{a,b->...} - Encerramento com dois argumentos.

a.replaceAll(/\d+/,{...}) - Pesquise todas as seqüências de dígitos na string e substitua por um fechamento.

{Eval.me(it+b.replace("^","**"))} - Mais especificamente, um fechamento com cada partida tendo a operação anexada a ela e depois avaliada como um código groovy.

.replace("^","**")- Substitua a primeira instância do ^operador com expoente de groovy **na operação fornecida. Se você deseja que isso funcione com cadeias de equação completas que usam expoentes, use replaceAll()uma penalidade de +3 bytes.

Nota lateral divertida é um cenário de teste válido:
(22348952345238905290858906209862398036spooky409552me, /200*4943^8-23939+((100/203)+600)

— Urna de polvo mágico
fonte
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.

Resposta tecnicamente inválida, porque esse idioma não existia. No entanto, não foi projetado especificamente para isso, nem qualquer adição específica. Então, eu estou executando. Processe-me.

Experimente Online!

— ATaco
fonte
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}

Infelizmente EVALestá desativado por padrão. Além disso, você deve usar divpara divisão inteira.

— bb94
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.