Sfida

Per questa sfida, una stringa montagnosa è una stringa conforme alla regola grammaticale in M: x(Mx)*cui ad ogni produzione, tutte le x sono lo stesso carattere. Una volta rientrata, una stringa montuosa potrebbe assomigliare a questa:

A
 B
  C
   D
  C
   E
    F
   E
  C
 B
A

Come puoi vedere, sembra un po 'come una montagna di lato.

Definizione formale

• Ogni singolo personaggio aè montuoso.
• Se Sè una stringa montuosa ed aè un personaggio, allora aSaè montuosa, dove la giustapposizione rappresenta la concatenazione di stringhe.
• Se aSae aTasono stringhe montuose, allora aSaTaè una stringa montuosa. Si noti che questa regola implica che questo modello vale per qualsiasi numero di ripetizioni. (vale a dire aSaTaUa, aSaTaUaVa, aSaTaUaVaWa... sono tutti montagnosa.)

Esempi

Tutti i palindromi di lunghezza dispari sono montuosi, ad esempio:

t
 a
  c
   o
  c
 a
t

qwertytrasdfdgdsarewqjklkjq è un esempio meno banale:

q
 w
  e
   r
    t
     y
    t
   r
    a
     s
      d
       f
      d
       g
      d
     s
    a
   r
  e
 w
q
 j
  k
   l
  k
 j
q

Esempi di output

a                           ==> true
aaa                         ==> true
mom                         ==> true
tacocat                     ==> true
qwertytrasdfdgdsarewqjklkjq ==> true
wasitacaroraratisaw         ==> true
abcbcbcbcba                 ==> true
aaaaabcbbba                 ==> true

<empty string>              ==> false
aa                          ==> false
pie                         ==> false
toohottohoot                ==> false
asdfdghgfdsa                ==> false
myhovercraftisfullofeels    ==> false

Regole

• Questo è un problema decisionale, quindi qualsiasi rappresentazione di vero o falso è un output valido fintanto che è corretto, coerente, inequivocabile e il programma termina in un tempo finito. Assicurati di indicare la convenzione di output con la tua soluzione.
  • Dovrebbe essere banale determinare se l'output indica vero o falso senza dover sapere quale sia la stringa di input. Si noti che ciò non significa che i risultati di verità o falsità debbano essere costanti, tuttavia la convenzione di "stampare una stringa montuosa se la stringa è montuosa e una stringa non montuosa se non montuosa" è una scappatoia vietata per ovvie ragioni.
  • D'altra parte, una convenzione come "genera un'eccezione per il falso ed esce silenziosamente per il vero" andrebbe bene, così come "stampa un singolo personaggio per il vero e qualsiasi altra cosa per il falso"
• Questo è il golf del codice, quindi vince il programma più breve.
• Le scappatoie standard sono vietate.

Japt v2 , 14 13 byte

e/.).\1/_g
¥g

Provalo online!

Pulito , 94 89 87 80 byte

import StdEnv
?[a,b,c:s]=[a: ?if(a==c)s[b,c:s]]
?l=l
$s=limit(iterate?s)==[hd s]

Provalo online!

Perl, 22 byte

Include +perp

perl -pe '$_=/^((.)((?1)\2)*)$/' <<< abcbcbcbcba

Stampa 1 per vero, niente per falso

Brain-Flak , 78 byte

({()<<>(([{}]({}))([{}]({}))<>[({}<>)])>{[()()]((<()>))}<{}{}{}<>>}(())){{}}{}

Provalo online!

Stampa 1 per vero, niente per falso.

Per verificare una parola montuosa, è sufficiente supporre che la parola vada "giù" dalla montagna ogni volta che è possibile.

Python 2 , 89 83 byte

f=lambda s:re.search(M,s)and f(re.sub(M,r'\1',s))or len(s)==1
import re;M=r'(.).\1'

Provalo online!

Grazie a ovs per 6 byte.

Prolog (SWI) , 29 byte

a-->[X],+X.
+X-->[];a,[X],+X.

Provalo online!

Questo programma definisce una regola DCG a//0che corrisponde a qualsiasi stringa (elenco di caratteri) che è una stringa montuosa.

Spiegazione

Per questo programma uso una definizione leggermente diversa ma equivalente per stringhe montagnose rispetto a quanto descritto nella sfida: Una stringa montagnosa è un carattere cseguito da un numero (potrebbe essere zero) di stringhe montagnose con cvirate alle estremità. In una notazione derivata da regex più concisa, una stringa montuosa deve corrispondere al modello in c(Mc)*cui si Mtrova una stringa montuosa e *significa che l'espressione tra parentesi viene ripetuta zero o più volte. Si noti che mentre ognuno cdeve avere lo stesso carattere, Mnon è necessario che ciascuno abbia la stessa stringa montuosa.

Prova di equivalenza

È chiaro che le regole 1 e 2 della sfida sono equivalenti alla mia regola dove si Mcverifica rispettivamente zero e una volta.

