Por que 6 tinha medo de 7? Porque 7 8 9!

Dada uma sequência, aplique as seguintes transformações:

• Se houver um 6 próximo a um 7, remova o 6 (6 tem medo de 7)
• Se a sequência "789" aparecer, remova os 8 e os 9 (7 e 9)

(Se não me engano, não importa em que ordem você faz as transformações)

Continue aplicando essas transformações até que você não possa mais.

Exemplo:

78966

Primeiro, vemos "789", então a string se torna "766". Então vemos "76", então tiramos o 6 e a string se torna "76". Então vemos "76" novamente, então ficamos com "7".

Casos de teste:

• 987=> 987(Não está na ordem certa. Não faz nada.)
• 6 7=> 6 7(O espaço em branco atua como um buffer entre 6 e 7. Nada acontece)
• 676 => 7
• 7896789 => 77
• 7689 => 7
• abcd => abcd

Retina , 12

Tradução da resposta sed:

6*7(6|89)*
7

Experimente online

Javascript ES6, 29 bytes

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

Teste:

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

Obrigado a @GamrCorps por fornecer a versão lambda deste código!

Obrigado a @ user902383 por apontar um truque de caixa automática!

...Sim.

Na verdade, é mais longo do que eu esperava - o Java substitui itens em cadeias por replaceAll()uma vez por correspondência, não repetidamente até que ele pare de mudar. Então eu tive que usar um laço for chique.

Formulário Lambda:

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

Formulário de função:

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

Código não testável testável:

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

A pontuação inclui +1 para a -ropção.

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

(Observe que [6|89]a versão não-capturada (6|89)está escrita como (?:6|89)no Perl 5. <[6|89]>é como você escreveria o que está escrito como [6|89]no 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

Pitão, 17 bytes

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

Experimente aqui.

Leaky Nun superou isso por um byte nos comentários.

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

Explicação:

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

Ferrugem, 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}

Irremediavelmente longa, como de costume para 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 bytes

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

Torna-se um pouco mais claro com espaços:

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

Ruby, 27 bytes

Esta solução é de comentários, crédito para Brad Gilbert b2gills .

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

Ruby, 37 bytes

(solução antiga)

Esta solução usa o fato de que você nunca precisará substituir mais vezes do que caracteres na sequência.

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

Japonês , 15 bytes

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

Solução RegEx simples

Experimente online

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

Fazendo uso de:

• padrão regex de outra pessoa
• da maneira -replaceque uma substituição global é padrão no PowerShell
• desenrolamento de loop, onde aplicará o -regexoperador à matriz $args, aplicando-o a todos os elementos individualmente, e há apenas um elemento aqui, porque há apenas um parâmetro de script, para que funcione bem e podemos evitar a indexação do elemento [0].

A tentativa anterior da novidade antes de realizar uma substituição global faria isso; 74 bytes de construção de uma cadeia de "-replace -replace -replace" usando a multiplicação de cadeias de caracteres, quantas vezes o comprimento da cadeia de caracteres, e depois avaliando ():

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

(Com um pouco de substituição de cadeia para reduzir o número de substituições).

CJam, 70 64 bytes

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

Eu sei que isso provavelmente poderia ser muito mais jogado e sua ajuda seria muito apreciada, mas, francamente, estou feliz por ter conseguido a resposta. Esta foi minha primeira tentativa de escrever CJam.

Explicação:

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

Exemplo

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

EDIT : Experimente online!

Explicação

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

Isso funciona aplicando uma substituição de expressão regular quantas vezes houver caracteres na sequência original . Isso é suficiente, pois cada substituição reduz o número de caracteres.

Sério, 29 bytes

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

Recebe entrada como uma cadeia de caracteres entre aspas duplas, como "6789". Experimente online (você precisará citar manualmente a entrada).

Explicação:

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

Ter , 26 bytes

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

incluindo uma nova linha à direita.

A entrada é anexada ao programa antes de iniciá-lo.
A saída é lida no estado do programa quando termina, da mesma forma que uma máquina de Turing.
(Thue faz ter um fluxo de saída, mas é difícil de usar corretamente, então eu não tenho certeza se este é um método de saída aceitável)

Bash, 102 82 67 (+7)? bytes

versão extglob

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

Isso deve ser colocado em um arquivo e chamado com, por exemplo bash -O extglob 789.sh 6567678989689789656. O (+7)? bytes é para se a opção extglob contar para bytes.

Obrigado ao @BinaryZebra por apontar os recursos do extglob!

Versão não 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

Isso deve ser colocado em um arquivo e chamado com, por exemplo ./789.sh 65678989656.

Utiliza a expansão de parâmetros para pesquisar e substituir em um loop. Envolvi uma série de expansões para fazer a substituição, pois não conheço uma maneira de encadear expansões com mais eficiência.

R, 35 bytes

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

Eu não sabia que poderia usar gsubdessa maneira, um grande obrigado por todas as respostas aqui que me fizeram aprender algo novo.

PHP 51 caracteres

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

Caso de teste escrito em mão longa

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

Isso faz a comparação de cadeias e as cadeias substituem ambas na condição while. Se enquanto condição for atendida, ele atualiza a mão esquerda da comparação com o resultado. Deixe-me saber de quaisquer melhorias.

Jolf , 15 bytes

Experimente aqui! Eu realmente tenho 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);

solução regex, pega $ a string e substitui pela expressão

Clojure, 71 bytes

Clojure é menos do que o ideal para o golfe devido à sua natureza detalhada - mas, no entanto, é um exercício interessante:

Versão com golfe, usando interoperabilidade Java:

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

Versão sem golfe, usando interoperabilidade Java:

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

Versão "pura Clojure" sem golfe:

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

/// , 19 bytes (não concorrente)

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

Você não pode realmente fornecer entrada nesse idioma; portanto, a suposta entrada vai para a direita do 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

Experimente online!

Como funciona

String.eé função de substituição recursiva. O Japt 2 possui uma nova sintaxe regex e o preenchimento automático de parênteses dentro do regex, o que economiza um byte aqui. (No Japão 1.x, tivemos que passar as strings no lugar das expressões regulares, o que era meio desajeitado.)

Dyalog APL , 17 bytes

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

'6*qualquer número de seis
7 seguido por sete
(... )*' seguido por zero ou mais seqüências de ...
 6|89 seis ou oito e nove

⎕R R EColoque que com

'7' pois mesmo

05AB1E , 12 bytes

Δ67‚7:789¬:

Experimente online ou verifique todos os casos de teste .

Explicação:

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