反手^ H ^ H ^ H ^ H ^ H ^ Hspaces

47

在某些终端上，按退格键将生成控制代码^H以删除前一个字符。这引起了一个俗套的成语，其中假装因喜剧效果而假装：

对这个傻瓜^ H ^ H ^ H ^ Hgentleman很好，他是从公司总部来的。

给定一个或多个字符串^H，则在每个字符串上输出退格结果^H。输入将仅使用可打印字符（ASCII 32-126），并且^仅显示为^H。空文本永远不会出现退格键。

您可能不会假定输出环境支持控制代码，尤其是退格代码\x08。

>> Horse^H^H^H^H^HCow
Cow

>> Be nice to this fool^H^H^H^Hgentleman, he's visiting from corporate HQ.
Be nice to this gentleman, he's visiting from corporate HQ.

>> 123^H45^H^H^H78^H
17

>> Digital Trauma^H^H^H^H^H^H^H^H^H^H^H^H^H^HMaria Tidal Tug^H^H^H^H^H^H^H^H^H^H^H^H^H^H^HDigital Trauma
Digital Trauma

排行榜

这是马丁·布特纳（MartinBüttner）提供的按语言排行榜。

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

# Language Name, N bytes

N您提交的文件大小在哪里。如果您提高了分数，则可以通过打败旧分数来保持标题。例如：

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

显示代码段

code-golf  string 
— 异或
source
4
是否AAA^HB^H^H有效？
— 内森·美林
@NathanMerrill是的，结果为A。
— xnor
3
我怀疑视网膜在这里会很好。
— Claudiu
1
@Fatalize：“退格永远不会在空文本上发生。”
— Maltysen
16
@Maria Tidal Tug再次困扰我
— Digital Trauma

Answers:

69

GNU sed，11个字节

:;s/.^H//;t

测试输出：

$ echo "Horse^H^H^H^H^HCow
Be nice to this fool^H^H^H^Hgentleman, he's visiting from corporate HQ.
123^H45^H^H^H78^H
Digital Trauma^H^H^H^H^H^H^H^H^H^H^H^H^H^HMaria Tidal Tug^H^H^H^H^H^H^H^H^H^H^H^H^H^H^HDigital Trauma" | sed ':;s/.^H//;t'
Cow
Be nice to this gentleman, he's visiting from corporate HQ.
17
Digital Trauma
$
— 数字创伤
source
5
看看谁出现了！这是Maria Tidal Tug ^ H ^ H ^ H ^ H ^ H ^ H ^ H ^ H ^ H ^ H ^ H ^ H ^ H ^ H ^ H数字创伤！
— Alex A.
@AlexA。我想开个玩笑吗？
— user253751
@immibis：请参阅Digital Trauma对这个问题的评论。
— Alex A.
sed -r ':;s/(^|.)\^H//;t'-这需要付出额外的6个字节的代价
— aragaer 2015年
@aragaer为什么有必要？OP说“ 退格永远不会在空文本上发生 ”。我认为^H字符串的开头是空文本上的退格键。
— Digital Trauma 2015年
19

Pyth，11个字节

.U+PbZcz"^H

示范。

.U+PbZcz"^H
               Implicit: z = input()
      cz"^H    z.split("^H")
.U             reduce, with the first element of the list as the initial value.
   Pb          Remove the last character of what we have so far.
  +  Z         And add on the next segment.
               Print implicitly.
— 伊萨格
source
17

Gema，6个字节

?#\^H=

样品运行：

bash-4.3$ gema -p '?#\^H=' <<< 'pizza is alright^H^H^H^H^H^Hwesome'
pizza is awesome

CW，因为愚人与绅士的榜样花了太长时间。（一天之后被杀。可能是解释器中的一个小故障？这里所有其他示例都在几分之一秒内进行了处理。）Gema的递归模式似乎不受递归级别的影响，但是不匹配的文本量会成倍地增加处理时间。

— manatwork
source
是否有该语言的链接？在Github上进行的快速搜索显示了很多内容
— -Sp3000
当然。gema.sourceforge.net（顺便说一句，Gema项目已于2003-10-27注册，而GitHub已于2008-04-10启动。这可能是在那里找不到它的原因。）
— manatwork
我相信递归深度等于不匹配字符串的长度，因为它会一次又一次递归直到\^H机械匹配，一次匹配一个字符?。
— isaacg 2015年
15

C，52个字节

