Pourquoi 6 avait peur de 7? Parce que 7 8 9!

Étant donné une chaîne, appliquez les transformations suivantes:

• S'il y a un 6 à côté d'un 7 enlevez le 6 (6 a peur de 7)
• Si la séquence "789" apparaît, retirez le 8 et le 9 (7 a mangé 9)

(Si je ne me trompe pas, l'ordre dans lequel vous effectuez les transformations n'a pas d'importance)

Continuez à appliquer ces transformations jusqu'à ce que vous n'en puissiez plus.

Exemple:

78966

Nous voyons d’abord "789", donc la chaîne devient "766". Ensuite, nous voyons "76", nous retirons donc le 6 et la chaîne devient "76". Ensuite, nous voyons à nouveau "76", il ne nous reste donc que "7".

Cas de test:

• 987=> 987(Pas dans le bon ordre. Ne fait rien.)
• 6 7=> 6 7(Les espaces blancs jouent le rôle de tampon entre 6 et 7. Rien ne se passe)
• 676 => 7
• 7896789 => 77
• 7689 => 7
• abcd => abcd

Rétine , 12

Traduction de la réponse sed:

6*7(6|89)*
7

Essayez-le en ligne

Javascript ES6, 29 octets

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

Tester:

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 octets

Merci à @GamrCorps d'avoir fourni la version lambda de ce code!

Merci à @ user902383 pour avoir signalé une astuce de sélection automatique!

...Ouaip.

C'est en fait plus long que prévu - Java remplace les éléments des chaînes avec replaceAll()une correspondance par correspondance, pas de manière répétée jusqu'à ce que les modifications soient arrêtées. J'ai donc dû utiliser une fantaisie pour la boucle.

Forme lambda:

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

Forme de fonction:

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

Code non-golfable testable:

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

Le score inclut +1 pour l' -roption.

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

Perl 6 , 19  18 octets

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

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

(Notez que [6|89]c'est la version sans capture (6|89)qui est orthographiée comme (?:6|89)dans Perl 5. Voici <[6|89]>comment vous écririez ce qui est orthographié comme [6|89]dans Perl 5)

usage:

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

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

Essayez-le ici.

Leaky Nun a dépassé ce chiffre d'un octet dans les commentaires.

Perl 5 , 17 octets

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

usage:

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

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

Explication:

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

Rouille, 96 octets

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

Désespérément long, comme d'habitude pour Rust ...

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 octets

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

Cela devient un peu plus clair avec des espaces:

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

Ruby, 27 octets

Cette solution est issue de commentaires, crédit à Brad Gilbert b2gills .

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

Ruby, 37 octets

(ancienne solution)

Cette solution utilise le fait que vous n'aurez jamais besoin de remplacer plus de fois que de caractères dans la chaîne.

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

Japt , 15 octets

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

Solution simple RegEx

Essayez-le en ligne

PowerShell, 27 octets

$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

Faire usage de:

• le motif regex de quelqu'un d'autre
• le chemin -replacefait un remplacement global par défaut dans PowerShell
• boucle déroulant, où l' -regexopérateur appliquera l' opérateur au tableau $argsen l'appliquant individuellement à tous les éléments; il n'y a qu'un seul élément ici, car il n'y a qu'un seul paramètre de script. Cela fonctionne donc bien et nous pouvons éviter d'avoir à indexer un élément [0].

La nouvelle tentative précédente avant de réaliser un remplacement global le ferait; 74 octets de construction d'une chaîne de "-replace -replace -replace" en utilisant la multiplication de chaîne, autant de fois que la longueur de la chaîne, puis en évaluant celle-ci:

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

(Avec un peu de substitution de chaîne pour réduire le nombre de remplacements).

CJam, 70 64 octets

Merci à Peter Taylor pour avoir coupé {"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

Je sais que cela pourrait probablement être joué beaucoup plus loin et votre aide serait grandement appréciée, mais franchement, je suis simplement heureuse d’avoir réussi à obtenir la réponse. Ce fut ma première tentative d'écriture de CJam.

Explication:

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

jt"'789|76'55cYX]

Exemple

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

EDIT : Essayez-le en ligne!

Explication

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

Cela fonctionne en appliquant un remplacement d'expression régulier autant de fois qu'il y a de caractères dans la chaîne d'origine . Cela suffit, car chaque substitution réduit le nombre de caractères.

Sérieusement, 29 octets

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

Prend les entrées sous forme de chaîne entre guillemets, comme "6789". Essayez-le en ligne (vous aurez besoin de citer manuellement l'entrée).

Explication:

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

Jeudi , 26 octets

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

y compris une fin de ligne.

L'entrée est ajoutée au programme avant de le démarrer.
La sortie est lue dans l'état du programme quand il se termine, de la même manière qu'une machine de Turing.
(Thue fait avoir un flux de sortie, mais il est difficile d'utiliser correctement, donc je ne suis pas sûr que ce soit une méthode de sortie acceptable)

Bash, 102 82 67 (+7)? octets

version extglob

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

Ceci est destiné à être placé dans un fichier et appelé avec par exemple bash -O extglob 789.sh 6567678989689789656. Le (+7)? octets est pour si l'option extglob compte pour les octets.

Merci à @BinaryZebra pour avoir signalé les fonctionnalités d'extglob!

Version non-extglob (82 octets)

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

Ceci est destiné à être placé dans un fichier et appelé avec par exemple ./789.sh 65678989656.

Il utilise l'expansion des paramètres pour rechercher et remplacer dans une boucle. J'ai eu recours à une série d'expansions pour effectuer le remplacement car je ne connaissais pas le moyen de chaîner plus efficacement les expansions.

R, 35 octets

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

Je ne savais pas que je pourrais utiliser gsubcette façon, un grand merci pour chaque réponse ici qui m'a fait apprendre quelque chose de nouveau.

PHP 51 caractères

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

Cas de test écrit à la main

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

Cela fait la comparaison de chaîne et la chaîne remplace les deux dans la condition while. Si tant que la condition est remplie, la main gauche de la comparaison est mise à jour avec le résultat. Faites-moi savoir de toutes les améliorations.

Jolf , 15 octets

Essayez-le ici! Dois-je vraiment expliquer?

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 octets

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

solution regex, prend $ une chaîne et remplace via l'expression.

Clojure, 71 octets

Clojure n’est pas idéal pour jouer au golf en raison de sa nature verbeuse - mais c’est quand même un exercice intéressant:

Version golfée, utilisant Java interop:

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

Version non-golfée, utilisant Java interop:

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

Version "pure Clojure" sans jeu:

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

/// , 19 octets (non concurrents)

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

Vous ne pouvez pas réellement entrer d’entrée dans cette langue, l’entrée supposée va donc à la droite du code.

Python 3, 46 octets

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

Japt v2.0a0, 12 octets

e/6?7(6|89/7

Essayez-le en ligne!

Comment ça fonctionne

String.eest la fonction de remplacement récursive. Japt 2 a une nouvelle syntaxe regex et l'auto-complétion des parenthèses dans regex, qui enregistre un octet ici. (Dans Japt 1.x, nous devions passer des chaînes à la place des regexes, ce qui était un peu maladroit.)

Dyalog APL , 17 octets

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

'6*un nombre quelconque de six
7 suivi d'un sept
(… )*' suivi de zéro ou plusieurs séquences de…
 6|89 un six ou huit-neuf

⎕R R EPlacez que ,

'7' un sept

05AB1E , 12 octets

Δ67‚7:789¬:

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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