Un'attività che a volte faccio quando sono annoiato è quella di scrivere un paio di personaggi in coppie corrispondenti. Traccio quindi delle linee (sopra le cime mai sotto) per collegare questi personaggi. Ad esempio potrei scrivere e quindi le linee come:$abcbac$

O potrei scrivere$abbcac$

Dopo aver tracciato queste linee, provo a disegnare anelli chiusi attorno a blocchi in modo che il mio anello non intersechi nessuna delle linee che ho appena disegnato. Ad esempio, nel primo l'unico loop che possiamo disegnare è attorno all'intera cosa, ma nel secondo possiamo disegnare un loop attorno solo alla s (o tutto il resto)$b$

Se ci proviamo per un po 'scopriremo che alcune stringhe possono essere disegnate solo in modo che i loop chiusi contengano tutte o nessuna delle lettere (come il nostro primo esempio). Chiameremo tali stringhe stringhe ben collegate.

Si noti che alcune stringhe possono essere disegnate in più modi. Ad esempio può essere disegnato in entrambi i seguenti modi (e un terzo non incluso):$bbbb$

o

Se uno di questi modi può essere disegnato in modo tale che un loop chiuso possa contenere alcuni dei caratteri senza intersecare nessuna delle linee, la stringa non è ben collegata. (quindi non è ben collegato)$bbbb$

Compito

Il tuo compito è scrivere un programma per identificare le stringhe che sono ben collegate. Il tuo input sarà costituito da una stringa in cui ogni carattere appare un numero pari di volte e il tuo output dovrebbe essere uno dei due valori coerenti distinti, uno se le stringhe sono ben collegate e l'altro altrimenti.

Inoltre, il programma deve avere un significato di stringa ben collegato

• Ogni personaggio appare un numero pari di volte nel tuo programma.

• Dovrebbe produrre il valore di verità una volta superato.

Il programma dovrebbe essere in grado di produrre l'output corretto per qualsiasi stringa composta da caratteri da ASCII stampabile o dal proprio programma. Con ogni personaggio che appare un numero pari di volte.

Le risposte verranno classificate come lunghezze in byte con un numero inferiore di byte con un punteggio migliore.

Suggerimento

Una stringa non è ben collegata se esiste una sottostringa rigida contigua non vuota in modo tale che ciascun carattere appaia un numero pari di volte in quella sottostringa.

Casi test

abcbac -> True
abbcac -> False
bbbb -> False
abacbc -> True
abcbabcb -> True
abcbca -> False

Regex (ECMAScript 2018 o .NET), 140 126 118 100 98 82 byte

^(?!(^.*)(.+)(.*$)(?<!^\2|^\1(?=(|(<?(|(?!\8).)*(\8|\3$){1}){2})*$).*(.)+\3$)!?=*)

Questo è molto più lento della versione a 98 byte, perché ^\1è a sinistra del lookahead e viene quindi valutato dopo di esso. Vedi sotto per un semplice switcheroo che riacquista la velocità. A causa di ciò, i due TIO sottostanti sono limitati al completamento di un set di casi di test più piccolo rispetto a prima e quello .NET è troppo lento per controllare la propria regex.

Provalo online! (ECMAScript 2018)
Provalo online! (.NETTO)

Per eliminare 18 byte (118 → 100), ho spudoratamente rubato un'ottimizzazione davvero piacevole dal regex di Neil che evita la necessità di mettere un lookahead all'interno del lookbehind negativo (producendo un regex senza restrizioni di 80 byte). Grazie Neil!

Ciò è diventato obsoleto quando ha perso altri 16 byte (98 → 82) grazie alle idee di jaytea che hanno portato a una regex illimitata a 69 byte! È molto più lento, ma è golf!