j;f(char*s){for(j=0;*s=s[j];s[j]==94?s--,j+=3:s++);}

我们定义一个函数f，该函数将指向字符串的指针作为输入。函数调用后，该指针将包含修改后的字符串。

一个简单的测试：

int main(int argc, char** argv) {
    char buf[300] = "Digital Trauma^H^H^H^H^H^H^H^H^H^H^H^H^H^HMaria Tidal Tug^H^H^H^H^H^H^H^H^H^H^H^H^H^H^HDigital Trauma";
    f(buf);
    printf(buf);
    return 0;
}

上面的照片：

Digital Trauma
— 脑钢
source
1
这真的很聪明。我注意到了几件事：全局变量已被初始化为零，因此无需j在for循环中进行初始化（当然，这是一次性的，但是在规则中我什么都没看到:)）。您还可以将赋值与减量组合起来：j;f(char*s){for(;s[j]==94?*s--=s[j],j+=3:s++);}（47个字节）
— Cole Cameron
@ColeCameron 你错过了这个
— undergroundmonorail
@undergroundmonorail dang，我只是仔细检查一下是否错过了。我仍然是打高尔夫球的新手，但我会在以后记住这一点：）。谢谢（你的）信息！
— 科尔·卡梅隆
1
@ColeCameron不幸的是，它具有未排序的修改和访问（UB），并在我的编译器/计算机上立即导致EXC_BAD_ACCESS。
— BrainSteel
1
@Quentin我尝试过，但是由于逗号s--, j+=3和运算符优先级，它无法正常工作。
— BrainSteel
14

Haskell，47个字节

h(a,_:_:b)=f$init a++b;h(x,_)=x
f=h.span(/='^')

定义一个函数f :: String -> String。这个怎么运作：

    f "ab^Hc^Hd"
=== h ("ab", "^Hc^Hd")   (find ^H)
=== f ("a" ++ "c^Hd")    (backspace)
=== f "ac^Hd"            (join)
=== h ("ac", "^Hd")      (find ^H)
=== f ("a", "d")         (backspace)
=== f "ad"               (join)
=== h ("ad", "")         (find ^H)
=== "ad"                 (no ^H: base case)
— 林恩
source
1
我认为您可以通过交换两种情况h并h(x,_)=x为空字符串大小写来节省字节。
— Zgarb 2015年
12

CJam，14 13字节

q"^H"/{W\ts}*

这个怎么运作

q                   e# Read the entire input
 "^H"/              e# Split it on occurrences of string "^H"
      {    }*       e# Reduce on the split array
       W\t          e# This is the tricky part. We know that if there are two parts that we
                    e# are reducing on, they must be separated by "^H". Which in turn means
                    e# that from the first part, last characters needs to be deleted
                    e# So we simply put the second part in place of the last character of the
                    e# first part.
          s         e# Doing the above makes it a mixed array of character and string.
                    e# So we convert it to a single string, ready to be served as first part
                    e# in next reduce iteration

更新：吉米23013节省了1个字节

在这里在线尝试

— 优化器
source
2
缩短1个字节：W\ts。
— jimmy23013 2015年
11

视网膜，13字节

视网膜

+`.\^H(.*)
$1

这两行应该转到它们自己的文件，但是您可以将代码作为带有-s标志的一个文件来运行。

在每一步中，我们都删除.\^H字符串中的第一个匹配项。我们重复此操作（使用+修饰符），直到没有删除发生。

— Randomra
source
只是出于好奇：为什么要捕获(.*)，因为它似乎没有变回原样？
— manatwork
1
@manatwork这样一来，我们只需.\^H一步即可捕获第一步。否则abc^H^H^H将导致ab^第一步后的结果。
— randomra'7
4
尚未实现替换限制的道歉（可能会允许类似+1`.\^H）。;）
— Martin Ender 2015年
10

JavaScript（ES6），39个字节

f=s=>(t=s.replace(/.\^H/,''))!=s?f(t):t

// TEST

Out=x=>O.innerHTML+=x+'\n'

Test=_=>(Out(I.value + "\n-> " + f(I.value)),I.value='')

;["Horse^H^H^H^H^HCow"
,"Be nice to this fool^H^H^H^Hgentleman, he's visiting from corporate HQ."
,"123^H45^H^H^H78^H"
,"Digital Trauma^H^H^H^H^H^H^H^H^H^H^H^H^H^HMaria Tidal Tug^H^H^H^H^H^H^H^H^H^H^H^H^H^H^HDigital Trauma"]
.forEach(t => Out(t + "\n-> " + f(t)))
#I { width:400px }
<pre id=O></pre>
<input id=I><button onclick='Test()'>-></button>
展开摘要

