¿Por qué tenía 6 miedo de 7? Porque 7 8 9!

Dada una cadena, aplique las siguientes transformaciones:

• Si hay un 6 al lado de un 7, elimine el 6 (6 tiene miedo de 7)
• Si aparece la secuencia "789", elimine el 8 y el 9 (7 ate 9)

(Si no me equivoco, no importa en qué orden realice las transformaciones)

Siga aplicando estas transformaciones hasta que ya no pueda.

Ejemplo:

78966

Primero vemos "789", por lo que la cadena se convierte en "766". Luego vemos "76", por lo que sacamos el 6 y la cadena se convierte en "76". Luego vemos "76" nuevamente, así que nos quedamos con "7".

Casos de prueba:

• 987=> 987(No en el orden correcto. No hace nada)
• 6 7=> 6 7(El espacio en blanco actúa como un buffer entre 6 y 7. No pasa nada)
• 676 => 7
• 7896789 => 77
• 7689 => 7
• abcd => abcd

Retina , 12

Traducción de la respuesta sed:

6*7(6|89)*
7

Pruébalo en línea

Javascript ES6, 29 bytes

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

Prueba:

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

¡Gracias a @GamrCorps por proporcionar la versión lambda de este código!

¡Gracias a @ user902383 por señalar un truco de autoboxing!

...Sip.

En realidad, es más largo de lo que esperaba: Java reemplaza los elementos en cadenas con replaceAll()una vez por partido, no repetidamente hasta que deja de cambiar. Así que tuve que usar un elegante bucle for.

Forma lambda:

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

Forma de la función:

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

Código no comprobado comprobable:

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

La puntuación incluye +1 para la -ropción.

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

(Tenga en cuenta que [6|89]la versión sin captura de la (6|89)cual se escribe como (?:6|89)en Perl 5. <[6|89]>es cómo escribiría lo que se escribe como [6|89]en Perl 5)

uso:

$ 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

Pruébalo aquí

Leaky Nun ha superado esto por un byte en los comentarios.

Perl 5 , 17 bytes

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

uso:

$ 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~#&

Explicación:

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

Óxido, 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}

Desesperadamente largo, como de costumbre para Rust ...

Sin golf:

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

Se vuelve un poco más claro con los espacios:

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

Rubí, 27 bytes

Esta solución es de comentarios, crédito a Brad Gilbert b2gills .

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

Ruby, 37 bytes

(antigua solución)

Esta solución utiliza el hecho de que nunca necesitará reemplazar más veces que los caracteres en la cadena.

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

Japt , 15 bytes

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

Solución RegEx simple

Pruébalo en línea

PowerShell, 27 bytes

$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

Haciendo uso de:

• patrón de expresiones regulares de otra persona
• la forma en -replaceque un reemplazo global por defecto en PowerShell
• desenrollado de bucle, donde aplicará el -regexoperador a la matriz $argsaplicándolo a todos los elementos individualmente, y aquí solo hay un elemento porque solo hay un parámetro de script, por lo que funciona bien y podemos evitar tener que indexar el elemento [0].

Un intento previo de novedad antes de realizar un reemplazo global lo haría; 74 bytes de construcción de una cadena de "-replace -replace -replace" usando la multiplicación de cadenas, tantas veces como la longitud de la cadena, luego evalúela ()

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

(Con un poco de sustitución de cadenas para acortar el número de reemplazos).

CJam, 70 64 bytes

Gracias a Peter Taylor por cortar {"789":I}{"76:":I}?a"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

Sé que esto probablemente podría jugar mucho más y tu ayuda sería muy apreciada, pero, francamente, estoy feliz de haber logrado obtener la respuesta. Este fue mi primer intento de escribir CJam.

Explicación:

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

Ejemplo

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

EDITAR : ¡ Pruébelo en línea!

Explicación

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

Esto funciona aplicando un reemplazo de expresión regular tantas veces como haya caracteres en la cadena original . Esto es suficiente, ya que cada sustitución reduce el número de caracteres.

En serio, 29 bytes

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

Toma la entrada como una cadena entre comillas dobles, como "6789". Pruébelo en línea (deberá citar manualmente la entrada).

Explicación:

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

Jue , 26 bytes

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

incluyendo una nueva línea final.

La entrada se agrega al programa antes de iniciarlo.
La salida se lee del estado del programa cuando termina, de manera similar a una máquina de Turing.
(Thue hace tener un flujo de salida, pero es difícil de usar correctamente, así que no estoy seguro de si se trata de un método de salida aceptable)

Bash, 102 82 67 (+7)? bytes

versión extglob

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

Esto está destinado a ser puesto en un archivo y llamada con, por ejemplo bash -O extglob 789.sh 6567678989689789656. El (+7)? bytes es para si la opción extglob cuenta para bytes.

¡Gracias a @BinaryZebra por señalar las características de extglob!

Versión no extglob (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

Esto está destinado a ser puesto en un archivo y llamada con, por ejemplo ./789.sh 65678989656.

Utiliza la expansión de parámetros para buscar y reemplazar en un bucle. Involucré una serie de expansiones para hacer el reemplazo, ya que no conozco una forma de encadenar expansiones de manera más efectiva.

R, 35 bytes

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

No sabía que podía usar de gsubesta manera, muchas gracias por cada respuesta aquí que me hizo aprender algo nuevo.

PHP 51 caracteres

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

Caso de prueba escrito a mano

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

Esto hace la comparación de la cadena y la cadena reemplaza ambas en la condición while. Si mientras se cumple la condición, actualiza la mano izquierda de la comparación con el resultado. Déjame saber de cualquier mejora.

Jolf , 15 bytes

Pruébalo aquí! ¿Realmente tengo que explicar?

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

solución de expresiones regulares, toma $ una cadena y reemplaza a través de la expresión.

Clojure, 71 bytes

Clojure es menos que ideal para jugar golf debido a su naturaleza detallada, pero no obstante es un ejercicio interesante:

Versión de golf, utilizando interoperabilidad Java:

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

Versión sin golf, utilizando interoperabilidad Java:

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

Versión "pura Clojure" sin golf:

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

/// , 19 bytes (no competitivos)

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

En realidad, no puede proporcionar información en este idioma, por lo que la supuesta entrada va a la derecha del código.

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

Pruébalo en línea!

Cómo funciona

String.eEs una función de reemplazo recursiva. Japt 2 tiene una nueva sintaxis de expresiones regulares y autocompletado de paréntesis dentro de expresiones regulares, lo que ahorra un byte aquí. (En Japt 1.x, tuvimos que pasar cadenas en lugar de expresiones regulares, que era un poco torpe).

Dyalog APL , 17 bytes

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

'6*cualquier número de seises
7 seguido de un siete
(... )*' seguido de cero o más secuencias de ...
 6|89 un seis u ocho y nueve

⎕R R EColoque que con

'7' un siete

05AB1E , 12 bytes

Δ67‚7:789¬:

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

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