Recentemente iBug ha ottenuto una lunga barra in materiale composito, ma prezioso. Il bar è così lungo che iBug non può facilmente venderlo per i crediti, quindi vuole tagliarlo. La barra è realizzata con materiali così fragili e magici che, se una parte viene rotta, anche tutte le parti della barra realizzate con lo stesso materiale si rompono, rendendo difficile il taglio arbitrario.

iBug vuole tagliare la barra in più pezzi possibili. Ama anche programmi molto brevi e code-golf, quindi ha fatto un'analisi astratta del suo problema.

La barra magica di iBug è rappresentata come una stringa (o una matrice o una sequenza di caratteri se preferisci), in questo modo:

aaabbccccccbbbaaacccccaabbbaaaaa

Ogni lettera nella stringa rappresenta un materiale magico. La barra corrisponde sempre a RegEx ^\w*$, quindi potrebbero esserci fino a 63 materiali nella barra. Una "parte" è una sequenza consecutiva di tutti i caratteri che non sono separati da spazi.

iBug vuole che tu scriva un programma che calcoli il numero massimo di parti che potrebbe ottenere, se zero o più set di caratteri vengono completamente rimossi (sostituiti da spazi) e comunichi a iBug quel numero.

Esempio 1:

In:  aaabbccccccbbbaaacccccaabbbaaaaa
Out: 4

Descrizione: se bviene completamente rimosso dalla barra, iBug potrebbe ottenere 4 parti. Può anche ottenere 4 parti rimuovendo be c, come mostrato di seguito

aaabbccccccbbbaaacccccaabbbaaaaa  # Original string
aaa  cccccc   aaacccccaa   aaaaa  # Remove 'b'
aaa           aaa     aa   aaaaa  # Remove 'b' and 'c'

E questo è il numero massimo di parti che iBug può ottenere da questa barra

Esempio 2:

In:     111aa___9999____aaa99111__11_a_aa999
Result: 111aa   9999    aaa99111  11 a aa999
Out:    6

Descrizione: Rimuovendo solo il trattino basso, iBug può ottenere 6 parti dalla barra e questo è il massimo.

Esempio 3:

In:  __________
Out: 1

Descrizione: cosa? Vuoi tagliare questo? È possibile ottenere 1 parte solo se non la si taglia affatto.

Esempio 4:

In:  
Out: 0

Descrizione: Non c'è niente da tagliare, quindi zero.

Ci sono anche alcune regole a cui iBug vuole che i programmi obbediscano:

1. a iBug non piacciono le scappatoie standard e sono vietate.

2. Finché funziona, non è necessario che sia un programma completo. È accettata anche una funzione che accetta input da un parametro e fornisce output tramite il valore di ritorno.

3. Sono consentiti input e output flessibili. Il tuo programma o funzione può prendere una stringa, o una matrice di caratteri, o qualunque cosa tu trovi più facile da gestire. È possibile fornire l'output stampando il numero o restituendolo.

Esempi di casi di test (ma non limitati a questi)

aaabbbaaa           = 2
123456789           = 5
AaAaAaAa            = 4
aaabcccdedaaabefda  = 6
________            = 1
(empty)             = 0

Dato che si tratta di un codice-golf , vince il programma più breve (in byte) in ogni lingua!

Extra

iBug apprezza molto se puoi fornire una spiegazione per il tuo programma, anche se non influenza il tuo punteggio (è ancora lunghezza in byte).

Haskell , 73 71 70 byte

