Universal Spooky Meme Translator

43

介绍

事实证明，外星人像我们一样爱模因。到目前为止，我们遇到的每一个外星人种族都有自己的版本2spooky4me（请参见以下问题）和等效版本，但有所不同。CUTE1f星球上的居民无法承受很多鬼怪，因此他们更喜欢1spooky2me鬼怪，而skeletor7的迷们喜欢它们一些鬼怪，因此他们倾向于使用9spooky11me。

挑战

翻译模因是一项艰苦的工作，因此您要编写一个通用的模因翻译器，以帮助这些人正确访问模因网。您的程序将接受一个模因和一个变换，以应用于该模因中的数字序列，以使其适合其他星球的居民。

输入项

您的程序将收到两个字符串输入：

  1. 输入模因（例如2spooky4me）。火柴[a-zA-Z0-9]+。
  2. 要应用的转换（例如+1，从2spooky4me到3spooky5me）。匹配[+\-*/^]\d+（你必须接受+，-，*，/，并^为运营商，无论在你的语言本地表示的）。

输出量

您的程序必须返回字符串输出（打印到标准输出或等效输出），并将给定的转换应用于输入模因中的数字序列。在一系列怪异的事件中，结果还表明，到目前为止遇到的所有种族都喜欢积分模因而不是分数模因，因此这些转换应执行整数算术（例如1spooky1me /2应该产生0spooky0me）。

例子

标准算术运算适用：

Input:  2spooky4me +1
Output: 3spooky5me

Input:  2spooky4me -1
Output: 1spooky3me

Input:  2spooky4me *15
Output: 30spooky60me

Input:  10spooky900me /5
Output: 2spooky180me

数字序列是不可或缺的；整数截断应在以下情况下发生：

Input:  idontunderstandmemes3 /2
Output: idontunderstandmemes1

您的输入内容可能没有任何数字序列：

Input:  notreallyafunnymeme *100
Output: notreallyafunnymeme

即使您选择的语言不是本机运算，您也必须支持幂运算：

Input:  2spooky4me ^3
Output: 8spooky64me

字符串中数字序列的数量对字符串的长度没有限制：

Input:  some1meme2sequences3can4be5really6long7 /2
Output: some0meme1sequences1can2be2really3long3

附录

如果您的语言支持任意精度整数作为语言功能，则必须使用这些整数。如果不是，则不需要支持任意精度的整数。例如，您必须Integer在Haskell中使用，而不是Int因为它可以作为语言的一部分使用；在中Java，您不需要使用，BigInteger因为它是库功能，而不是语言功能。

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

这是代码高尔夫，因此禁止标准漏洞，以字节为单位的最短答案为胜！

排行榜

这篇文章底部的堆栈摘录从答案a）生成排行榜，答案是每种语言的最短解决方案列表，b）则是总体排行榜。

为确保您的答案显示出来，请使用以下Markdown模板以标题开头。

## Language Name, N bytes

N您提交的文件大小在哪里。如果您提高了分数，则可以将旧分数保留在标题中，方法是将它们打掉。例如：

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

如果要在标头中包含多个数字（例如，因为您的分数是两个文件的总和，或者您想单独列出解释器标志罚分），请确保实际分数是标头中的最后一个数字：

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

您还可以将语言名称设置为链接，然后该链接将显示在代码段中：

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

显示代码段

code-golf  string  math  subsequence 
— 伊泰·费伯
source
3
您的最后一个测试用例是错误的。您的输出中有太多的零，因此其为/ 5。
— 尼克·哈特利
5
首先，这是一个安排合理的第一篇文章，所以恭喜您：)请注意，我们有一个沙箱，您可以在其中发布挑战，以在提出挑战之前进行反馈。
— FryAmTheEggman '15
3
欢迎使用PPCG（即使您显然已经来过2年以上）。不错的第一个挑战。是否有关于任意精度整数的附录规定（例如，Java 必须使用该附录BigInteger进行计算）？
— AdmBorkBork，2016年
18
到目前为止，我们遇到过的每一个外星种族……这都是真的！:-)
— 路易斯·门多
2
这是您的挑战，最终要取决于您，但是对于碰巧使用其他语法的语言来说，这并不公平。
— 丹尼斯

