Sfida:

Dato un numero intero positivo, genera la sottosequenza a cifra singola più lunga che si verifica almeno due volte e ha i confini di un'altra cifra (o l'inizio / fine dell'intero).

Un esempio:

Input: 7888885466662716666
la sottosequenza più lunga di una singola cifra sarebbe 88888( 7[88888]5466662716666) con una lunghezza di 5. Tuttavia, questa sottosequenza si verifica solo una volta nell'intero.
Invece, il risultato per l'input 7888885466662716666dovrebbe essere 6666( 78888854[6666]271[6666]), poiché si verifica (almeno) due volte.

Regole della sfida:

• La lunghezza delle sottosequenze ha la priorità sul numero di volte in cui si verifica. (Vale a dire con input 8888858888866656665666, produciamo 88888( [88888]5[88888]66656665666; lunghezza 5, si verifica due volte), e non 666( 88888588888[666]5[666]5[666]; lunghezza 3, si verifica tre volte).
• Se la lunghezza di più sottosequenze è uguale, viene emesso quello con il maggior numero di occorrenze. Vale a dire con input 3331113331119111, abbiamo output 111( 333[111]333[111]9[111]; lunghezza 3, si verifica tre volte), e non 333( [333]111[333]1119111; anche lunghezza 3, ma si verifica due volte)
• Se il conteggio delle occorrenze e la lunghezza di più sottosequenze sono uguali, è possibile generare una di esse o tutte (in qualsiasi ordine). Cioè con ingressi 777333777333, le uscite possibili sono: 777; 333; [777, 333]; o [333, 777].
• La sottosequenza deve avere i confini di altre cifre (o l'inizio / la fine dell'intero). Vale a dire con input 122222233433il risultato è 33( 1222222[33]4[33]; lunghezza 2, ricorre due volte) e non 222( 1[222][222]33433, lunghezza 3, ricorre due volte con entrambi non validi).
  • Questo vale per tutti i numeri che vengono conteggiati nel contatore delle occorrenze. Vale a dire con 811774177781382il risultato il risultato è 8( [8]117741777[8]13[8]2; lunghezza 1, si verifica tre volte) e non 77( 811[77]41[77]781382/ 811[77]417[77]81382; lunghezza 2, si verifica due volte con una non valida) né 1( 8[1][1]774[1]7778[1]382; lunghezza 1, si verifica quattro volte con due non valide).
• Puoi presumere che l'input non conterrà alcuna cifra 0(corrisponderà [1-9]+). (Questo per evitare di dover gestire casi di test come quelli 10002000che dovrebbero essere prodotti 000, dove la maggior parte delle lingue produrrebbe 0di default.)
• Si può presumere che l'input conterrà sempre almeno un output valido.
• Gli I / O sono entrambi flessibili. Può essere un elenco / matrice / flusso di cifre / byte / caratteri o come stringa anziché un singolo intero.

Regole generali:

• Questo è code-golf , quindi vince la risposta più breve in byte.
  Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
• Per la tua risposta valgono regole standard , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti e tipo di ritorno, programmi completi. La tua chiamata.
• Sono vietate le scappatoie predefinite .
• Se possibile, aggiungi un link con un test per il tuo codice.
• Inoltre, si consiglia vivamente di aggiungere una spiegazione per la risposta.

Casi test:

Input:  7888885466662716666 / [7,8,8,8,8,8,5,4,6,6,6,6,2,7,1,6,6,6,6]
Output: 6666                / [6,6,6,6]

Input:  3331113331119111 / [3,3,3,1,1,1,3,3,3,1,1,1,9,1,1,1]
Output: 111              / [1,1,1]

Input:            777333777333                   / [7,7,7,3,3,3,7,7,7,3,3,3]
Possible outputs: 777; 333; [777,333]; [333;777] / [7,7,7]; [3,3,3]; [[7,7,7],[3,3,3]]; [[3,3,3],[7,7,7]]

Input:  122222233433 / [1,2,2,2,2,2,2,3,3,4,3,3]
Output: 33           / [3,3]

Input:  811774177781382 / [8,1,1,7,7,4,1,7,7,7,8,1,3,8,2] 
Output: 8               / [8]

Input:  555153333551 / [5,5,5,1,5,3,3,3,3,5,5,1] 
Output: 1            / [1]

Input:            12321              / [1,2,3,2,1]
Possible outputs: 1; 2; [1,2]; [2,1] / [1]; [2]; [[1],[2]]; [[2],[1]]

Input:  944949949494999494 / [9,4,4,9,4,9,9,4,9,4,9,4,9,9,9,4,9,4]
Output: 4                  / [4]

Input:  8888858888866656665666 / [8,8,8,8,8,5,8,8,8,8,8,6,6,6,5,6,6,6,5,6,6,6]
Output: 88888                  / [8,8,8,8,8]

Input:  1112221112221111               / [1,1,1,2,2,2,1,1,1,2,2,2,1,1,1,1]
Output: 111; 222; [111,222]; [222,111] / [1,1,1]; [2,2,2]; [[1,1,1],[2,2,2]]; [[2,2,2],[1,1,1]]

Input:  911133111339339339339339 / [9,1,1,1,3,3,1,1,1,3,3,9,3,3,9,3,3,9,3,3,9,3,3,9]
Output: 111                      / [1,1,1]

05AB1E , 14 byte

γТ1›ÏD€gZQÏ.M

Provalo online!

Spiegazione

γ                # group consecutive equal elements
 Т              # count the occurrence of each group among the list of groups
   1›Ï           # keep only groups with a count greater than 1
      D€gZQÏ     # keep only those with a length equal to the greatest length
            .M   # get the most common item

Gelatina , 12 byte

Œgœ-Q$LÐṀÆṃ'

Provalo online!

Versione precedente - 14 byte

ŒgŒQ¬TịƲLÐṀÆṃ'

Provalo online!

Come funziona?

Œgœ-Q$LÐṀÆṃ' – Full program. Receives a list of digits as input.
Œg           – Group equal adjacent values.
  œ-Q$       – Multiset difference with itself deduplicate.
      LÐṀ    – Keep those that are maximal by length.
         Æṃ' – Mode. Returns the most common element(s).
-------------------------------------------------------------------------
ŒgŒQ¬TịƲLÐṀÆṃ' – Full program. Receives a list of digits as input.
Œg             – Group equal adjacent values.
  ŒQ           – Distinct sieve. Replace the first occurrences of each value by 1.
                 and the rest by 0. [1,2,3,2,3,2,5]ŒQ -> [1,1,1,0,0,0,1]       
    ¬T         – Negate and find the truthy indices.
      ịƲ       – Then index in the initial list of groups.
               – This discards the groups that only occur once.
        LÐṀ    – Find all those which are maximal by length.
           Æṃ' – And take the mode.

JavaScript (ES6), 79 73 68 byte

Accetta l'input come stringa. Restituisce un numero intero.

s=>[...s,r=q=0].map(o=d=>q=s^d?o[!o[q]|r[q.length]?q:r=q]=s=d:q+d)|r

Provalo online!

Commentate

s =>                      // s = input string, also used as the current digit
  [ ...s,                 // split s into a list of digit characters
    r =                   // r is the final result
    q =                   // q is the current digit sequence
    0                     // append a final dummy entry to force the processing of the last
  ]                       // sequence
  .map(o =                // o is an object used to keep track of encountered sequences
       d =>               // for each digit d in the array defined above:
    q =                   //   update q:
      s ^ d ?             //     if d is not equal to the current digit:
        o[                //       this statement will ultimately update o[q]
          !o[q] |         //         if q has not been previously seen
          r[q.length] ?   //         or the best result is longer than q:
            q             //           leave r unchanged
          :               //         else:
            r = q         //           set r to q
        ] = s = d         //       reset q to d, set the current digit to d
                          //       and mark q as encountered by setting o[q]
      :                   //     else:
        q + d             //       append d to q
  ) | r                   // end of map(); return r, coerced to an integer

Retina , 56 byte

L`(.)\1*
O`
L$m`^(.+)(¶\1)+$
$#2;$1
N`
.+;

N$`
$.&
-1G`

Provalo online!Il link include casi di test. Spiegazione:

L`(.)\1*

Elencare tutte le sottosequenze delle cifre ripetute al massimo.

O`

Ordina l'elenco in ordine.

L$m`^(.+)(¶\1)+$
$#2;$1

Elencare tutte le sottosequenze multiple con il loro "conteggio".

N`

Ordina in ordine crescente di conteggio.

.+;

Elimina i conteggi.

N$`
$.&

Ordina in ordine crescente di lunghezza. (Se le lunghezze sono uguali, viene preservato l'ordine precedente dovuto al conteggio).

-1G`

Mantieni l'ultimo valore più lungo.

R , 102 byte

function(i)rep(names(sort(-(x=(x=table(rle(i)))[rowSums(x>1)>0,,drop=F])[m<-max(rownames(x)),])[1]),m)

Provalo online!

Dato che non c'era ancora una risposta R, ho deciso di provarlo, e beh ... non è stato facile. Non so davvero se sia un buon approccio, ma qui va.

Ingressi e uscite vettori di caratteri.

Perl 6 , 58 56 byte

*.comb(/(.)$0*/).Bag.max({.value>1,+.key.comb,.{*}}).key

Provalo online!

Python 2 , 123 120 byte

import re
def f(s):r=re.findall(r'(\d)(\1*)',s);c=r.count;print max((len(a+b)*(c((a,b))>1),c((a,b)),a+b)for a,b in r)[2]

Provalo online!

Powershell, 101 byte

($args|sls '(.)\1*'-a|%{$_.Matches}|group|?{$_.Count-1}|sort @{e={$_.Name.Length,$_.Count}})[-1].Name

Script di prova spiegato:

$f = {

(
    $args|          # for each argument (stings)
    sls '(.)\1*'-a| # searches all
    %{$_.Matches}|  # regex matches
    group|          # group it (Note: Count of each group > 0 by design)
    ?{$_.Count-1}|  # passthru groups with Count not equal 1
    sort @{         # sort all groups by 2 values
        e={$_.Name.Length,$_.Count}
    }
)[-1].Name          # returns name of last group (group with max values)

}

@(
    ,('7888885466662716666', '6666')
    ,('3331113331119111', '111')
    ,('777333777333', '777','333')
    ,('122222233433', '33')
    ,('811774177781382', '8')
    ,('555153333551','1')
    ,('12321', '1','2')
    ,('944949949494999494','4')
    ,('8888858888866656665666','88888')
    ,('1112221112221111','111','222')
) | % {
    $s,$e = $_
    $r = &$f $s
    "$($r-in$e): $r"
}

Produzione:

True: 6666
True: 111
True: 777
True: 33
True: 8
True: 1
True: 1
True: 4
True: 88888
True: 111

Python 2 , 114 113 byte

-1 byte grazie a TFeld .

p='';r=[];C=r.count
for c in input():r+=['']*(c!=p);r[-1]+=c;p=c
print max((len(w),C(w),w)for w in r if~-C(w))[2]

Provalo online!

Haskell, 72 byte

import Data.Lists
g!x|y<-countElem x g=(y>1,1<$x,y)
(argmax=<<(!)).group

Come funziona

(argmax=<<(!)).group       -- expands to: f i = argmax (group i !) (group i)
    group                  -- split the input list into subsequences of equal digits
                           -- e.g. "1112211" -> ["111","22","11"]

                           -- find the element of this list where the function !
                           -- returns the maximum value. First parameter to !
                           -- is the grouped input list, second parameter the
                           -- the element to look at 

g!x|
    y<-countElem x g       -- let y be the number of occurrences of x in g
  = (  ,   ,  )            -- return a triple of
     y>1                   -- a boolean y>1  (remember: True > False)  
        1<$x               -- length of x (to be exact: all elements in x
                           -- replaced by 1. This sorts the same way as the
                           -- length of x)
             y             -- y
                           -- a triples sorts lexicographical

R , 85 byte

function(x,R=rle(x),a=ave(R$v,R,FUN=length))rep(R$v[o<-order(a<2,-R$l,-a)[1]],R$l[o])

Provalo online!

• Input: un vettore di cifre intere separate ad esc(1,8,8...)

• Output: un vettore di cifre intere separate

Codice srotolato con spiegazione:

function(x){                # x is a vector of digits : e.g. c(1,1,8,8,1,1)

R = rle(x)                  # Get the sequences of consecutive repeating digits
                            # doing run length encoding on x, i.e. : R is a list
                            # with the digits (R$values) and the number of their
                            # consecutive occurrencies (R$lengths)
                            # N.B. you can use R$v for R$values and R$l for R$lenghts

a=ave(R$v,R,FUN=length)     # Group R$v by R$l AND R$v, count the occurrencies 
                            # for each group and "unroll" the value of each 
                            # group to the original R$v length.
                            # Here basically we count the occurrencies of the same 
                            # sequence.

o<-order(a<2,-R$l,-a)[1]    # Get the indexes used to order by a < 2 then by -R$l and
                            # finally by -a; store the first index in "o".
                            # Here basically we use order to select the first sequence 
                            # repeated at least twice, in case of ties the sequence 
                            # with the greatest length and in case of ties the most 
                            # repeated sequence.

rep(R$v[o],R$v[o])          # Using the index "o", we reconstruct the sequence repeating
                            # R$l[o] times R$v[o]
}

Versione alternativa che accetta il vettore di numeri interi o di caratteri:

R , 88 byte

function(x,R=rle(x),a=ave(R$v,R,FUN=length))rep(R$v[o<-tail(order(a>1,R$l,a),1)],R$l[o])

Provalo online!

• Input: un vettore di caratteri o cifre separati, ad es. c("1","8","8"...)Oc(1,8,8...)

• Output: un vettore di caratteri separati se l'input era un vettore di caratteri, un vettore di cifre se l'input era un vettore di cifre

Rosso , 256 250 byte

func[s][p: func[b][sort parse b[collect[any keep[copy a skip thru any a]]]]first
last sort/compare collect[foreach d p p s[if 1 < k: length? to-block d[keep/only
reduce[form unique d k]]]]func[x y][(reduce[length? x/1 x/2])< reduce[length? y/1 y/2]]]

Provalo online!

Davvero, soluzione davvero lunga questa volta ... (sospiro)

Prende l'input come stringa.

Spiegazione:

f: func [ s ] [
    p: func [ b ] [                        ; groups and sorts the adjacent repeating items
        sort parse b [ 
            collect [                      
                any keep[
                    copy a skip thru any a ; gather any item, optionally followed by itself  
                ]
            ]
        ]
    ]
    t: copy []
    foreach d p p s [                     ; p p s transforms the input string into a block of sorted blocks of repeating digits
        if 1 < k: length? to-block d [    ; filters only the blocks that occur more than once
            insert/only t reduce [ form unique d k ] ; stores the digits and the number of occurences
                                          ; "8888858888866656665666" -> [["5" 3] ["666" 3] ["88888" 2]]
        ]
    ]
    first last sort/compare t func [ x y ] ; takes the first element (the digits) of the last block of the sorted block of items
        [ (reduce [ length? x/1 x/2 ]) < reduce [ length? y/1 y/2 ] ] ; direct comparison of the blocks
]

Java (JDK 10) , 213 byte

s->{int l=99,X[][]=new int[10][l],d,D=0,m=0,M=0;for(var x:s.split("(?<=(.))(?!\\1)"))X[x.charAt(0)-48][x.length()]++;for(;M<1&&l-->1;)for(d=0;d++<9;)if((m=X[d][l])>1&m>M){M=m;D=d;}for(;l-->0;)System.out.print(D);}

Provalo online!

Spiegazione (obsoleta)

s->{                                    // Lambda for Consumer<String>
 int l=99,                              //  Length of token, max is 99.
     X[][]=new int[10][l],              //  Array containing the occurrences per token
     d,                                 //  digit value
     D=0,                               //  digit holder for best sequence candidate
     m=0,                               //  holder of the current candidate
     M=0;                               //  best candidate for the current length of token.
 for(var x:s.split("(?<=(.))(?!\\1)"))  //  Tokenize the string into digit-repeating sequences
  X[x.charAt(0)-48][x.length()]++;      //   Add one occurrence for the token
 for(;M<1&&l-->1;)                      //  While no value has been found and for each length, descending. Do not decrease length if a value has been found.
  for(d=0;d++<9;)                       //   for each digit
   if((m=X[d][l])>1&m>M){               //    if the current occurrence count is at least 2 and that count is the current greatest for the length
    M=m;D=d;                            //     mark it as the current best
   }                                    //
 for(;l-->0;)System.out.print(D);       //  Output the best-fitting subsequence.
}                                       // 

Titoli di coda

• -9 byte e individuazione dei bug grazie a Kevin Cruijssen

Rubino , 68 67 byte

->a{(b=a.chunk &:+@).max_by{|x|[(c=b.count x)<2?0:x[1].size,c]}[1]}

Provalo online!

Input e output array di caratteri.

L'approccio è piuttosto semplice: identifichiamo le serie di cifre consecutive ( chunkusando l'unario +come funzione di identità) e prendiamo il massimo - prima per la dimensione della serie (reimpostare a zero se il suo conteggio delle occorrenze è <2), quindi per il conteggio stesso .

