为什么6害怕7？因为7 8 9！

给定字符串，请执行以下转换：

• 如果7旁边有6，则删除6（6害怕7）
• 如果出现序列“ 789”，则删除8和9（7 ate 9）

（如果我没记错的话，以什么顺序进行转换都没关系）

继续应用这些转换，直到不再使用。

例：

78966

首先我们看到“ 789”，因此字符串变成“ 766”。然后我们看到“ 76”，所以我们取出6，字符串变成“ 76”。然后我们再次看到“ 76”，所以我们剩下“ 7”。

测试用例：

• 987=> 987（顺序不正确。不执行任何操作。）
• 6 7=> 6 7（空格用作6到7之间的缓冲区。什么都没有发生）
• 676 => 7
• 7896789 => 77
• 7689 => 7
• abcd => abcd

视网膜 12

sed答案的翻译：

6*7(6|89)*
7

在线尝试

Javascript ES6，29个字节

s=>s.replace(/6*7(89|6)*/g,7)

测试：

f=s=>s.replace(/6*7(89|6)*/g,7)
;`987 -> 987
6 7 -> 6 7
676 -> 7
7896789 -> 77
7689 -> 7
abcd -> abcd`
.split`\n`.every(t=>(t=t.split` -> `)&&f(t[0])==t[1])

Java，126 81 66 58字节

感谢@GamrCorps提供此代码的lambda版本！

感谢@ user902383指出了自动装箱技巧！

...对。

它实际上比我预期的要长-Java replaceAll()每次匹配用一次替换字符串中的项目，直到替换停止为止才重复。所以我不得不花哨的循环。

Lambda形式：

x->{for(;x!=(x=x.replaceAll("67|76|789","7")););return x;}

功能形式：

String s(String x){for(;x!=(x=x.replaceAll("67|76|789","7")););return x;}

可测试的非高尔夫代码：

class B{
    public static void main(String[]a){
        System.out.print(new B().s(a[0]));
    }
    String s(String x){for(;x!=(x=x.replaceAll("67|76|789","7")););return x;}
}

GNU Sed，17岁

分数包括+1作为-r选项。

s/6*7(6|89)*/7/g

Perl 6的，19  18个字节

{S:g/6*7[6|89]*/7/} # 19 bytes

$ perl6 -pe 's:g/6*7[6|89]*/7/' # 17 + 1 = 18 bytes

（请注意，[6|89]非捕获版本的(6|89)拼写与(?:6|89)Perl 5相同。这<[6|89]>是您编写[6|89]Perl 5 拼写的内容的方式）

用法：

$ perl6 -pe 's:g/6*7[6|89]*/7/' <<< '
987
6 7
6676689
7896789
7689
abcd
68978966897896
79|689
'

987
6 7
7
77
7
abcd
68977
79|689

Pyth，17个字节

u:G"67|76|789"\7z

在这里尝试。

Leaky Nun在评论中对此一字不漏。

Perl 5，17个字节

perl -pe 's/6*7(6|89)*/7/g' # 16 + 1

用法：

$ perl -pe 's/6*7(6|89)*/7/g' <<< '
987
6 7
6676689
7896789
7689
abcd
68978966897896
'

987
6 7
7
77
7
abcd
68977

Mathematica，52个字节