Answers:

10

Jolf，15个 14字节

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

在这里尝试！

说明

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

有趣的是，在挑战之后我更新了Jolf，添加了一些RegExp内置函数。这可能是12 11字节：

ρiLRdC!6+HI
— 科纳·奥布莱恩
source
24

Ruby，50 44 43字节

FGITW回答。得快！

感谢@Neil节省了6个字节。

哦，对了，划掉44还是44

->m,t{m.gsub(/\d+/){eval$&+t.sub(?^,'**')}}
— 价值墨水
source
哦，伙计，这几乎就是我正在嘲笑的答案：a=gets;$><<gets.gsub(/\d+/){eval$&+a}。我的错过了^！= **事情，而且可能会更长一些。
— 尼克·哈特利
3
+1可使您的整个解决方案比PowerShell处理所需的时间短4个字节^。：D
— AdmBorkBork's
15

Perl，36 34字节

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

源代码长30个字节，并且需要开关-pi（+4个字节）。它采用来自STDIN的第一个输入，第二个输入作为的参数-i。

感谢@DenisIbaev打高尔夫球2个字节！

在Ideone上进行测试。

— 丹尼斯
source
是的，我想如果有人能击败我的Ruby答案，那就是Dennis和/或Perl，您最终同时满足了这两个期望
— Value Ink
1
-pi是4个字节？
— CalculatorFeline
@CatsAreFluffy 当前共识是计算不带标志的调用的编辑距离。其中包括一个-pi与其余命令分开的空间。
— 丹尼斯
"0|$&"比短"0|".$&。
— 丹尼斯·伊巴耶夫
@DenisIbaev由于输入为字母数字，因此"0|$&$^I"也可以使用。谢谢！
— 丹尼斯
9

PowerShell v2 +，139137字节

param($a,$b)-join($a-split"(\d+)"|%{if($_-match"\d+"){if($b[0]-ne'^'){[math]::Floor((iex $_$b))}else{"$_*"*$b.Trim('^')+1|iex}}else{$_}})

糟糕...仅占47个字节，^因为这不是PowerShell中的本机运算符。@TessellatingHeckler节省了2个字节。

需要输入的$a=<word>，$b=<operation>一样.\universal-spooky-meme.ps1 2spooky4me ^3。我们-split $a用数字表示，将其括在括号中，以便保留定界符，然后将结果数组通过循环传递|%{...}。如果当前片段是数字，那么我们在第一个if。我们需要检查的第一个字符是否$b为^。如果不是，我们只需连接当​​前片段并将$b其发送到iex（类似于eval），然后将其保留在管道中。否则，我们需要创建一个指数字符串，"$_*"*$b.Trim('^')+1并将其通过管道传递到iex，然后将其保留在管道中。对于给定的2spooky4me ^3示例，这将分别是2*2*2*1和4*4*4*1。

否则，我们只是将字符串保留在管道中。

所有这些结果都是从带有封装括号的管道中收集的，然后再-join一起返回一个字符串。那就是在管道上重新保留的内容，在程序终止时输出是隐式的。

例子

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
source
在查看答案之前，我写了自己的文章，然后我也提出了一些想法-谢谢。我想你可以替换Floor(("$_$b"|iex))使用Floor((iex $_$b))，以节省一对夫妇，或可能iex $_+$b。
— TessellatingHeckler
@TessellatingHeckler感谢您提供的两个字节！
— AdmBorkBork，2016年
8

JavaScript（ES7），58 57字节

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

编辑：当我记得这replace也适用于文字字符串时，保存了1个字节。

— 尼尔
source
太好了，我正在研究ES6解决方案
— 巴林（Bálint）2016年
你能咖喱保存一个字节吗？
— gcampbell '16
1
@gcampbell是的，但是我太懒了。
— 尼尔
6

佩斯，29岁

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

这是通过从模因中提取每个数字，然后对其进行交织（.i），后跟一个空格并与其他参数一起包裹在列表中而实现的。因此，如果我们的电话号码是7，^20我们将得到以下列表：["^", "7 ", "20"]。展平并在其上使用Pyth eval（.v）总是可以得到我们想要的操作。最终，这些值与数字出现时的原始字符串拆分交错。

