Perché 6 aveva paura di 7? Perché 7 8 9!

Data una stringa applicare le seguenti trasformazioni:

• Se c'è un 6 accanto a un 7 rimuovi il 6 (6 ha paura di 7)
• Se appare la sequenza "789", rimuovi l'8 e il 9 (7 ha mangiato 9)

(Se non sbaglio, non importa in quale ordine fai le trasformazioni)

Continua ad applicare queste trasformazioni fino a quando non puoi più.

Esempio:

78966

Per prima cosa vediamo "789", quindi la stringa diventa "766". Quindi vediamo "76", quindi estraiamo il 6 e la stringa diventa "76". Quindi vediamo di nuovo "76", quindi rimaniamo con "7".

Casi test:

• 987=> 987(Non nell'ordine giusto. Non fa nulla.)
• 6 7=> 6 7(Lo spazio bianco funge da buffer tra 6 e 7. Non succede nulla)
• 676 => 7
• 7896789 => 77
• 7689 => 7
• abcd => abcd

Retina , 12

Traduzione della risposta sed:

6*7(6|89)*
7

Provalo online

Javascript ES6, 29 byte

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 byte

Grazie a @GamrCorps per aver fornito la versione lambda di questo codice!

Grazie a @ user902383 per aver segnalato un trucco di boxe automatica!

...Sì.

In realtà è più lungo di quanto mi aspettassi: Java sostituisce gli elementi nelle stringhe con replaceAll()una volta per corrispondenza, non ripetutamente fino a quando non smette di cambiare. Quindi ho dovuto usare una fantasia per loop.

Forma lambda:

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

Modulo di funzione:

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

Codice Ungolfed testabile:

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

Il punteggio include +1 per l' -ropzione.

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

Perl 6 , 19  18 byte

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

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

(Si noti che [6|89]è la versione non acquisita di (6|89)cui si scrive come (?:6|89)in Perl 5. <[6|89]>è come si scriverebbe ciò che è scritto come [6|89]in Perl 5)

utilizzo:

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

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

Provalo qui.

Leaky Nun lo ha superato di un byte nei commenti.

Perl 5 , 17 byte

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

utilizzo:

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

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

Spiegazione:

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

Ruggine, 96 byte

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

Disperatamente lungo, come al solito per 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 byte

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

Diventa un po 'più chiaro con gli spazi:

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

Rubino, 27 byte

Questa soluzione deriva dai commenti, merito a Brad Gilbert b2gills .

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

Rubino, 37 byte

(vecchia soluzione)

Questa soluzione utilizza il fatto che non sarà mai necessario sostituire più volte dei caratteri nella stringa.

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

Japt , 15 byte

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

Soluzione RegEx semplice

Provalo online

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

Utilizzando:

• il modello regex di qualcun altro
• il modo in cui -replaceun globale sostituisce per impostazione predefinita in PowerShell
• srotolamento del ciclo, in cui applicherà l' -regexoperatore alla matrice $argsapplicandolo a tutti gli elementi singolarmente, e qui c'è solo un elemento perché c'è solo un parametro di script, quindi funziona bene e possiamo evitare di indicizzare l'elemento [0].

Novità del precedente tentativo prima di realizzare un sostituto globale lo farebbe; 74 byte di costruzione di una catena di "-replace -replace -replace" utilizzando la moltiplicazione della stringa, tante volte quanto la lunghezza della stringa, quindi eval () ing:

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

(Con un po 'di sostituzione della stringa per abbreviare il numero di sostituzioni).

CJam, 70 64 byte

Grazie a @Peter Taylor per il taglio {"789":I}{"76:":I}?di"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

So che probabilmente questo potrebbe essere ulteriormente approfondito e il tuo aiuto sarebbe molto apprezzato, ma sinceramente sono solo felice di essere riuscito a ottenere la risposta. Questo è stato il mio primo tentativo di scrivere CJam.

Spiegazione:

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

jt"'789|76'55cYX]

Esempio

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

EDIT : provalo online!

Spiegazione

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

Funziona applicando una normale sostituzione di espressione per tutte le volte che ci sono caratteri nella stringa originale . Questo è sufficiente, poiché ogni sostituzione riduce il numero di caratteri.

Scherzi a parte, 29 byte

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

Accetta l'input come una stringa tra virgolette, come "6789". Provalo online (dovrai citare manualmente l'input).

Spiegazione:

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

Quindi , 26 byte

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

tra cui una nuova riga finale.

L'input viene aggiunto al programma prima di avviarlo.
L'output viene letto dallo stato del programma quando termina, in modo simile a una macchina di Turing.
(Thue ha avere un flusso di output, ma è difficile da usare in modo corretto, quindi non sono sicuro se questo è un metodo di uscita accettabile)

Bash, 102 82 67 (+7)? byte

versione extglob

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

Questo è pensato per essere messo in un file e chiamato con es bash -O extglob 789.sh 6567678989689789656. Il (+7)? byte è se l'opzione extglob conta ai byte.

Grazie a @BinaryZebra per aver segnalato le funzionalità di extglob!

Versione non extglob (82 byte)

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

Questo è pensato per essere messo in un file e chiamato con es ./789.sh 65678989656.

Utilizza l'espansione dei parametri per cercare e sostituire in un ciclo. Ho coinvolto una serie di espansioni per fare il rimpiazzo poiché non sono a conoscenza di un modo per incatenare più efficacemente le espansioni.

R, 35 byte

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

Non sapevo di poter usare in gsubquesto modo, un grande grazie per ogni risposta qui che mi ha fatto imparare qualcosa di nuovo.

PHP 51 caratteri

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

Test case scritto a mano lunga

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

Questo fa il confronto tra stringhe e la stringa sostituisce entrambe nella condizione while. Se mentre la condizione è soddisfatta, aggiorna la mano sinistra del confronto con il risultato. Fammi sapere di eventuali miglioramenti.

Jolf , 15 byte

Provalo qui! Devo davvero spiegare?

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 byte

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

soluzione regex, prende $ una stringa e la sostituisce tramite l'espressione.

Clojure, 71 byte

Clojure è tutt'altro che ideale per il golf a causa della sua natura verbosa - ma è comunque un esercizio interessante:

Versione golfizzata, con interoperabilità Java:

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

Versione non giocata a golf, usando l'interoperabilità Java:

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

Versione "golf Clojure" senza golf:

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

/// , 19 byte (non concorrenti)

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

In realtà non è possibile fornire input in questa lingua, quindi l'input supposto va a destra del codice.

Python 3, 46 byte

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

Japt v2.0a0, 12 byte

e/6?7(6|89/7

Provalo online!

Come funziona

String.eè la funzione di sostituzione ricorsiva. Japt 2 ha una nuova sintassi regex e il completamento automatico delle parentesi all'interno di regex, che qui salva un byte. (In Japt 1.x, dovevamo passare le stringhe al posto delle regex, che era un po 'goffo.)

Dyalog APL , 17 byte

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

'6*qualsiasi numero di sei
7 seguito da un sette
(... )*' seguito da zero o più sequenze di ...
 6|89 un sei o otto-nove

⎕R R EPosizionare che con

'7' un sette

05AB1E , 12 byte

Δ67‚7:789¬:

Provalo online o verifica tutti i casi di test .

Spiegazione:

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