StringReplace[#,"67"|"76"|"789"->"7"]&~FixedPoint~#&

说明：

                                                   &   A function returning
                                     &                   a function returning
              #                                            its first argument
StringReplace[ ,                    ]                     with
                "67"                                        "67"
                    |                                      or
                     "76"                                   "76"
                         |                                 or
                          "789"                             "789"
                               ->                         replaced with
                                 "7"                       "7"
                                    ~FixedPoint~        applied to
                                                #        its first argument
                                                        until it no longer changes.

锈，96字节

fn f(mut s:String)->String{for _ in 0..s.len(){for r in&["67","76","789"]{s=s.replace(r,"7")}}s}

绝望地漫长，按照Rust的惯例...

取消高尔夫：

fn seven_ate_nine(mut str: String) -> String {
    for _ in 0..str.len() {
        for to_replace in &["67","76","789"] {
            str = str.replace(to_replace, "7");
        }
    }
    s
}

Emacs Lisp，59个字节

(lambda(s)(replace-regexp-in-string"6*7\\(6\\|89\\)*""7"s))

空格变得更加清晰：

(lambda (s) (replace-regexp-in-string "6*7\\(6\\|89\\)*" "7" s))

Ruby，27个字节

该解决方案来自于Brad Gilbert b2gills的评论。

->s{s.gsub /6*7(6|89)*/,?7}

Ruby，37个字节

（旧解决方案）

此解决方案使用这样一个事实，即您替换字符串的次数将永远不需要。

->s{s.chars{s.sub! /67|76|789/,?7};s}

Japt，15个字节

Ur"6*7(89|6)*"7

简单的RegEx解决方案

在线尝试

PowerShell，27个字节

$args-replace'6*7(89|6)*',7

e.g.
PS C:\temp> .\ate.ps1 "7689"
7

PS C:\temp> .\ate.ps1 "abcd"
abcd

PS C:\temp> .\ate.ps1 "68978966897896"
68977

利用：

• 别人的正则表达式模式
• -replace在PowerShell中默认情况下如何进行全局替换
• 循环展开，它将通过将-regex运算符分别$args应用于所有元素而将运算符应用于数组，并且这里只有一个元素，因为只有一个脚本参数，因此可以正常工作，并且可以避免为element编制索引[0]。

在实现全局替换之前，新颖性先前的尝试可以做到；74个字节使用字符串乘法构建“ -replace -replace -replace”链，其长度是字符串的长度的多少倍，然后eval（）对其进行运算：

"'$($args)'"+("{0}6|6(?=7)'{0}89'"-f"-replace'(?<=7)")*$args[0].Length|iex

（使用一些字符串替换可以缩短替换次数）。

CJam，70 64字节

由于@Peter泰勒切割{"789":I}{"76:":I}?到"789""76"?:I

"67":Iq:A{AI#:B){AB<7+A{BI,+}~>+s:A];}{"76"I={"789":I}{"76":I}?];}?}/A

"67":Iq:A{AI#:B){AB<7+A{BI,+}~>+s:A];}{"76"I="789""76"?:I];}?}/A

我知道这可能会做得更多，对您的帮助将不胜感激，但是坦率地说，我很高兴自己能找到答案。这是我第一次编写CJam。

说明：

"67":I                e# Assign the value of 67 to I
q:A                   e# Read the input and assign to A
{                     e# Opening brackets for loop
    AI#:B)            e# Get the index of I inside A and assign to B. The increment value by 1 to use for if condition (do not want to process if the index was -1)
    {                 e# Open brackets for true result of if statement
        AB<           e# Slice A to get everything before index B
        7+            e# Append 7 to slice
        A{BI,+}~>     e# Slice A to get everything after index B plus the length of string I (this will remove I entirely)
        +s:A          e# Append both slices, convert to string, and assign back to A
        ];            e# Clear the stack
    }                 e# Closing brackets for the if condition
    {                 e# Open brackets for false result of if statement
        "76"I=        e# Check if I is equal to 76
        "789"         e# If I is 76, make I 789
        "76"?:I       e# If I is not 76, make I 76
        ];            e# Clear the stack if I does not exist inside A
    }?                e# Closing brackets for false result of if statement
}/                    e# Loop
A                     e# Output A

MATL，17个字节

jt"'789|76'55cYX]

例

>> matl
 > jt"'789|76'55cYX]
 > 
> 7896789
77

编辑：在线尝试！

说明

j                   % input string
t                   % duplicate
"                   % for each character. Iterates as many times as the string length
    '789|76'        % regular expression for replacement
    55c             % string to insert instead: character '7'
    YX              % regexprep
]                   % end for

通过对原始字符串中的字符进行多次次数的常规表达式替换，可以正常工作。这是足够的，因为每次替换都会减少字符数。

严重的是29个字节

,;l`'7;;"67"(Æ"76"(Æ"789"(Æ`n

将输入作为双引号字符串，例如"6789"。在线尝试（您将需要手动引用输入内容）。

说明：