x#z|z==x=' '|1<2=z
f x=maximum$length(words x):[f$(c#)<$>x|c<-x,c>' ']

^{Grazie a Laikoni per aver salvato 1 byte!}

Provalo online!

JavaScript (ES6), 109 90 byte

f=s=>Math.max((s.match(/\s+/g)||[]).length,...[...s].map(c=>c>` `&&f(s.split(c).join` `)))

<input oninput=o.textContent=/\s/.test(this.value)?``:f(this.value)><pre id=o>0

Un po 'lento sul 123456789caso di test. La precedente risposta da 109 byte non era limitata a !/\s/:

f=
s=>(g=a=>Math.max(a.filter(s=>s).length,...[...a.join``].map(c=>g([].concat(...a.map(s=>s.split(c)))))))([s])

<input oninput=o.textContent=f(this.value)><pre id=o>0

Python 2 , 111 93 72 byte

-21 byte grazie Kirill L.

f=lambda s:max([len(s.split())]+[f(s.replace(c,' '))for c in s if'/'<c])

Provalo online!

Gelatina ,  13  11 byte

^{Troppe istruzioni a 2 byte}
-2 grazie a Zgarb (utilizzare il prodotto esterno rapidoþ>. <)

eþŒPŒr¬S€ṀḢ

Un collegamento monadico che accetta un elenco di caratteri e restituisce un numero intero non negativo.

Provalo online!

Come?

Per ogni sottosequenza dell'input (gli insiemi che possiamo rimuovere, più gli equivalenti ridondanti) ottiene un elenco di esistenza per identificare quali vengono rimossi, quindi trova effettivamente quante serie di zeri rimangono e produce il massimo. L'ultima parte funziona in modo leggermente strano da quando l'ho trovata più golfosa di alternative più ingenue - trova le piste come [element, count]coppie, nega di identificare gli zeri come tali, le somme trova il massimo quindi prende la testa (la somma degli elementi anziché dei conteggi ).

eþŒPŒr¬S€ṀḢ - Link: list of characters        e.g. "aabcde"
  ŒP        - power-set - gets all subsequences    ["","a","a","b",...,"bd",...,"aabcde"]
 þ          - outer-product with:
e           -   exists in?                         [[0,0,0,0,0,0],[1,1,0,0,0,0],[1,1,0,0,0,0],[0,0,1,0,0,0],..,[0,0,1,0,1,0]...,[1,1,1,1,1,1]]
    Œr      - run-length encode                    [[[0,6]],[[1,2],[0,4]],[[1,2],[0,4]],[[0,2],[1,1],[0,3]],...,[[0,2],[1,1],[0,1],[1,1],[0,1]],...,[[1,6]]]
      ¬     - NOT                                  [[[1,0]],[[0,0],[1,0]],[[0,0],[1,0]],[[1,0],[0,0],[1,0]],...,[[1,0],[0,0],[1,0],[0,0],[1,0]],...,[[0,0]]]
        €   - for €ach:
       S    -   sum                                [[1,0],[1,0],[1,0],[2,0],...,[3,0],...,[0,0]]
         Ṁ  - maximum                              [3,0]
          Ḣ - head                                 3

Rubino , 98 89 75 64 61 byte

f=->s{[s.split.size,*s.scan(/\w/).map{|c|f[s.tr c,' ']}].max}

Provalo online!

_{^{più piccolo e più lento di prima!}}

Fondamentalmente una porta della risposta Javascript di @ Neil

Ungolfed e annotato

def f(input_string)
    # splits by / +/ by default
    size0 = input_string.split.size
    # an array of all non-space characters in input_string
    characters = input_string.scan(/\w/)
    size1 = characters.map {|i|
        # all letters and digits and _ are "bigger" than /, space isn't
        if i > '/'
            # tr replaces every occurrence of i in input_string with space
            next_string = input_string.tr(i, ' ')
            f(next_string) # recursive call
        else
            0
        end
    }
    # max value between size0 and any element in size1
    return [size0, *size1].max
end

Provalo online!

Buccia , 12 11 byte

▲mȯ#€0gM€¹Ṗ

Provalo online! Funziona con la forza bruta ed è piuttosto lento. Aggiungi uall'estremità destra per renderlo più veloce, senza cambiare la semantica.

Spiegazione

▲mȯ#€0gM€¹Ṗ  Implicit input, say S = "abddccbdcaab"
          Ṗ  Powerset of S: P = ["","a","b","ab","d","ad"...,"abddccbdcaab"]
 m           Map this function over P:
              Argument is a subsequence, say R = "acc"
       M ¹    Map over S
        €     index of first occurrence in R: [1,0,0,0,2,2,0,0,2,1,1,0]
      g       Group equal elements: [[1],[0,0,0],[2,2],[0,0],[2],[1,1],[0]]
  ȯ#          Count the number of groups
    €0        that contain 0: 3
▲            Take maximum of the results: 4

Perl 5 , (precedenti), -p -I., 52 49 43 byte

Conteggio vecchio stile: +3per -p: 46byte (poiché deve essere in un programma, non può essere eseguito utilizzando -e)

barsplit.pl:

#!/usr/bin/perl -pI.
$G[split]+=s%\S%do$0for s/$&/ /rg%eg;$_=$#G

Esegui con la stringa su STDIN:

echo aaabcccdedaaabefda | ./barsplit.pl; echo

Provalo online!

L' -I.opzione è lì per farlo funzionare anche su perls recenti dove di default .non c'è più @INC. Nelle versioni precedenti di perl tale opzione non è necessaria. L'ho provato su una macchina più vecchia che aveva ancora perl 5.20, quindi il punteggio si basa su quello (altrimenti dovrei anche contare l' .argomento -I)

Versione veloce ( 49byte):

#!/usr/bin/perl -pI.
$G[split]+=s%.%$$_++||do$0for s/$&/ /rg%eg;$_=$#G

Wolfram Language (Mathematica) , 77 byte

Max@Table[Tr[1^StringSplit[#,(##|##)..&@@s]],{s,Subsets@Union@Characters@#}]&

Provalo online!