PCRE, 152 byte

(\d)(?<!(?=\1)..)(?=(\1*)(?!\1).*(?!\1).\1\2(?!\1))(?!(?:(?=\2((\3?+)(\d)(\5*)))){1,592}?(?=\2\3.*(?!\5).\5\6(?!\5))(?:\1(?=\1*\4\5(\7?+\5)))*+(?!\1))\2

Guardalo in azione su: https://regex101.com/r/0U0dEp/1 (guarda la prima partita in ogni caso di test)

Questo è solo per divertimento, poiché regex non è un vero linguaggio di programmazione in sé e per sé e la soluzione è limitata: P

Poiché un gruppo di larghezza zero come (?:)+una volta corrisponde solo una volta e non si ripete indefinitamente, e poiché PCRE effettua internamente copie di gruppi quantificati con limiti, ho dovuto usare un numero magico ("{1.592}"), che significa che possiamo solo cercare fino a 592 insiemi di cifre contigue per trovare un insieme in competizione che potrebbe essere più lungo di quello attualmente sotto controllo. Maggiori informazioni su questo concetto qui .

Perl 5 , 88 byte

my($m,%s);++$i%2*$s{$_}++&&($n=$s{$_}/9+length)>$m&&($a=$_,$m=$n)for pop=~/((.)\2*)/g;$a