,;l`'7;;"67"(Æ"76"(Æ"789"(Æ`n
,;l                            get input and push its length (we'll call it n)
   `                       `n  call the following function n times:
    '7;;"67"(Æ                   replace all occurrences of "67" with "7"
              "76"(Æ             replace all occurrences of "76" with "7"
                    "789"(Æ      replace all occurrences of "789" with "7"

周，26字节

67::=7
76::=7
789::=7
::=

包括结尾的换行符。

在启动之前，将输入附加到程序中。
与图灵机类似，在终止时从程序状态中读取输出。
（虽然确实有输出流，但是很难正确使用，因此我不确定这是否是可接受的输出方法）

Bash，102 82 67（+7）？个字节

extglob版本

x=$1
while v=${x/@(76|67|789)/7};[ $v != $x ];do x=$v;done
echo $v

这应该放在文件中，并使用例如调用bash -O extglob 789.sh 6567678989689789656。（+7）？bytes是用于extglob选项是否计入字节。

感谢@BinaryZebra指出extglob功能！

非extglob版本（82字节）

x=$1
while v=${x/76/7};v=${v/67/7};v=${v/789/7};[ $v != $x ];do x=$v;done
echo $v

这应该放在文件中，并使用例如调用./789.sh 65678989656。

它利用参数扩展来循环搜索和替换。由于我不知道一种更有效地链接扩展的方法，因此我进行了一系列扩展来进行替换。

R，35个字节

cat(gsub("6*7(6|89)*",7,scan(,"")))

我不知道我可以用gsub这种方式，非常感谢您的每一个答案，让我学到了一些新的东西。

PHP 51个字符

while($s!=$r=str_replace([789,67,76],7,$s)){$s=$r;}

长手编写的测试用例

$s = '78966';
while ($s != $r = str_replace([789, 67, 76], 7, $s) )
{
    $s = $r;
}
echo $s; // 7;

这将进行字符串比较，并且在while条件下将字符串都替换。如果满足while条件，它将用结果更新比较的左手。让我知道任何改进。

Jolf，15个字节

在这里尝试！我真的需要解释吗？

pi"6*7(6|89)*"7
p               replace any entity in
 i               the input
  "6*7(6|89)*"   that matches this regex
              7  with 7
                implicit output

PHP，36字节

preg_replace('/6*7(6|89)*/','7',$a);

正则表达式解决方案，使用$ a字符串并通过表达式替换。

Clojure，71个字节

Clojure因其冗长的性质而不太适合打高尔夫球-但这仍然是一个有趣的练习：

高尔夫版本，使用Java互操作性：

(defn f[s](let[x(.replaceAll s "67|76|789" "7")](if(= s x)s(recur x))))

非高尔夫版本，使用Java互操作：

(defn six-fears-seven [s]
  (let [x (.replaceAll s "67|76|789" "7")]
    (if (= s x)
      s
      (recur x))))

无高尔夫球的“纯Clojure”版本：

(defn six-fears-seven [s]
  (let [x (clojure.string/replace s #"67|76|789" "7")]
    (if (= s x)
      s
      (recur x))))

///，19个字节（无竞争）

/67/7//76/7//789/7/

您实际上无法提供这种语言的输入，因此假定的输入将显示在代码的右侧。

Python 3，46个字节

import re
lambda s:re.sub(r'6*7(6|89)*','7',s)

Japt v2.0a0，12个字节

e/6?7(6|89/7

在线尝试！

这个怎么运作

String.e是递归替换功能。Japt 2具有新的regex语法和regex内的括号自动补全功能，在此处节省了一个字节。（在Japt 1.x中，我们不得不传递字符串来代替正则表达式，这有点笨拙。）

Dyalog APL，17个字节

'6*7(6|89)*'⎕R'7'

'6*任意数量的6，
7 然后是7
(… )*' 随后是零个或多个序列，
 6|89 即6或8到9

⎕R [R E放置与

'7' 一个七

05AB1E，12 个字节

Δ67‚7:789¬:

在线尝试或验证所有测试用例。

说明：

Δ               # Continue doing the following until it no longer changes:
 67             #  Push 67 to the stack
   Â            #  Bifurcate (short for Duplicate & Reverse); which pushes 76 to the stack
    ‚           #  Pair them up
     7:         #  Replace all occurrences of 67 or 76 with 7 in the (implicit) input
                #   i.e. 17893762 → 1789372
       789      #  Push 789 to the stack
          ¬     #  Take the head (without popping); which pushes 7 to the stack
           :    #  Replace all 789 with 7
                #   i.e. 1789372 → 17372
                # (And implicitly output the result after the loop)