— edc65
source
10

Perl，20 16 15字节

（14个字符的代码+ 1个字符的命令行选项。）

s/.\^H//&&redo

样品运行：

bash-4.3$ perl -pe 's/.\^H//&&redo' <<< "Be nice to this fool^H^H^H^Hgentleman, he's visiting from corporate HQ."
Be nice to this gentleman, he's visiting from corporate HQ.
— 工作的人
source
1
保存4个字符：1while s/.\^H//
— 凯文·里德
哇！@KevinReid太好了。谢谢。
— manatwork 2015年
1
还有一个：s/.\^H//&&redo
— 丹尼斯
谢谢@丹尼斯。redo不知何故没有进入我的技能范围。将不得不改变这一点。
— manatwork
2
请注意，@ Dennis的版本只有在循环或{ }块内的唯一语句时才起作用（按预期）。（之所以起作用，perl -p是因为该-p开关会自动将您的代码包装在while循环内。）Kevin的版本可在任何设置下使用。
— Ilmari Karonen
9

朱莉娅58 42 41字节

通过操作节省了16个字节，而通过Glen O节省了1个字节！

f(s)='^'∈s?f(replace(s,r".\^H","",1)):s

这将创建一个递归函数，该函数接受一个字符串并返回一个字符串。

^H当输入包含时，这一次用空字符串替换一次出现的^。

例子：

julia> f("123^H45^H^H^H78^H")
"17"

julia> f("pizza is alright^H^H^H^H^H^Hwesome")
"pizza is awesome"
— 亚历克斯·A
source
这是我第一次在野外见到朱莉娅。真好！
— Ogaday'2
8

REGXY，10个字节

使用REGXY，这是一种基于正则表达式替换的语言。用任何字符替换后跟^ H的任何字符。然后执行第二行，该行只是指向前一行的指针，重复替换直到匹配失败。

/.\^H//
//

这可以使用上面的链接中的样本解释器正确编译和执行，但是该解决方案可能有点厚脸皮，因为它依赖于语言规范模糊的假设。规范指出，每行的第一个标记（在/之前）都充当标签，但是假设空标签指针将指向具有空标签的文件中的第一个命令（换句话说， “ null”是有效标签）。一个不太厚脸皮的解决方案是：

a/.\^H//
b//a

总计13个字节。

— Jarmex
source
7

Python 3，53个字节

o=""
for x in input().split("^H"):o=o[:-1]+x
print(o)

但个人而言，我更喜欢这个词多一点的版本：

H=input().split("^H")
print(eval("("*~-len(H)+")[:-1]+".join(map(repr,H))))

有趣的是

'B''a''c''k''h''a''n''d''e''d'[:-1][:-1][:-1][:-1][:-1][:-1]

实际工作并给出了'Back'，所以我试图映射^H -> [:-1]和任何其他字符c -> 'c'，然后eval，但不幸的是，你不能有任何字符串之后没有+，所以这个失败：

'B''a''c''k''h''a''n''d''e''d'[:-1][:-1][:-1][:-1][:-1][:-1]'s''p''a''c''e''s'
— Sp3000
source
嘿，那太整齐了。
— Alex Van Liew
+=在循环中工作
— CalculatorFeline
@CatsAreFluffy是的o=o[:-1]+x，不是o=o+x
— Sp3000
糟糕，错过了。像o[:-2]=x工作吗？
— CalculatorFeline
@CatsAreFluffy您不能分配给str
— Sp3000 '16
7

Haskell，52 47字节

import Data.Lists
foldl1((++).init).splitOn"^H"

用法示例：

> map (foldl1((++).init).splitOn"^H") ["Horse^H^H^H^H^HCow", "123^H45^H^H^H78^H", "Digital Trauma^H^H^H^H^H^H^H^H^H^H^H^H^H^HMaria Tidal Tug^H^H^H^H^H^H^H^H^H^H^H^H^H^H^HDigital Trauma"]
["Cow","17","Digital Trauma"]

这个怎么运作：

                  splitOn"^H"     -- split on substring "^H", e.g "Horse^H^H^H^H^HCow" -> ["Horse","","","","","Cow"]
                 .                -- then