Provalo online!

Leggermente non golfato, con prove:

sub f {
  my($m,%s);
  my($i,$n,$a);           #not needed in golfed version
  ++$i % 2  *  $s{$_}++
  && ($n=$s{$_}/9+length) > $m
  && ($a=$_, $m=$n)
    for pop=~/((.)\2*)/g; #i.e. 7888885466662716666 => 7 88888 5 4 6666 2 7 1 6666
  $a
}
for(map[/\d+/g],split/\n/,join"",<DATA>){ #tests
  my($i,@e)=@$_;
  printf "%-6s   input %-24s   expected %-10s   got %s\n",
    (grep f($i) eq $_, @e) ? "Ok" : "Not ok", $i, join('|',@e), f($i);
}
__DATA__
Input:  7888885466662716666     Output: 6666
Input:  3331113331119111        Output: 111
Input:  777333777333            Output: 777|333
Input:  122222233433            Output: 33
Input:  811774177781382         Output: 8
Input:  555153333551            Output: 1
Input:  12321                   Output: 1|2
Input:  944949949494999494      Output: 4
Input:  8888858888866656665666  Output: 88888
Input:  1112221112221111        Output: 111|222

Wolfram Language (Mathematica) , 67 byte

#&@@@MaximalBy[Select[Tally@Split@#,Last@#>1&],{Length@#,#2}&@@#&]&

Funzione pura. Prende un elenco di cifre come input e restituisce un elenco di sottosequenze (in nessun ordine particolare) come output. Non sono sicuro se la clausola "deve apparire almeno due volte" possa essere gestita in modo più pulito. Provalo online!

Japt -h, 12 byte

Input e output sono stringhe.

ò¦ ñÊf@ÓZè¶X

Provalo