如果两个输入都用引号引起来，则可以短一个字节；如果其中两个输入都可以被引号，则可以短两个字节。

在这里尝试或运行测试套件

— 弗莱姆·埃格曼
source
6

Python 2，156 89 88 87字节

受到其他答案的启发，这些答案使用其语言的替换功能和函数处理程序，以iperator 处理长nput字符串的数字部分o。对于Python来说^很不幸，必须将替换为**，这将花费18个字节。.group(0)仅仅访问匹配对象的字符串表示形式的调用并不能使事情变得更好。

感谢QPaysTaxes发现虚假空间，并感谢RootTwo提供了不必要的参数.group！

import re
lambda i,o:re.sub(r'\d+',lambda p:str(eval(p.group()+o.replace('^','**'))),i)
— 奥吉多
source
我认为您可以在i,o:
— Nic Hartley
您可以再保存两个字节：（1）通过使用p.group()。（默认为0）；和（2）插入r=re.sub;替换第一re.sub呼叫与r和然后使用r('^','**',o)代替o.replace(...)
— RootTwo
@RootTwo：对我来说， r('^','**',o)然后需要转义^以\^匹配字符，而不是开头，不o保存任何字节：-(-但感谢指出不必要的内容0！
— ojdo
5

Javascript（ES6）99字节

另一个例子，为什么我们讨厌等待ES7获得兼容性

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

可运行的示例：

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!")));
展开摘要

— 巴林特
source
您匹配的正则表达式似乎有些偏离。在可运行示例中，您省略了大写字母，从而将它们从结果中去除（“ 2spooky4ME”，“ + 1” =>“ 3spooky5”），在第一个示例中，您与匹配\d+|\D+，等效于.+。[a-zA-Z0-9]+是您想要的正则表达式，不是吗？还是[a-zA-Z]+|[0-9]+分裂带来了不同？
— Itai Ferber
Math.pow直接调用可能会更容易，因为无论如何您都必须对其进行特殊处理。另外，您是否使用整数除法？
— 尼尔
@Neil我忘了，分
— 巴林特
@Neil有没有更好的上限方法？
— 巴林特
1
@ItaiFerber \d+|\D+与不太一样.+。它们是不一样的，因为苯撑膨胀发生在the之前or。如果看起来像是一样的(\d|\D)+，但是按原样，它不会匹配2a一组中的所有内容，而是两个独立的组。
— FryAmTheEggman '16
5

朱莉娅71 59 54字节

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

big如果可用的话，使用要求会使它更长。

在线尝试！

— 丹尼斯
source
4

科特林，416个 413字节

eval()Kotlin中缺少an 确实增加了该字节数。

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

在线尝试！

不打高尔夫球

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

PowerShell（v4），124120字节

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

（新行仅用于避免水平滚动，它们在另存为一行时起作用）。

评论，并要求提供非高尔夫版本：

$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)
  • .net regex库可以用对匹配内容执行的脚本块进行替换，PowerShell将类型字符串转换为数字，iex就像eval()在其他语言中一样。它就是"2spooky" "+3"->eval("2+3")
  • 除了...它不能处理^运算符或类似的任何其他便捷的幂运算**，它只能使用[math]::Pow()库调用，因此有一个大块可以处理该分支。
    • 更新的版本从@TimmyD窃取了一个主意，而是进行了字符串乘法- "2*" * n变成字符串"2*2*2*2*"，然后+1在末尾添加乘以一个，而不是抱怨结尾*。
  • 除...之外，.Net进行Banker的舍入，默认舍入到最接近的偶数，并且3/2 = 2而不是3/2 =1。此挑战要求截断，这意味着[math]::Truncate()。相反，我通过-replace修剪小数点及其后的所有内容来保存字符。

测试用例：

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

注意 在上一次测试中，数字会[BigInteger]自动溢出为类型，但会以科学计数法表示。幸运的是，每个已知的能够在星际之间进行交流的种族都有足够的科学发展能力，可以毫无问题地处理科学符号。

