Warum hatte 6 Angst vor 7? Weil 7 8 9!

Wenden Sie bei einer gegebenen Zeichenfolge die folgenden Transformationen an:

• Wenn es eine 6 neben einer 7 gibt, entferne die 6 (6 hat Angst vor 7)
• Wenn die Sequenz "789" erscheint, entfernen Sie die 8 und die 9 (7 aßen 9)

(Wenn ich mich nicht irre, spielt es keine Rolle, in welcher Reihenfolge Sie die Transformationen durchführen)

Wenden Sie diese Transformationen so lange an, bis Sie sie nicht mehr können.

Beispiel:

78966

Zuerst sehen wir "789", so dass die Zeichenfolge "766" wird. Dann sehen wir "76", also nehmen wir die 6 heraus und die Zeichenfolge wird "76". Dann sehen wir wieder "76", so dass wir mit "7" belassen werden.

Testfälle:

• 987=> 987(Nicht in der richtigen Reihenfolge. Tut nichts.)
• 6 7=> 6 7(Das Leerzeichen dient als Puffer zwischen 6 und 7. Nichts passiert)
• 676 => 7
• 7896789 => 77
• 7689 => 7
• abcd => abcd

Retina , 12

Übersetzung der sed Antwort:

6*7(6|89)*
7

Probieren Sie es online aus

Javascript ES6, 29 Bytes

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

Prüfung:

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 Bytes

Vielen Dank an @GamrCorps für die Lambda-Version dieses Codes!

Vielen Dank an @ user902383 für den Hinweis auf einen Autoboxing-Trick!

...Jep.

Tatsächlich ist es länger als erwartet - Java ersetzt Elemente in Zeichenfolgen durch replaceAll()einmal pro Match, nicht mehrmals, bis sich nichts mehr ändert. Also musste ich eine ausgefallene for-Schleife verwenden.

Lambda-Form:

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

Funktionsform:

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

Testbarer Ungolfed Code:

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

Die Punktzahl enthält +1 für die -rOption.

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

Perl 6 , 19  18 Bytes

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

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

(Beachten Sie, dass [6|89]die nicht aufzeichnende Version (6|89)wie (?:6|89)in Perl 5 geschrieben <[6|89]>ist. So würden Sie schreiben, was [6|89]in Perl 5 geschrieben ist.)

Verwendungszweck:

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

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

Probieren Sie es hier aus.

Leaky Nun hat dies in den Kommentaren um ein Byte übertroffen.

Perl 5 , 17 Bytes

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

Verwendungszweck:

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

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

Erläuterung:

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

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

Hoffnungslos lang, wie für Rust üblich ...

Ungolfed:

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 Bytes

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

Mit Leerzeichen wird es etwas klarer:

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

Ruby, 27 Bytes

Diese Lösung ist aus Kommentaren, Kredit an Brad Gilbert b2gills .

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

Ruby, 37 Bytes

(alte Lösung)

Diese Lösung nutzt die Tatsache, dass Sie nie mehr Male als Zeichen in der Zeichenfolge ersetzen müssen.

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

Japt , 15 Bytes

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

Einfache RegEx-Lösung

Probieren Sie es online aus

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

Gebrauch machen von:

• das Regex-Muster eines anderen
• Auf diese Weise -replacewird in PowerShell standardmäßig eine globale Ersetzung durchgeführt
• Loop Unrolling, bei dem der -regexOperator auf das Array angewendet $argswird, indem er auf alle Elemente einzeln angewendet wird, und es gibt hier nur ein Element, da es nur einen Skriptparameter gibt [0].

Ein neuer vorheriger Versuch, bevor ein globaler Ersatz realisiert wird, würde es tun; 74 Bytes zum Erstellen einer Kette von "-replace -replace -replace" unter Verwendung der String-Multiplikation, die so oft wie die Länge des Strings ist, und anschließender Auswertung ():

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

(Mit ein wenig String-Ersetzung, um die Anzahl der Ersetzungen zu verringern).

CJam, 70 64 Bytes

Vielen Dank an @Peter Taylor für den Schnitt {"789":I}{"76:":I}?zu"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

Ich weiß, dass dies wahrscheinlich viel weiter fortgeschritten sein könnte und Ihre Hilfe wäre sehr dankbar, aber ehrlich gesagt bin ich nur froh, dass ich die Antwort bekommen habe. Dies war mein erster Versuch, CJam zu schreiben.

