Tại sao 6 sợ 7? Vì 7 8 9!

Cho một chuỗi áp dụng các biến đổi sau:

• Nếu có 6 bên cạnh 7, hãy xóa 6 (6 sợ 7)
• Nếu chuỗi "789" xuất hiện, hãy xóa 8 và 9 (7 ăn 9)

(Nếu tôi không nhầm thì không vấn đề gì khi bạn thực hiện các phép biến đổi)

Tiếp tục áp dụng các biến đổi này cho đến khi bạn không thể.

Thí dụ:

78966

Đầu tiên chúng ta thấy "789", vì vậy chuỗi trở thành "766". Sau đó, chúng tôi thấy "76", vì vậy chúng tôi lấy ra 6 và chuỗi trở thành "76". Sau đó, chúng tôi lại thấy "76", vì vậy chúng tôi chỉ còn lại "7".

Các trường hợp thử nghiệm:

• 987=> 987(Không theo đúng thứ tự. Không có gì.)
• 6 7=> 6 7(Khoảng trắng đóng vai trò là vùng đệm giữa 6 và 7. Không có gì xảy ra)
• 676 => 7
• 7896789 => 77
• 7689 => 7
• abcd => abcd

Võng mạc , 12

Bản dịch của câu trả lời sed:

6*7(6|89)*
7

Dùng thử trực tuyến

Javascript ES6, 29 byte

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

Kiểm tra:

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 byte

Cảm ơn @GamrCorps đã cung cấp phiên bản lambda của mã này!

Cảm ơn @ user902383 vì đã chỉ ra một thủ thuật autoboxing!

... vâng

Nó thực sự dài hơn tôi mong đợi - Java thay thế các mục trong chuỗi bằng replaceAll()một lần cho mỗi trận đấu, không lặp lại cho đến khi nó ngừng thay đổi. Vì vậy, tôi đã phải sử dụng một ưa thích cho vòng lặp.

Mẫu Lambda:

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

Hình thức chức năng:

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

Mã xác nhận có thể kiểm tra:

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

Điểm bao gồm +1 cho -rtùy chọn.

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

Perl 6 , 19  18 byte

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

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

(Lưu ý rằng [6|89]phiên bản không bắt giữ (6|89)được đánh vần như (?:6|89)trong Perl 5. <[6|89]>là cách bạn sẽ viết những gì được đánh vần như [6|89]trong Perl 5)

sử dụng:

$ 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

Bình thường, 17 byte

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

Hãy thử nó ở đây.

Leaky Nun đã vượt qua điều này bằng một byte trong các bình luận.

Perl 5 , 17 byte

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

sử dụng:

$ 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

Toán học, 52 byte

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

Giải trình:

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

Rust, 96 byte

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

Vô vọng, như thường lệ đối với Rust ...

Ung dung:

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 byte

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

Nó trở nên rõ ràng hơn với không gian:

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

Ruby, 27 byte

Giải pháp này là từ ý kiến, tín dụng cho Brad Gilbert b2gills .

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

Ruby, 37 byte

(giải pháp cũ)

Giải pháp này sử dụng thực tế là bạn sẽ không bao giờ cần phải thay thế nhiều lần hơn các ký tự trong chuỗi.

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

Japt , 15 byte

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

Giải pháp RegEx đơn giản

Dùng thử trực tuyến

PowerShell, 27 byte

$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

Sử dụng:

• mô hình regex của người khác
• cách -replacethay thế toàn cầu theo mặc định trong PowerShell
• hủy kiểm soát vòng lặp, nơi nó sẽ áp dụng -regextoán tử cho mảng $argsbằng cách áp dụng nó cho tất cả các phần tử riêng lẻ và chỉ có một phần tử ở đây vì chỉ có một tham số tập lệnh, vì vậy nó hoạt động tốt và chúng ta có thể tránh phải lập chỉ mục phần tử [0].

Nỗ lực mới lạ trước khi nhận ra một sự thay thế toàn cầu sẽ làm điều đó; 74 byte xây dựng chuỗi "-replace -replace -replace" bằng cách nhân chuỗi, nhiều lần bằng độ dài của chuỗi, sau đó eval () ing nó:

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

(Với một chút thay thế chuỗi để rút ngắn số lần thay thế).

CJam, 70 64 byte