Nel caso in cui la stringa montagnosa abbia tempi Mcricorrenti in ncui n > 1la stringa può essere riscritta come cMcScdove Ssono le ultime n - 1volte che si Mcverificano escludendo l'ultima c(si noti che Mè qualsiasi stringa montagnosa e non necessariamente uguale all'altra M). Poiché Mè una stringa montuosa, secondo la regola 2, cMcdeve essere una stringa montuosa. O Sè una stringa montuosa nel qual caso cScè una stringa montuosa o Spuò essere riscritta come cMcTcdove si Ttrovano le ultime n - 2volte che si Mcverificano escludendo l'ultima c. Questa linea di ragionamento può continuare ad essere applicata fino a quando la stringa non è garantita per essere montuosaMcuna volta ciò significherebbe che dovrebbe essere anche montuoso. Quindi, poiché cMcè montuoso e se cMce cM'csono montagnosi, allora cMcM'cdeve essere montuoso, tutta la corda deve essere montuosa.

Per il contrario, per una stringa in cScTccui cSce cTcsono montuosi, allora o cScè una stringa montuosa secondo la regola 2 o secondo la regola 3. Se è una stringa montuosa secondo la regola 2, allora Sdeve essere anche una stringa montuosa. Se è una stringa montuosa secondo la regola 3, allora cScdeve essere della forma in cUcVccui cUce cVcsono stringhe montuose. Poiché il più lungo di cUce cVcdeve essere ancora almeno due caratteri più corto di cSce la regola 3 richiede l'applicazione di almeno 5 caratteri, dopo un numero finito di applicazioni della regola 3 ogni stringa tra le cs selezionate dalle applicazioni della regola 3 deve essere montuosa stringa. La stessa linea di ragionamento può essere applicata acTc quindi la stringa è montuosa secondo la mia definizione.

Poiché qualsiasi stringa che corrisponde alla mia definizione è montuosa e la mia definizione corrisponde a tutte le stringhe montuose, è equivalente a quella fornita nella domanda.

Spiegazione del codice

Nel complesso la a//0regola DCG, definita sulla prima riga, corrisponde a qualsiasi stringa montuosa. La +//1regola DCG (come i predicati, le regole DCG possono essere fornite da nomi di operatori ), definita alla riga due, corrisponde a qualsiasi stringa composta da una sequenza di zero o più stringhe montagnose con il carattere passato mentre i suoi argomenti Xvenivano attaccati alle loro estremità . O per prendere in prestito la notazione simile alla regex che ho usato sopra, a//0corrisponde c(Mc)*ma esternalizza il lavoro di abbinare effettivamente quello (Mc)*a +//1cui prende ccome argomento X.

Riga per riga i codici si comportano come segue:

a-->[X],+X.

Questa riga definisce la regola DCG a. Gli [X]stati che il primo carattere deve essere uguale alla variabile attualmente non definito X. Ciò si traduce in Xessere impostato uguale al primo carattere. L' +Xallora afferma che il resto della stringa deve corrispondere la regola DCG +//1con il carattere che Xè impostato come argomento.

+X-->[];a,[X],+X.

Questa riga definisce la +//1regola DCG. Il ;rappresenta un o in Prolog, il che significa che la stringa può corrispondere a []o a,[X],+X. La []rappresenta la stringa vuota, quindi +//1è sempre in grado di identificare una stringa vuota. Se la stringa non è vuota, l'inizio deve corrispondere a//0e quindi deve essere una stringa montuosa. Questo deve quindi essere seguito da qualunque personaggio Xsia impostato. Infine, il resto della stringa deve corrispondere +X.

Buccia , 15 byte

εωφΓ§?t·:⁰`(=←t

Provalo online! L'inferenza del tipo dura circa 40 secondi, quindi sii paziente.

Spiegazione

εωφΓ§?t·:⁰`(=←t  Implicit input, say s = "abacdca"
 ω               Apply until fixed point is reached
  φ              this self-referential anonymous function (accessed with ⁰):
                  Argument is a string x.
   Γ              Deconstruct x into head h and tail t.
    §?t·:⁰`(=←t   Call this function on h and t. It is interpreted as §(?t)(·:⁰)(`(=←t)).
                  § feeds h to (·:⁰) and (`(=←t)), and calls (?t) on the results.
                  The semantics of ? cause t to be fed to all three functions.
          `(=←t   First, check whether h equals the first element (←) of the tail of t.
     ?t           If it does (e.g. if h='a' and t="bacdca"), return tail of t ("acdca").
                  Otherwise (e.g. if h='b' and t="acdca"),
       · ⁰        call the anonymous function recursively on t: "aca"
        :         and prepend h to the result: "baca".
                 Final result is "a".
ε                Is it a 1-element string? Implicitly print 0 or 1.

L'idea è di sostituire ripetutamente una sottostringa del modulo abacon afino a quando ciò non è più possibile. L'input è montuoso se e solo se ciò si traduce in una stringa a carattere singolo (che è ciò che εverifica). L'unica situazione pericolosa è quando abbiamo una stringa come questa, dove abanon sembra essere un picco:

a
 b
  a
   c
  a
   d
  a
 b
a

Fortunatamente, possiamo sempre trasformarlo in uno:

a
 b
a
 c
a
 d
a
 b
a

Retina 0.8.2 , 15 byte

+`(.).\1
$1
^.$

Provalo online! Trivial port della risposta Japt di @ETHproductions.

JavaScript (Node.js) , 53 byte

Suppongo che questo sia quasi il metodo più semplice per farlo?

f=s=>(w=s.replace(/(.).\1/,"$1"))==s?w.length==1:f(w)

Provalo online!

JavaScript (Node.js) , 72 byte

Meno banale, ma molto più lungo.

s=>[...s].reduce((a,x)=>(a[a.length-2]==x?a.pop():a.push(x),a),[])==s[0]

Provalo online!