Erläuterung:

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

jt"'789|76'55cYX]

Beispiel

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

EDIT : Probieren Sie es online!

Erläuterung

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

Dies funktioniert, indem ein regulärer Ausdrucksersatz so oft angewendet wird, wie die ursprüngliche Zeichenfolge Zeichen enthält . Dies ist ausreichend, da jede Ersetzung die Anzahl der Zeichen verringert.

Im Ernst, 29 Bytes

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

Nimmt die Eingabe als Zeichenfolge in doppelten Anführungszeichen an "6789". Probieren Sie es online aus (Sie müssen die Eingabe manuell zitieren).

Erläuterung:

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

Thue , 26 Bytes

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

einschließlich einer nachgestellten Newline.

Die Eingabe wird vor dem Start an das Programm angehängt.
Die Ausgabe wird, ähnlich wie bei einer Turing-Maschine, beim Beenden aus dem Programmzustand ausgelesen.
(Thue hat zwar einen Ausgabestream, aber es ist schwierig, ihn korrekt zu verwenden. Daher bin ich mir nicht sicher, ob dies eine akzeptable Ausgabemethode ist.)

Bash, 102 82 67 (+7)? Bytes

extglob version

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

Dies soll in einer Datei abgelegt und mit zB aufgerufen werden bash -O extglob 789.sh 6567678989689789656. Die (+7)? Bytes ist für, wenn die Option extglob für Bytes zählt.

Vielen Dank an @BinaryZebra für den Hinweis auf die Funktionen von extglob!

Non-Extglob-Version (82 Bytes)

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

Dies soll in einer Datei abgelegt und mit zB aufgerufen werden ./789.sh 65678989656.

Es nutzt die Parametererweiterung, um in einer Schleife zu suchen und zu ersetzen. Ich habe eine Reihe von Erweiterungen durchgeführt, um das Ersetzen durchzuführen, da mir kein Weg bekannt ist, Erweiterungen effektiver zu verketten.

R, 35 Bytes

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

Ich wusste nicht, dass ich gsubdiesen Weg nutzen könnte , ein großes Dankeschön für jede Antwort, die mich dazu brachte, etwas Neues zu lernen.

PHP 51 Zeichen

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

Testfall in langer Hand geschrieben

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

Dadurch werden sowohl der Zeichenfolgenvergleich als auch die Zeichenfolge in der while-Bedingung ersetzt. Wenn while-Bedingung erfüllt ist, wird die linke Hand des Vergleichs mit dem Ergebnis aktualisiert. Informieren Sie mich über mögliche Verbesserungen.

Jolf , 15 Bytes

Probieren Sie es hier aus! Muss ich das wirklich erklären?

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 Bytes

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

Regex-Lösung, nimmt $ eine Zeichenfolge und ersetzt durch den Ausdruck.

Clojure, 71 Bytes

Clojure ist aufgrund seiner Ausführlichkeit weniger als ideal zum Golfen - dennoch ist es eine interessante Übung:

Golf Version mit Java Interop:

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

Ungolf-Version mit Java-Interop:

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

Ungolfene "pure Clojure" -Version:

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

/// , 19 bytes (nicht konkurrierend)

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

Sie können in dieser Sprache keine Eingaben machen, die angebliche Eingabe steht also rechts vom Code.

Python 3, 46 Bytes

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

Japt v2.0a0, 12 Bytes

e/6?7(6|89/7

Probieren Sie es online!

Wie es funktioniert

String.eist eine rekursive Ersetzungsfunktion. Japt 2 hat eine neue Regex-Syntax und automatische Vervollständigung von Klammern in Regex, wodurch hier ein Byte gespart wird. (In Japt 1.x mussten wir anstelle von regulären Ausdrücken Zeichenfolgen übergeben, was etwas klobig war.)

Dyalog APL , 17 Bytes

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

'6*Eine beliebige Anzahl von Sechsern,
7 gefolgt von einer Sieben
(… )*' gefolgt von null oder mehr Folgen von…
 6|89 einer Sechs oder Acht-Neun

⎕R R rsetzen dass mit

'7' wie eben

05AB1E , 12 Bytes

Δ67‚7:789¬:

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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