foldl1(         )                 -- fold from left by
            init                  --   first dropping the last char from the left argument
       (++).                      --   second concatenating left and right argument
— 妮米
source
6

Ruby，27 24 20字节

（19个字符的代码+ 1个字符的命令行选项。）

$_=$`+$'while/.\^H/

谢谢：

  • Ventero建议使用全局变量（-4个字符）

样品运行：

bash-4.3$ ruby -pe '$_=$`+$'"'"'while/.\^H/' <<< "Be nice to this fool^H^H^H^Hgentleman, he's visiting from corporate HQ."
Be nice to this gentleman, he's visiting from corporate HQ.
— 工作的人
source
+1我以为我会做一个Ruby的答案，直到我看到这个为止-我很确定这会变得很小。很好用[]！
— daniero 2015年
开始时有另一个版本：loop{$_[/.\^H/]=""}rescue""这个版本更好，因为它演示了Ruby的异常处理功能。
— manatwork 2015年
哈哈，真是个
— 好人
1
迟到总比不到好：$_=$`+$'while~/.\^H/持续20分钟（如果您不关心regexp literal in condition警告，甚至可以丢弃波浪号）。
— Ventero '16
1
@manatwork：从技术上讲，它在所有> = 1.9的ruby版本中都出现（条件之后的正则表达式和字符串文字在1.8之后不推荐使用），我想您ruby仍然还是默认irb使用1.8，而使用ruby 2.1.5。
— Ventero'Apr 11'16
4

python 2，50

在其中有一秒钟有点奇怪lambda，但似乎是迄今为止最好的Python。

lambda s:reduce(lambda a,b:a[:-1]+b,s.split('^H'))
— 费瑟姆
source
3

Pyth-19个字节

Reduce确实非常好用，但是一次只能处理一个字符，因此我不得不花与实际算法几乎一样多的字符来换行^H。寻找一种更好的方法。

u?+GHnHbPGjbcz"^H"k

在这里在线尝试。

— 马尔蒂森
source
3

TeaScript，7个字节[不竞争]

挑战发布后，TeaScript成为了竞争对手。这是参考。

xW/.\^H

这将使用新的TeaScript 3，并进行递归替换以删除字符

— 下山羊
source
1
由于某种原因，由于ISO 8859链接，此
— 页数
regerence？xD
— 猫
2

K5，64个字节

K并不是真正为这种工作而设计的...

{[s]$[2>#s;s;`=t:*&{"^H"~2#x_s}'1+!-2+#s;s;,/2#2!|(0,t,3+t)_s]}/
— kirbyfan64sos
source
2

golflua，36个字节

\f(s)@o!=s o=s;s=s:g(".^H","",1)$~s$

样品运行：

Lua 5.2.2  Copyright (C) 1994-2013 Lua.org, PUC-Rio
> \f(s)@o!=s o=s;s=s:g(".^H","",1)$~s$
> w(f("Be nice to this fool^H^H^H^Hgentleman, he's visiting from corporate HQ."))
Be nice to this gentleman, he's visiting from corporate HQ.
— 工作的人
source
2

Javascript，62个字节

不是最短的，但是效果很好。

t=prompt();while(t.match(R=/.\^H/))t=t.replace(R,'');alert(t);
展开摘要

这大概可以缩短很多！

— 伊斯梅尔·米格尔（Ismael Miguel）
source
1
不是最短的一个，也不起作用（尝试任何测试用例）。regexp不应该是全局的（删除/ g）
— edc65
@ edc65感谢您的提示。我尝试了一些东西，他们工作了。这就是为什么我这样发布
— Ismael Miguel
2

R， 54 52字节

f=function(s)ifelse(s==(r=sub(".\\^H","",s)),r,f(r))

与我的朱莉娅答案相同的基本思想。这将创建一个递归函数，该函数接受一个字符串并返回一个字符串。如果输入等于自身，并且出现一次^H删除，则将其返回，否则再次调用该函数。

您可以在线尝试！

— 亚历克斯·A
source
2

ECMAScript 6,57字节

s=>{while(~s.indexOf`^H`)s=s.replace(/.\^H/,'');return s}

这是可能golfable，只是得想办法恐怕不是

— 下山羊
source
2
怎么s=>{while(s!=(s=s.replace(/.\^H/,""));return s}样
— lrn
或者，如果while和return太长，则可能是递归的：var f=s=>s==(s=s.replace(/.\^H/))?s:f(s)
— lrn
@lm，您应该添加第二个参数“”进行替换。然后，您就会得到我的回答:)
— edc65
真正。空字符串参数必须存在，我必须复制了错误的版本:(
— lrn
~s.indexOf`^H`可以成为/\^H/.test(s)
— 不是查尔斯（Charles）
2

（Visual）FoxPro任何版本80字节

PARA t
DO WHILE AT('^H',t)>0
t = STRT(t,SUBS(t,AT('^H',t)-1,3))
ENDDO
RETU t

通过查找^ H并备份一个字符来将字符串重复翻译为空。

— 克里斯
source
2

朱莉娅41 39字节

s->foldl((t,v)->chop(t)v,split(s,"^H"))

它的作用是使用^ H作为分隔符，然后删除每个字符串上的最后一个字符，然后连接下一个字符串，然后再次删除最后一个字符。与其他Julia答案不同，这不是递归函数。

注意：我已经从定义中删除了函数名称。本来是说f(s)=而不是s->，而您将它用作f("AAA^HB^H^H")...，但是我通过将其设为“匿名”来节省了两个字节，并使用自身作为其名称。您可以这样使用它：

(s->foldl((t,v)->chop(t)v,split(s,"^H")))("AAA^HB^H^H")

（您也可以为分配一个变量f=s->foldl((t,v)->chop(t)v,split(s,"^H"))，然后f("AAA^HB^H^H")就可以使用）

— 格伦·奥
source
1

Python 2、74 + 2 = 76字节

到目前为止，我已经尝试了几种方法，这是到目前为止我能提出的最好的方法。

n=input();o='';c=0
for l in n:d=l=='^';o=[o+l*(1-c),o[:-1]][d];c=d
print o
— 卡德
source
4
那两个额外的字节从哪里来？
— xnor
@xnor输入必须用引号引起来，才能正常工作。我忘了把它张贴在帖子中。
— 卡德，2015年
1
我认为通常的惯例是允许字符串参数免费包含在引号中，但我不确定。
— xnor
1

腮腺炎，84字节

R Z S T="",Y=$L(Z,"^H") F I=1:1:Y{S T=T_$P(Z,"^H",I) S:I<Y T=$E(T,1,$L(T)-1)} W !,T

可以将其缩短为一个函数（我可以在快速测试中保存一个字节），但我有点像单线方面... :-)

大括号来自于Mumps的Intersystems Cache风格，这是我最精通的东西。

— Zmerch
source
1

Java-123字节

我个人g---1最喜欢这个部分。

String f(char[] a){String b="";for(int g=-1;++g<a.length;b=(a[g++]=='^'?b.substring(0,b.length()-1):b+a[g---1]));return b;}

展开（略）：

  String f(char[] a) {
      String b = "";
      for (int g = -1;
           ++g < a.length;
           b = (a[g++]=='^' 
                ? b.substring(0, b.length() - 1) 
                : b + a[g---1])
      );
      return b;
  }
— 弹力狂人
source
1

批-138字节

@!! 2>nul||cmd/q/v/c%0 %1&&exit/b
set s=%1&for /F %%a in ('"prompt $H&echo on&for %%b in (1)do rem"')do set D=%%a
echo %s:^H=!D! !D!%

第一行是一种在冗长的长度上保存几个字节的方法@echo off&setLocal enableDelayedExpansion（如果您想知道的话，它将关闭回显并启用变量的延迟扩展）。我在批量打高尔夫球的技巧中对此进行了解释。

第二行是一个巧妙的小技巧，用于将退格控制字符保存到变量中。这很hacky，我不能假装为此赞誉。这里有点解释。基本上使用提示命令来生成退格字符并将其捕获为变量-在这种情况下!D!。

然后，最后一行执行简单的字符串操作-替换^H为!D!<SPACE>!D!。

C:\>bsp.bat "testing^H^H^H test"
"test test"

不幸的是，它在诸如此类的情况下会中断"AAA^HB^H^H"-应该在哪里产生"A"，而是产生"A"B。这有点令人困惑。我将不得不更深入地研究批处理字符串的工作方式。

C:\>bsp.bat "AAA^HB^H^H"
"A"B

多亏了这里有帮助的人-我现在意识到我只保存退格字符（0x08），所以也只覆盖了字符。现在，它可以与以下示例一起使用：

C:\>bsp.bat "AAA^HB^H^H"
"A"
— 不败
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.