Nhờ @ Peter Taylor để cắt {"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

Tôi biết điều này có thể có thể được đánh gôn hơn rất nhiều và sự giúp đỡ của bạn sẽ được đánh giá rất cao, nhưng thật lòng tôi rất vui vì tôi đã có được câu trả lời. Đây là nỗ lực đầu tiên của tôi khi viết CJam.

Giải trình:

"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 byte

jt"'789|76'55cYX]

Thí dụ

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

EDIT : Hãy thử trực tuyến!

Giải trình

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

Điều này hoạt động bằng cách áp dụng một thay thế expresion thường xuyên nhiều lần như có các ký tự trong chuỗi ban đầu . Điều này là đủ, vì mỗi sự thay thế làm giảm số lượng ký tự.

Nghiêm túc, 29 byte

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

Đưa đầu vào dưới dạng một chuỗi trích dẫn kép, như "6789". Hãy thử trực tuyến (bạn sẽ cần trích dẫn thủ công đầu vào).

Giải trình:

,;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"

Thứ ba , 26 byte

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

bao gồm một dòng mới.

Đầu vào được gắn vào chương trình trước khi bắt đầu nó.
Đầu ra được đọc khỏi trạng thái chương trình khi nó kết thúc, tương tự như máy Turing.
(Thue không có luồng đầu ra, nhưng rất khó sử dụng chính xác, vì vậy tôi không chắc đây có phải là phương thức đầu ra chấp nhận được không)

Bash, 102 82 67 (+7)? byte

phiên bản ngoại khóa

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

Điều này có nghĩa là được đặt trong một tập tin và được gọi với ví dụ bash -O extglob 789.sh 6567678989689789656. (+7)? byte là nếu tùy chọn extglob tính vào byte.

Cảm ơn @BinaryZebra đã chỉ ra các tính năng extglob!

Phiên bản không phải extglob (82 byte)

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

Điều này có nghĩa là được đặt trong một tập tin và được gọi với ví dụ ./789.sh 65678989656.

Nó sử dụng mở rộng tham số để tìm kiếm và thay thế trong một vòng lặp. Tôi liên quan đến một loạt các mở rộng để thực hiện thay thế vì tôi không biết cách mở rộng chuỗi hiệu quả hơn.

R, 35 byte

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

Tôi không biết tôi có thể sử dụng gsubtheo cách này, một lời cảm ơn lớn cho mỗi câu trả lời ở đây đã khiến tôi học được điều gì đó mới.

PHP 51 ký tự

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

Trường hợp thử nghiệm viết bằng tay dài

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

Điều này không so sánh chuỗi và chuỗi thay thế cả trong điều kiện while. Nếu trong khi điều kiện được đáp ứng, nó sẽ cập nhật bàn tay trái của so sánh với kết quả. Hãy cho tôi biết bất kỳ cải tiến.

Jolf , 15 byte

Hãy thử nó ở đây! Tôi có thực sự phải giải thích?

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 byte

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

giải pháp regex, lấy $ một chuỗi và thay thế thông qua biểu thức.

Clojure, 71 byte

Clojure ít hơn lý tưởng để chơi gôn do tính chất dài dòng của nó - nhưng dù sao đó cũng là một bài tập thú vị:

Phiên bản chơi gôn, sử dụng Java interop:

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

Phiên bản chưa chơi gôn, sử dụng Java interop:

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

Phiên bản "thuần Clojure" không chơi gôn:

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

/// , 19 byte (không cạnh tranh)

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

Bạn thực sự không thể cung cấp đầu vào bằng ngôn ngữ này, vì vậy, đầu vào được cho là ở bên phải của mã.

Python 3, 46 byte

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

Japt v2.0a0, 12 byte

e/6?7(6|89/7

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

String.elà hàm đệ quy thay thế. Japt 2 có cú pháp regex mới và tự động hoàn thành các dấu ngoặc trong regex, giúp lưu một byte ở đây. (Trong Japt 1.x, chúng tôi đã phải vượt qua các chuỗi thay cho regexes, điều này hơi khó hiểu.)

APL Dyalog , 17 byte

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

'6*bất kỳ số lượng sixes
7 tiếp theo bảy
(... )*' tiếp theo không hay nhiều chuỗi ...
 6|89 một sáu hoặc 8-9

⎕R R nơi đó với

'7' bảy

05AB1E , 12 byte

Δ67‚7:789¬:

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

Δ               # 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)