Si noti che le (|(no-op per rendere il regex ben collegato hanno il risultato di farlo valutare molto lentamente in .NET. Non hanno questo effetto in ECMAScript perché le corrispondenze opzionali a larghezza zero vengono trattate come non corrispondenze .

ECMAScript proibisce quantificatori di asserzioni, quindi questo rende più difficile il golf dei requisiti di fonte limitata . Tuttavia, a questo punto è così ben golfato che non penso che sollevare quella particolare restrizione aprirebbe ulteriori possibilità di golf.

Senza i caratteri extra necessari per far passare le restrizioni ( 101 69 byte):

^(?!(.*)(.+)(.*$)(?<!^\2|^\1(?=((((?!\8).)*(\8|\3$)){2})*$).*(.)+\3))

È lento, ma questa semplice modifica (per soli 2 byte extra) riacquista tutta la velocità persa e altro:

^(?!(.*)(.+)(.*$)(?<!^\2|(?=\1((((?!\8).)*(\8|\3$)){2})*$)^\1.*(.)+\3))

^
(?!
    (.*)               # cycle through all starting points of substrings;
                       # \1 = part to exclude from the start
    (.+)               # cycle through all ending points of non-empty substrings;
                       # \2 = the substring
    (.*$)              # \3 = part to exclude from the end
    (?<!               # Assert that every character in the substring appears a total
                       # even number of times.
        ^\2            # Assert that our substring is not the whole string. We don't
                       # need a $ anchor because we were already at the end before
                       # entering this lookbehind.
    |                  # Note that the following steps are evaluated right to left,
                       # so please read them from bottom to top.
        ^\1            # Do not look further left than the start of our substring.
        (?=
            # Assert that the number of times the character \8 appears in our
            # substring is odd.
            (
                (
                    ((?!\8).)*
                    (\8|\3$) # This is the best part. Until the very last iteration
                             # of the loop outside the {2} loop, this alternation
                             # can only match \8, and once it reaches the end of the
                             # substring, it can match \3$ only once. This guarantees
                             # that it will match \8 an odd number of times, in matched
                             # pairs until finding one more at the end of the substring,
                             # which is paired with the \3$ instead of another \8.
                ){2}
            )*$
        )
        .*(.)+         # \8 = cycle through all characters in this substring
        # Assert (within this context) that at least one character appears an odd
        # number of times within our substring. (Outside this negative lookbehind,
        # that is equivalent to asserting that no character appears an odd number
        # of times in our substring.)
        \3             # Skip to our substring (do not look further right than its end)
    )
)

L'ho scritto usando lookahead molecolare ( 103 69 byte) prima di convertirlo in lookbehind di lunghezza variabile:

^(?!.*(?*(.+)(.*$))(?!^\1$|(?*(.)+.*\2$)((((?!\3).)*(\3|\2$)){2})*$))

^
(?!
    .*(?*(.+)(.*$))       # cycle through all non-empty substrings;
                          # \1 = the current substring;
                          # \2 = the part to exclude from the end
    (?!                   # Assert that no character in the substring appears a
                          # total even number of times.
        ^\1$              # Assert that our substring is not the whole string
                          # (i.e. it's a strict substring)
    |
        (?*(.)+.*\2$)    # \3 = Cycle through all characters that appear in this
                          # substring.
        # Assert (within this context) that this character appears an odd number
        # of times within our substring.
        (
            (
                ((?!\3).)*
                (\3|\2$)
            ){2}
        )*$
    )
)

E per aiutare a rendere il mio regex ben collegato, ho usato una variante del regex sopra:

(?*(.+)(.*$))(?!^\1$|(?*(.)+.*\2$)((((?!\3).)*(\3|\2$)){2})*$)\1

Se utilizzato con regex -xml,rs -o, identifica una rigida sottostringa dell'input che contiene un numero pari di ogni carattere (se presente). Certo, avrei potuto scrivere un programma non regex per farlo per me, ma dove sarebbe divertente?

Gelatina, 20 byte

ĠẈḂẸẆṖÇ€Ạ
ĠẈḂẸ
ẆṖÇ€Ạ

Provalo online!

La prima riga viene ignorata. È lì solo per soddisfare la condizione che ogni personaggio appaia un numero pari di volte.

La riga successiva Ġesegue il primo roup degli indici in base al loro valore. Se prendiamo quindi la lunghezza di ciascun elenco secondario nell'elenco risultante ( Ẉ), otteniamo il numero di volte in cui appare ciascun carattere. Per verificare se uno di questi non è pari, otteniamo l'ultimo Ḃdi ogni conteggio e chiediamo se esiste Ẹun valore di verità (diverso da zero).

Pertanto, questo collegamento helper indica se non è possibile cerchiare una sottostringa .

Nel collegamento principale, prendiamo tutte le sottostringhe dell'input ( Ẇ), Ṗopzioniamo l'ultima (in modo da non controllare se l'intera stringa può essere cerchiata) ed eseguiamo il collegamento helper ( Ç) su ogni €sottostringa. Il risultato è quindi se tutte le Ạsottostringhe non possono essere cerchiate.

J , 34 byte

2:@':.,|~*'>1(#.,)*/@(1>2|#/.~)\.\

Provalo online!

-8 byte grazie a FrownyFrog

originale

J , 42 byte

(*#'.,012&|@~#')=1#.[:,([:*/0=2&|@#/.~)\.\

Provalo online!

spiegazione

(*#'.,012&|@~#') = 1 #. [: , ([: */ 0 = 2&|@#/.~)\.\

(*#'.,012&|@~#')                                       NB. this evaluates to 1
                                                       NB. while supplying extra
                                                       NB. chars we need.  hence...
                 =                                     NB. does 1 equal...
                   1 #.                                NB. the sum of...
                        [: ,                           NB. the flatten of...
                             (                  )\.\   NB. the verb in parens applied
                                                       NB. to every suffix of every
                                                       NB. prefix, ie, all contiguous 
                                                       NB. substrings
                             ([: */ 0 = 2&|@#/.~)      NB. def of verb in paren:
                                             /.~       NB. when we group by each
                                                       NB. distinct char...
                              [: */                    NB. is it the case that
                                                       NB. every group...
                                           @#          NB. has a length...
                                    0 = 2&|            NB. divisible by 2...

Python 3.8 (pre-release) , 66 byte

lambda l,b={id}:len({str(b:=b^{c})for(c)in l})<len(l)#,<^fmnost{}#

Provalo online!

L'era delle espressioni di assegnazione è alle porte. Con PEP 572 incluso in Python 3.8, il golf non sarà più lo stesso. È possibile installare l'anteprima anticipata dello sviluppatore 3.8.0a1 qui .

Le espressioni di assegnazione consentono :=di assegnare a una variabile in linea mentre si valuta tale valore. Ad esempio, (a:=2, a+1)dà (2, 3). Questo può ovviamente essere usato per memorizzare variabili da riutilizzare, ma qui facciamo un passo ulteriore e lo usiamo come accumulatore in una comprensione.

Ad esempio, questo codice calcola le somme cumulative [1, 3, 6]

t=0
l=[1,2,3]
print([t:=t+x for x in l])

Nota come ad ogni passaggio attraverso la comprensione dell'elenco, la somma cumulativa tviene aumentata di xe il nuovo valore viene memorizzato nell'elenco prodotto dalla comprensione.

Allo stesso modo, b:=b^{c}aggiorna il set di caratteri bper alternare se include il carattere ce valuta il nuovo valore di b. Quindi, il codice [b:=b^{c}for c in l]itera su caratteri cin le si accumula il set di caratteri visto un numero dispari di volte in ogni prefisso non vuoto.

Questo elenco viene verificato per i duplicati rendendolo invece una comprensione set e vedendo se la sua lunghezza è inferiore a quella di s, il che significa che alcune ripetizioni sono state compresse. In tal caso, la ripetizione significa che nella parte di svista tra quelle volte ogni personaggio ha incontrato un numero pari di numeri, rendendo la stringa non ben collegata. Python non consente l'insensibilità di insiemi di insiemi, quindi gli insiemi interni vengono convertiti in stringhe.

Il set bviene inizializzato come argomenti facoltativi e viene modificato correttamente nell'ambito della funzione. Ero preoccupato che ciò avrebbe reso la funzione non riutilizzabile, ma sembra reimpostare tra le esecuzioni.

Per la restrizione della fonte, i caratteri spaiati vengono inseriti in un commento alla fine. Scrivere for(c)in lpiuttosto che for c in lcancellare le parentesi extra gratuitamente. Inseriamo idil set iniziale b, che è innocuo poiché può iniziare come qualsiasi set, ma il set vuoto non può essere scritto {}perché Python creerà un dizionario vuoto. Dal momento che le lettere ie dsono tra quelle che necessitano di associazione, possiamo mettere idlì la funzione .

Si noti che il codice genera booleani negati, quindi si darà correttamente Falsesu se stesso.

Python 2 , 74 byte

bmn0=f=lambda s,P={0},d=[]:s<" "if(P in d)else+f(s[f<s:],P^{s[0^0]},[P]+d)

Provalo online!

Scorre la stringa, tenendo traccia Pdell'insieme di caratteri visto finora un numero dispari di volte. L'elenco dmemorizza tutti i valori passati di P, e se vedi la corrente Pgià in d, ciò significa che nei personaggi visti da quel momento, ogni personaggio è apparso un numero pari di volte. In tal caso, controlla se abbiamo esaminato l'intero input: in caso affermativo, accetta perché l'intera stringa è accoppiata come previsto, e altrimenti rifiuta.

Ora sulla restrizione della fonte. I personaggi che necessitano di abbinamento sono inseriti in vari luoghi innocui, sottolineati di seguito:

bmn0=f=lambda s,P={0},d=[]:s<" "if(P in d)else+f(s[f<s:],P^{s[0^0]},[P]+d)
_____              _              _      _    _    ___        ___    

Le f<srestituisce 0durante l'associazione fuori uno f, approfittando del nome della funzione anche di essere fin modo che sia definito (per il momento la funzione è chiamata.) Il 0^0assorbe un ^simbolo.

L' 0In P={0}è sfortunato: in Python {}valuta un dict vuoto anziché un set vuoto come vogliamo, e qui possiamo inserire qualsiasi elemento non personaggio e sarà innocuo. Non vedo nulla di ricambio da inserire, e ho inserito 0e duplicato in bmn0, costando 2 byte. Si noti che gli argomenti iniziali vengono valutati quando viene definita la funzione, quindi le variabili che definiamo noi stessi non possono essere inserite qui.

Perl 6 , 76 byte

*.comb[^*X+(^*).map(^*)].grep({$_&[&]($_)}).none.Bag{*}.none%2#*^+XBob2rec%#

Provalo online!

A Qualunque lambda che restituisca una giunzione nessuna delle giunzioni nessuna che possa essere boolificata in un valore di verità / falsità. Consiglierei di non rimuovere ?ciò che boolifica il risultato di ritorno, altrimenti l'output diventa piuttosto grande .

Questa soluzione è un po 'più complesso di quanto necessario, a causa di diverse funzioni coinvolte essendo collegato, ad esempio .., all, >>, %%ecc, senza limitazione sorgente, questo potrebbe essere 43 bytes:

*.comb[^*X.. ^*].grep(?*).one.Bag{*}.all%%2

Provalo online!

Spiegazione:

*.comb                     # Split the string to a list of characters
      [^*X+(^*).map(^*)]   # Get all substrings, alongside some garbage
                        .grep({$_&[&]($_)})        # Filter out the garbage (empty lists, lists with Nil values)
                                           .none                 # Are none of
                                                .Bag{*}          # The count of characters in each substring
                                                       .none%2   # All not divisible by 2

                                               #*^+XBob2rec%#    And garbage to even out character counts

Perl 5 -p, 94, 86, 78 byte

m-.+(?{$Q|=@q&grp,$\|=$&eq$_^!grep+/^/&(@m=$g=~/\Q$_/g),($g=$&)=~/./g})(?!)-}{

ouput 0 se ben collegato 1 altrimenti.

78 byte

86 byte

94 byte

Come funziona

• -pcon il }{trucco finale da emettere $\alla fine
• m-.+(?{.. })(?!)-, per eseguire il codice su tutta la sottostringa non vuota ( .+corrisponde prima all'intera stringa e dopo aver eseguito il codice tra (?{.. })backtracks a causa di un errore forzato(?!)
• $Q|=@q&grp, immondizia a causa della limitazione della fonte
• $\|=intero bit per bit o assegnazione, se ne esiste quasi 1, $\sarà 1 (vero), per impostazione predefinita è vuoto (falso)
• $&eq$_il caso in cui lo sbustring è l'intera stringa è bitoredato ^con "non si verifica alcun carattere dispari"
• ($g=$&)=~/./gper copiare la sottostringa abbinata in $g(perché sarà sovrascritta dopo la prossima regex match) e restituire l'array di caratteri della sottostringa.
• /^/ immondizia che valuta 1
• grep1 &(@m=$g=~/\Q$_/g),per ogni carattere nella sottostringa ottiene la matrice di caratteri nella $gcorrispondenza stessa, la matrice in scalare valuta le sue dimensioni e grepper filtrare i caratteri con occorrenza dispari 1&xè equivalente ax%2==1

Retina , 150 96 byte

^(?!(.*)(.+)(.*)$(?<!^\2|^\1(?:(^?(?:(?!\6).)*\6){2})*(|(?!\6).)*(?!.+\6.*\3$)(.){1,}\3)(?!,<)?)

Provalo online! Link include casi di test, incluso se stesso. Modifica: gira leggermente verso il basso la regex originale con l'aiuto di @Deadcode, quindi esegui un backup leggermente meno stravagante per mantenere il layout di origine. Spiegazione:

^(?!(.*)(.+)(.*)$

Asserire che non \3esiste alcuna sottostringa che corrisponda ai seguenti vincoli.

(?<!^\2|

Asserire che la sottostringa non è l'intera stringa originale.

^\1(?:(^?(?:(?!\6).)*\6){2})*(|(?!\6).)*(?!.+\6.*\3$)(.){1,}\3)(?!,<)?)

Asserire che non esiste un carattere \6tale che:

• non appare tra il personaggio stesso (esclusivo) e la fine della sottostringa
• appare un numero pari di volte tra l'inizio della sottostringa e se stesso (esclusivo)

Per superare il vincolo del layout di origine, ho sostituito ((((con (?:(^?(?:(e ((con (|(. Avevo ancora un vincolo sorgente ))e i personaggi erano !()1<{}rimasti, quindi ho cambiato un +in {1,}e ho inserito l'inutile (?!,<)?per consumare il resto.

C # (compilatore interattivo Visual C #) , 208 206 200 198 byte

x=>!x.GroupBy(c=>c).Any(g=>g.Count()%2>0)&!Enumerable.Repeat(x.Count,x.Count*x.Count).Where(
(l,i)=>i%l>0&!x.Skip(i/l).Take(i%l).GroupBy(c=>c).Any(g=>g.Count()%2>0)
).Any()/*>!oyAnC0EmeablR*WhiS/T*/

Provalo online!

-2 byte grazie a @KevinCruijssen!

Finalmente ho ottenuto un valore inferiore a 200, quindi potrei aver finito di giocare a golf per ora :) Ho finito per creare un secondo TIO per testare le cose in base a una risposta precedente.

Provalo online!

Cose che hanno reso difficile questo compito:

• L'operatore di uguaglianza ==non era permesso
• L'operatore di incremento / assegnazione ++non era consentito
• La All()funzione Linq non era consentita

Codice commentato di seguito:

// anonymous function that takes an IList as input
x=>
  // the first condition makes sure the string even
  // counts of each character
  !x.GroupBy(c=>c).Any(g=>g.Count()%2>0)&
  // the second condition generates all proper substrings of x
  // and tests for any that contain even character counts
  // the string length `l` is repeated `l*l` times
  !Enumerable.Repeat(x.Count,x.Count*x.Count)
    .Where((l,i)=>
      // check that the substring length is greater than 0
      i%l>0&
      // use skip/take to generate a substring
      // and check for a character count thats odd
      // negate the result meaning we have found
      // a substring that invalidates the input
      !x.Skip(i/l).Take(i%l)
        .GroupBy(c=>c).Any(g=>g.Count()%2>0)
    )
    // if any invalid substrings are found
    // then the result in invalid
    // the comment string at the end is needed
    // to make the program well-linked
    .Any()/*>!oyAnC0EmeablR*WhiS/T*/

Python 2 , 108 byte

lambda d,e=enumerate:min(max(d[l:l+b].count(k)%2for(k)in d)for b,c in e(d[2:],2)for l,f in e(d) )#b =:x+.%2#

Provalo online!

-2 grazie a Ørjan Johansen .

Brachylog , 16 byte

sᶠb∋p~j&sᶠb∋p~j&

Provalo online!

Stampa false.per esempi veritieri e true.per casi falsi. La versione TIO è troppo lenta per gestire se stessa, ma è chiaramente ben collegata poiché è una stringa con caratteri unici ripetuti due volte.

Spiegazione

    Input is a string: "abcacbaa"
sᶠ  Find all substrings: ["abcacbaa","abcacba","abcacb",..,"a"]
b   Behead (now the proper substrings remain): ["abcacba","abcacb",..,"a"]
∋   Take one of them: "abcacb"
p   Permute it: "abcabc"
~j  It is some string repeated twice: "abc"
&   Get the input again: "abcacbaa"
    Then repeat the above.
    If the constraints can be satisfied, the result is true, otherwise false.

05AB1E , 22 20 byte

Œε¢Pà}KŒIKεSIS¢ÈP}àÈ

Emette 1se la stringa è ben collegata e 0se la stringa non è ben collegata.

Provalo online o verifica tutti i casi di test .

Spiegazione:

Il programma di base è ŒsKεsS¢ÈP}à( 11 byte ), che genera 0se ben collegato e 1se non ben collegato. Il trailing È(is_even) è un semi-no-op che inverte l'output, quindi 1per stringhe ben collegate e 0per stringhe non ben collegate. Le altre parti non sono operative per conformarsi alle regole della sfida.

Œε¢Pà}K         # No-ops: substrings, map, count, product, maximum, close map, remove
                # Due to the last remove, we're back at the (implicit) input again
Π              # Take the substrings of the input
 IK             # Remove the input itself from that list of substrings
   ε            # Map each substring to:
    S           #  No-op: transform the substring into a list of characters
     IS         #  Get the input-string as a list of characters
       ¢        #  Count the occurrence of each character in the current substring
        È       #  Check which counts are even (1 if truthy; 0 if falsey)
         P      #  Take the product of that
          }à    # After the map: check if any are truthy by taking the maximum
            È   # Semi no-op: check if this maximum is even (0 becomes 1; 1 becomes 0)
                # (and output the result implicitly)