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

온라인으로 사용해보십시오

자바 스크립트 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])

자바, 126 81 66 58 바이트

이 코드의 람다 버전을 제공 한 @GamrCorps에게 감사합니다!

오토 박싱 트릭을 지적한 @ user902383에게 감사합니다!

...예.

실제로 예상보다 깁니다. Java는 문자열 항목을 replaceAll()일치 항목 당 한 번으로 바꾸고 변경이 중지 될 때까지 반복하지 않습니다. 그래서 멋진 for 루프를 사용해야했습니다.

람다 양식 :

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 세드, 17

점수는 -r옵션에 +1을 포함 합니다.

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

펄 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)펄 5와는 <[6|89]>당신이로 철자 무엇을 작성합니다 어떻게 [6|89]펄 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은 주석에서 이것을 바이트 단위로 초과했습니다.

펄 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

매스 매 티카, 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
}

이맥스 리스프, 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))

루비, 27 바이트

이 솔루션은 Brad Gilbert b2gills의 의견 입니다.

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

루비, 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

사용하기 :

• 다른 사람의 정규식 패턴
• -replacePowerShell에서 전역이 기본적으로 대체되는 방식
• 루프 언 롤링- -regex연산자를 $args모든 요소에 개별적으로 적용 하여 배열 에 연산자를 적용하며 여기에는 스크립트 매개 변수가 하나뿐이므로 하나의 요소 만 있으므로 제대로 작동하므로 element 색인을 생성하지 않아도됩니다 [0].

전역 대체를 실현하기 전에 참신한 이전의 시도는 그렇게 할 것입니다. 문자열 길이의 수만큼 문자열 곱셈을 사용하여 "-replace -replace -replace"체인을 빌드 한 다음 eval ()하는 74 바이트

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

(대체 수를 줄이기 위해 약간의 문자열 대체로).

CJam, 70 64 바이트

절단 {"789":I}{"76:":I}?을 해준 @Peter Taylor에게 감사 합니다"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
::=

후행 줄 바꿈 포함.

입력은 프로그램을 시작하기 전에 프로그램에 추가됩니다.
Turing 머신과 유사하게 출력이 종료되면 프로그램 상태에서 출력을 읽습니다.
(Thue 에는 출력 스트림이 있지만 올바르게 사용하기 어렵 기 때문에 이것이 허용 가능한 출력 방법인지 확실하지 않습니다)

배쉬, 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)? 바이트는 extglob 옵션이 바이트 수에 포함되는 경우입니다.

extglob 기능을 지적 해 주신 @BinaryZebra에게 감사드립니다!

비 글로브 버전 (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 조건에서 둘 다를 대체합니다. 조건이 충족되면 비교의 왼쪽을 결과와 함께 업데이트합니다. 개선 사항을 알려주세요.

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 문자열을 취하고 표현식을 통해 대체합니다.

클로저, 71 바이트

Clojure는 장황한 특성으로 인해 골프에 이상적이지 않지만 흥미로운 운동입니다.

Java interop을 사용한 골프 버전 :

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

Java interop을 사용하는 골프 용 버전 :

(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/

실제로이 언어로 입력을 제공 할 수 없으므로 가정 된 입력은 코드 오른쪽으로 이동합니다.

파이썬 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에는 새로운 정규 표현식 구문이 있고 정규 표현식 안에 괄호가 자동 완성되어 1 바이트를 절약합니다. (Japt 1.x에서 우리는 정규 표현식 대신 문자열을 전달해야했습니다.

Dyalog APL , 17 바이트

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

'6*상상의 임의의 수의
7 일곱 하였다
(.. )*' 0 개 이상의 서열 ... 다음
 6|89 여섯 또는 8-9

⎕R R이 와 있음을 eplace

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