Dlaczego 6 bało się 7? Ponieważ 7 8 9!

Podany ciąg znaków stosuje następujące przekształcenia:

• Jeśli obok 7 jest 6, usuń 6 (6 boi się 7)
• Jeśli pojawi się sekwencja „789”, usuń 8 i 9 (7 zjadł 9)

(Jeśli się nie mylę, nie ma znaczenia, w jakiej kolejności przeprowadzacie transformacje)

Stosuj te transformacje, aż przestaniesz.

Przykład:

78966

Najpierw widzimy „789”, więc ciąg staje się „766”. Następnie widzimy „76”, więc wyjmujemy 6, a ciąg staje się „76”. Następnie ponownie widzimy „76”, więc pozostaje nam „7”.

Przypadki testowe:

• 987=> 987(Nie w odpowiedniej kolejności. Nic nie robi.)
• 6 7=> 6 7(Biała spacja działa jako bufor między 6 a 7. Nic się nie dzieje)
• 676 => 7
• 7896789 => 77
• 7689 => 7
• abcd => abcd

Siatkówka , 12

Tłumaczenie odpowiedzi sed:

6*7(6|89)*
7

Wypróbuj online

JavaScript ES6, 29 bajtów

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

Test:

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 bajtów

Dzięki @GamrCorps za udostępnienie wersji kodu lambda!

Dzięki @ user902383 za wskazanie sztuczki polegającej na autoboksowaniu!

...tak.

Jest faktycznie dłuższy niż się spodziewałem - Java zamienia elementy w ciągach replaceAll()jeden raz na dopasowanie, nie wielokrotnie, dopóki nie przestanie się zmieniać. Musiałem więc użyć fantazyjnej pętli.

Formularz lambda:

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

Formularz funkcji:

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

Testowany niepoznany kod:

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

Wynik obejmuje +1 dla -ropcji.

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

Perl 6 , 19  18 bajtów

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

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

(Zauważ, że [6|89]wersja, (6|89)której nie można przechwycić, jest napisana tak, jak (?:6|89)w Perlu 5. Sposób <[6|89]>pisania tego, co napisane jest [6|89]w Perlu 5)

stosowanie:

$ 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 bajtów

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

Wypróbuj tutaj.

Dziurawa Zakonnica przerosła to bajtem w komentarzach.

Perl 5 , 17 bajtów

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

stosowanie:

$ 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 bajty

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

Wyjaśnienie:

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

Rdza, 96 bajtów

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

Beznadziejnie długi, jak zwykle dla Rust ...

Nie golfowany:

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 bajtów

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

Staje się nieco jaśniejszy ze spacjami:

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

Rubinowy, 27 bajtów

To rozwiązanie pochodzi z komentarzy, dzięki uprzejmości Brada Gilberta b2gills .

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

Rubinowy, 37 bajtów

(stare rozwiązanie)

To rozwiązanie wykorzystuje fakt, że nigdy nie będziesz musiał zamieniać więcej razy niż znaków w ciągu.

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

Japt , 15 bajtów

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

Proste rozwiązanie RegEx

Wypróbuj online

PowerShell, 27 bajtów

$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

Z wykorzystaniem:

• czyjś wzorzec regularny
• sposób, w jaki -replaceglobalnie zastępuje domyślnie w PowerShell
• rozwijanie pętli, w którym zastosuje -regexoperator do tablicy $args, stosując go indywidualnie do wszystkich elementów, i jest tylko jeden element, ponieważ jest tylko jeden parametr skryptu, więc działa OK i możemy uniknąć konieczności indeksowania elementu [0].

Zrobiłoby to nowa poprzednia próba przed realizacją globalnego zastąpienia; 74 bajty budowania łańcucha „-replace -replace -replace” przy użyciu mnożenia ciągu znaków tyle razy, ile wynosi długość ciągu, a następnie eval ():

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

(Z odrobiną podstawienia łańcucha w celu skrócenia liczby zamienników).

CJam, 70 64 bajtów

Dzięki @Peter Taylora do cięcia {"789":I}{"76:":I}?do"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

