Perché 6 aveva paura di 7?


61

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

130
Perché Vista aveva paura di 7? Perché 7 8 10.
lirtosiast

2
Un altro caso di test 68978966897896=>68977
Brad Gilbert b2gills

19
@ThomasKwa Oh, ho capito: Microsoft ha saltato Windows 9 perché stavano andando insieme all'enigma. ;)
ETHproductions

43
Perché la paura di sette aveva cinque anni? Perché sei sette otto. --Yoda
Jakuje,

2
Sei aveva paura di sette perché sette avevano gli occhi freddi e morti.
Conor O'Brien,

Risposte:



12

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

12
Fantastico, e dato che 9 vengono mangiati, hai solo 2 byte e vinci con questa risposta: P
Pierre Arlaud,

12

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

2
Perché non andare con una lambda? Salverà almeno 15 byte
GamrCorps il

@GamrCorps Non so come esprimerlo, non usare mai le funzioni.
Addison Crump,

1
qual è il punto di interfaccia e non di classe?
eis,

3
L'interfaccia @eis elimina la necessità di dichiarare main come pubblico, il che offre il minimo vantaggio. Vedi: codegolf.stackexchange.com/a/64713/44713
Addison Crump,

1
@ user902383 La riduzione che stai facendo è cambiando .equalsin !=, che non fa la stessa cosa. ==(o !=) confronta per posizione esadecimale dell'oggetto, non per valore. È la stessa lunghezza altrimenti. while()è 7 byte, for(;;)è 7 byte.
Addison Crump,


8

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

Non conosco Perl 6, ma suppongo che questa sia una sostituzione ripetuta. Se il 6*e il [6|89]*non corrispondono a nulla, cosa impedisce che 7venga sostituito 7all'infinito?
Trauma digitale

2
@DigitalTrauma Si scambia 7con 7poi ricomincia dalla posizione successiva, lavorando fino alla fine. :gè breve per :globalno repeat until it doesn't match anymore.
Brad Gilbert b2gills

1
@DigitalTrauma Per mettermi s/67|76|789/7/al lavoro, 667dovrei scriverlo come qualcosa per l'effetto di: while s/67|76|789/7/ {}che ovviamente non si fermerebbe mai se lo scrivessi while s/6*7[6|89]*/7/ {}come ti aspetteresti. Inoltre, la fine del commento precedente potrebbe
apparire

1
Non dovrebbe []essere cambiato in ()? Non vuoi abbinare pipe o 79999.
jwodder,

1
@jwodder No []è la versione non-cattura di Perl 6 (), ciò che stai pensando è scritto come <[6|89]>in Perl 6.
Brad Gilbert b2gills


4

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

4

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.

8
Il codice di golf è più chiaro del codice di spiegazione .. :)
Rob,

@Rob non ha fatto molte spiegazioni prima, optando per un approccio sistematico.
LegionMammal978,

Stavo solo scherzando, amico :)
Rob,

3

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
}

Almeno non è Java

3

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

3

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}

È possibile utilizzare charsinvece di size.timessalvare alcuni byte.
Maniglia della porta

Ruby non ha il flag globale per la sostituzione regex, o richiederebbe più byte per abilitare?
Brad Gilbert b2gills

@ BradGilbertb2gills, in Ruby è come in Awk: ci sono metodi separati sub()e gsub()per sostituire prima o tutti. Quindi globale è solo un personaggio in più.
arte

1
@manatwork Quindi scriverei qualcosa del tipo: ->s{s.gsub /6*7(6|89)*/,'7'}e lasciamo gsubfare tutto il lavoro in loop.
Brad Gilbert b2gills

Se capisco correttamente le regole dei flag della riga di comando, potresti salvare 16 byte usando il flag della riga di comando -p (+1) rendendolo gsub /6*7(6|89)*/,?7utilizzabile ruby -pe "gsub /6*7(6|89)*/,?7"per un totale di 20 + 1 byte
Alexis Andersen


2

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


2

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

Non ho tentato questa domanda da solo, quindi non sono sicuro se questo sia l'approccio migliore, ma se vuoi fare una divisione e unirti, dai un'occhiata a /e *. Nota anche che pensare in termini di pile quando sei abituato a linguaggi simili al C richiede un certo adattamento. Ad esempio {"789":I}{"76":I}?può estrarre il compito per diventare "789""76"?:I, che può essere ulteriormente golfato 78976`3/?:I.
Peter Taylor,

Grazie! Non riuscivo ancora a capire come usare il tuo secondo suggerimento.
Conrad Crates,

Scusa, errore mio. 78976`3/dà una matrice ["789" "76"]; quindi invece di utilizzare ?è necessario utilizzare =per indicizzare; ma è back-to-front, quindi avrebbe bisogno di invertire l'indice, perdendo il vantaggio.
Peter Taylor,

2

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.


1

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"

1

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)


Io non la penso così. Se hai un modo per STDOUT, devi farlo. Scusate!

Sì, questo è consentito in base al meta post.
geokavel,

1

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.


Benvenuti in PPCG!
Mego

@BinaryZebra Ah, grazie per la @()sintassi. Sapevo che doveva esserci un modo per combinare quelli. E @Mego, grazie per l'accoglienza!
Pooping,

1

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.


0

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.


0

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

0

PHP, 36 byte

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

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


I parametri GET non sono accettabili come metodo di input in PHP . Sarà necessario rendere questa una funzione e passare l'input come parametro di funzione, oppure ottenere input da $argvo STDIN.
Mego

@Mego Non sembra esserci consenso sul post a cui sei collegato.
user253751

@immibis Correct. È necessario un consenso per rendere accettabile un metodo I / O. La mancanza di uno significa che non è accettabile.
Mego

TL; DR hai gravi svantaggi se usi PHP per codegolf.
HamZa,

0

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


0

Python 3, 46 byte

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

0

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


0

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

⎕RR EPosizionare che con

'7' un sette


0

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)
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.