— TessellatingHeckler
source
1
您可以在其他答案中看到它们如何提供相当不易理解的高尔夫版本，然后提供单独的非高尔夫版本来检查代码行为。您应该使用自己的名称（即删除高尔夫球版本中的换行符）。
— jpmc26 '16
感谢您的功劳，但不是我的把戏–我从PowerShell Tips线程中提取了它。
— AdmBorkBork '16
显然，我很在意发表评论，而其他人则在意我的评论。;）
— jpmc26 '16
不，我说过您应该有一个完全打高尔夫球的版本和一个完全不打高尔夫球的版本。打高尔夫球的人需要滚动。没有高尔夫的将不会，并且将比您拥有的更具可读性。
— jpmc26 '16
1
@ jpmc26好吧，我已经编辑了一个没有注释的版本。
— TessellatingHeckler，2016年
3

Bash + GNU coreutils，144字节

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

这着眼于数字和非数字之间的变化，这就是为什么将随机无效的输入字符（逗号）附加到输入字符串的原因。然后在输出中忽略该逗号。OP的约定完全遵循bc此处用于进行数学运算的语法。

— Rexkogitans
source
顺便说一下，由于@TessellatingHeckler在PowerShell解决方案中的讨论：在我的解决方案中，您可以通过将换行符替换为分号来将程序转换为单行，这不会改变其长度。
— rexkogitans
3

Lua 145 93字节

r=io.read;m=r()o=r()m=m:gsub("%d",function(n)return loadstring("return..."..o)(n)end)print(m)
— 胡扯
source
为什么不发布函数呢？
— 巴林特
2

R，163字节

作为学习R中的正则表达式和字符串替换的人，这被证明是一个相当困难的挑战。尤其是因为匹配数字很容易，但是我找不到使用的多个替换方式gsub。此外，我不知道是否eval(parse(paste0(...是在操作之间进行切换的最有效方法。也许switch-function更适合这里。

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

说明

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
}
— 比利沃伯
source
我认为，如果您在比赛中使用gsub并加上一个闭包，则可以节省大量字节，这正是您在注释中所暗示的。我不知道如何在R中做到这一点。我也为此苦苦挣扎，直到我发现如何在Groovy中做到这一点为止。几乎改变了游戏规则。
— 魔术章鱼缸
2

Javascript（ES6），85个字节

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

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

取消高尔夫：

x = (s) => {
  var a = s.split(" ");
  return [...a[0]].map(x => (!isNaN(x)) ? eval(x + a[1]) : x).join ``
}
console.log(x("2spookie5me +1"));
— 布拉迪米尔·鲁伊斯
source
有人知道我是否可以使用Spread运算符分割空间吗？从这个s.split（“”）; 到[“” ... s]; 至少就是这个想法。
— 布拉迪米尔·鲁伊斯
您不需要()使用lambda参数，也不需要使用var，并且应该使用parens和逗号运算符而不是花括号，以及return
— Cyoce
此外，^这是JavaScript的特殊情况，它是按位异或，而不是Math.pow
— Sunny Pun
2

Groovy，64个 60字节

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

用闭包替换所有数字实例，该闭包评估对所传递单词的数字部分的运算。如果传递了指数函数，它将用正确的符号替换它。Groovy在使用时隐式处理BigInteger / BigDecimal转换，Eval.me()因为已解析的字符串可能超出2^32-1范围。

讲解

{a,b->...} -有两个参数的闭包。

a.replaceAll(/\d+/,{...}) -搜索字符串中的所有数字序列并替换为闭包。

{Eval.me(it+b.replace("^","**"))} -更具体地说，闭包中每个匹配项都附加了操作，然后将其评估为常规代码。

.replace("^","**")- 在提供的^操作**中，用groovy指数运算符替换第一个实例。如果您希望它与使用指数的完整方程式字符串一起使用，请replaceAll()改为使用+3字节的惩罚。

有趣的旁注他是一个有效的测试方案：
(22348952345238905290858906209862398036spooky409552me, /200*4943^8-23939+((100/203)+600)

— 魔术章鱼缸
source
1

RProgN，39字节

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

讲解

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

技术上无效的答案，因为该语言不存在。但是，它不是专门为此设计的，也没有任何特殊的添加。因此，我正在运行它。告我。

在线尝试！

— 阿塔科
source
0

Perl 6，111字节

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

不幸的EVAL是默认情况下是禁用的。另外，您必须使用div整数除法。

— bb94
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.