Wiem, że prawdopodobnie można by grać o wiele dalej i twoja pomoc byłaby bardzo mile widziana, ale szczerze mówiąc, po prostu cieszę się, że udało mi się uzyskać odpowiedź. To była moja pierwsza próba napisania CJam.

Wyjaśnienie:

"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 bajtów

jt"'789|76'55cYX]

Przykład

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

EDYCJA : Wypróbuj online!

Wyjaśnienie

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

Działa to poprzez zastosowanie regularnego zastępowania wyrażeń tyle razy, ile znaków ma oryginalny ciąg . To wystarczy, ponieważ każda zamiana zmniejsza liczbę znaków.

Poważnie, 29 bajtów

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

Pobiera dane wejściowe jako ciąg cudzysłowu, np "6789". Wypróbuj online (będziesz musiał ręcznie zacytować dane wejściowe).

Wyjaśnienie:

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

Czw. 26 bajtów

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

w tym końcowy znak nowej linii.

Dane wejściowe są dołączane do programu przed jego uruchomieniem.
Wyjście jest odczytywane ze stanu programu po jego zakończeniu, podobnie jak maszyna Turinga.
(Thue nie mają strumień wyjściowy, ale trudno używać prawidłowo, więc nie jestem pewien, czy jest to dopuszczalna metoda wyjścia)

Bash, 102 82 67 (+7)? bajty

wersja extglob

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

Jest to przeznaczone do umieszczenia w pliku i wywołania np bash -O extglob 789.sh 6567678989689789656. (+7)? bajtów jest, jeśli opcja extglob liczy się do bajtów.

Dzięki @BinaryZebra za wskazanie funkcji extglob!

Wersja bez extglob (82 bajty)

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

Jest to przeznaczone do umieszczenia w pliku i wywołania np ./789.sh 65678989656.

Wykorzystuje rozszerzenie parametrów do wyszukiwania i zamiany w pętli. Wymieniłem serię rozszerzeń, ponieważ nie znam sposobu na bardziej efektywne łączenie rozszerzeń.

R, 35 bajtów

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

Nie wiedziałem, że mogę skorzystać z gsubtego sposobu, wielkie dzięki za każdą odpowiedź, która sprawiła, że ​​nauczyłem się czegoś nowego.

PHP 51 znaków

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

Przypadek testowy napisany długimi rękami

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

Dokonuje to porównania łańcucha i łańcucha zastępuje oba w stanie while. Jeśli warunek jest spełniony, aktualizuje lewą rękę porównania z wynikiem. Daj mi znać o wszelkich ulepszeniach.

Jolf , 15 bajtów

Wypróbuj tutaj! Czy naprawdę muszę to wyjaśniać?

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 bajtów

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

Wyrażenie regularne, pobiera $ ciąg i zastępuje poprzez wyrażenie.

Clojure, 71 bajtów

Clojure jest mniej niż idealny do gry w golfa ze względu na jego pełną naturę - ale mimo to jest to interesujące ćwiczenie:

Wersja golfowa, wykorzystująca interfejs Java:

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

Wersja bez gry w golfa, z wykorzystaniem Java Interop:

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

Wersja „czystego Clojure” bez gry w golfa:

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

/// , 19 bajtów (niekonkurujące)

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

Nie można tak naprawdę wprowadzić danych w tym języku, więc domniemane dane wejściowe znajdują się po prawej stronie kodu.

Python 3, 46 bajtów

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

Japt v2.0a0, 12 bajtów

e/6?7(6|89/7

Wypróbuj online!

Jak to działa

String.ejest funkcją zastępowania rekurencyjnego. Japt 2 ma nową składnię wyrażeń regularnych i automatyczne uzupełnianie nawiasów w wyrażeniach regularnych, co oszczędza tutaj jeden bajt. (W Japt 1.x musieliśmy przekazywać łańcuchy zamiast wyrażeń regularnych, co było trochę niezgrabne.)

Dyalog APL , 17 bajtów

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

'6*dowolna liczba szóstek,
7 po których następuje siedem
(… )*' a następnie zero lub więcej sekwencji…
 6|89 sześć lub osiem-dziewięć

⎕R R EUmieãæ że z

'7' siódemka

05AB1E , 12 bajtów

Δ67‚7:789¬:

Wypróbuj online lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie:

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