Défi:

Étant donné un entier positif, sortez la sous-séquence à un chiffre la plus longue qui se produit au moins deux fois, ET a les limites d'un autre chiffre (ou le début / la fin de l'entier).

Un exemple:

Entrée: 7888885466662716666
La sous-séquence la plus longue d'un seul chiffre serait 88888( 7[88888]5466662716666) avec une longueur de 5. Cependant, cette sous-séquence ne se produit qu'une seule fois dans l'entier.
Au lieu de cela, le résultat de l'entrée 7888885466662716666doit être 6666(78888854[6666]271[6666] ), car il se produit (au moins) deux fois.

Règles du défi:

• La longueur des sous-séquences a priorité sur la quantité de fois où elle se produit. (C'est-à-dire avec entrée 8888858888866656665666, nous sortons 88888( [88888]5[88888]66656665666; longueur 5, se produit deux fois), et non666 ( 88888588888[666]5[666]5[666]; longueur 3, se produit trois fois).
• Si la longueur de plusieurs sous-séquences est égale, nous sortons celle avec le plus grand nombre d'occurrences. C'est-à-dire avec une entrée 3331113331119111, nous sortons 111( 333[111]333[111]9[111]; longueur 3, se produit trois fois), et non333 ( [333]111[333]1119111; longueur 3 également, mais se produit deux fois)
• Si le nombre d'occurrences et la longueur de plusieurs sous-séquences sont égaux, vous pouvez sortir l'un d'eux ou tous (dans n'importe quel ordre). -À- dire avec entrée 777333777333, les sorties possibles sont: 777; 333; [777, 333]; ou [333, 777].
• La sous-séquence doit avoir des limites d'autres chiffres (ou le début / la fin de l'entier). C'est-à-dire qu'avec l'entrée, 122222233433le résultat est 33( 1222222[33]4[33]; la longueur 2, se produit deux fois) et non 222( 1[222][222]33433, la longueur 3, se produit deux fois avec les deux invalides).
  • Cela s'applique à tous les nombres qui sont comptés dans le compteur d'occurrences. C'est-à-dire avec une entrée 811774177781382le résultat est 8( [8]117741777[8]13[8]2; la longueur 1, se produit trois fois) et non 77( 811[77]41[77]781382/ 811[77]417[77]81382; la longueur 2, se produit deux fois avec un invalide) ni 1( 8[1][1]774[1]7778[1]382; la longueur 1, se produit quatre fois avec deux invalides).
• Vous pouvez supposer que l'entrée ne contiendra aucun chiffre 0(elle correspondra [1-9]+). (C'est pour éviter d'avoir à traiter des cas de test comme 10002000celui-ci devrait sortir 000, où la plupart des langues sortiraient 0par défaut.)
• Vous pouvez supposer que l'entrée contiendra toujours au moins une sortie valide.
• Les E / S sont toutes deux flexibles. Peut être une liste / tableau / flux de chiffres / octets / caractères ou sous forme de chaîne au lieu d'un seul entier.

Règles générales:

• C'est le code-golf , donc la réponse la plus courte en octets l'emporte.
  Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues autres que le golf de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation.
• Des règles standard s'appliquent à votre réponse, vous êtes donc autorisé à utiliser STDIN / STDOUT, fonctions / méthode avec les paramètres appropriés et des programmes complets de type retour. Ton appel.
• Failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien avec un test pour votre code.
• De plus, l'ajout d'une explication à votre réponse est fortement recommandé.

Cas de 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 octets

γТ1›ÏD€gZQÏ.M

Essayez-le en ligne!

Explication

γ                # 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

Gelée , 12 octets

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

Essayez-le en ligne!

Version précédente - 14 octets

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

Essayez-le en ligne!

Comment ça fonctionne?

Œ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 octets

Prend l'entrée sous forme de chaîne. Renvoie un entier.

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

Essayez-le en ligne!

Commenté

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

Rétine , 56 octets

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

N$`
$.&
-1G`

Essayez-le en ligne! Le lien inclut des cas de test. Explication:

L`(.)\1*

Liste toutes les sous-séquences de chiffres répétées au maximum.

O`

Triez la liste dans l'ordre.

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

Répertoriez toutes les sous-séquences multiples avec leur "nombre".

N`

Trier par ordre croissant de comptage.

.+;

Supprimez les comptes.

N$`
$.&

Trier par ordre croissant de longueur. (Lorsque les longueurs sont égales, l'ordre précédent dû au comptage est conservé.)

-1G`

Gardez la dernière valeur, c'est-à-dire la plus longue.

R , 102 octets

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

Essayez-le en ligne!

Puisqu'il n'y avait pas encore de réponse R, j'ai décidé de faire un essai, et bien ... ce n'était pas facile. Je ne sais pas vraiment si c'est une bonne approche, mais c'est parti.

Entrées et sorties de vecteurs de caractères.

Perl 6 , 58 56 octets

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

Essayez-le en ligne!

Python 2 , 123 120 octets

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]

Essayez-le en ligne!

Powershell, 101 octets

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

Script de test expliqué:

$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"
}

Production:

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

Python 2 , 114 113 octets

-1 octet grâce à 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]

Essayez-le en ligne!

Haskell, 72 octets

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

Comment ça fonctionne

(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 octets

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

Essayez-le en ligne!

• Entrée: un vecteur de chiffres entiers séparés, par exemplec(1,8,8...)

• Sortie: un vecteur de chiffres entiers séparés

Code déroulé avec explication:

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

Version alternative acceptant le vecteur de chiffres entiers ou caractères:

R , 88 octets

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

Essayez-le en ligne!

• Entrée: un vecteur de caractères ou de chiffres séparés, par exemple c("1","8","8"...)ouc(1,8,8...)

• Sortie: un vecteur de caractères séparés si l'entrée était un vecteur de caractères, un vecteur de chiffres si l'entrée était un vecteur de chiffres

Rouge , 256 250 octets

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

Essayez-le en ligne!

Vraiment, solution vraiment longue cette fois ... (soupir)

Prend l'entrée sous forme de chaîne.

Explication:

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 octets

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

Essayez-le en ligne!

Explication (obsolète)

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.
}                                       // 

Crédits

• -9 octets et repérage de bugs grâce à Kevin Cruijssen

Rubis , 68 67 octets

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

Essayez-le en ligne!

Tableaux d'entrées et de sorties de caractères.

L'approche est assez simple: nous identifions les séries de chiffres consécutifs (en chunkutilisant unaire +comme fonction d'identité) et prenons le maximum - d'abord par la taille de la série (remis à zéro si son nombre d'occurrences est <2), puis par le nombre lui-même .

PCRE, 152 octets

(\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

Voyez-le en action sur: https://regex101.com/r/0U0dEp/1 (il suffit de regarder le premier match dans chaque cas de test)

C'est juste pour le plaisir, car regex n'est pas un véritable langage de programmation en soi, et la solution est limitée: P

Parce qu'un groupe de largeur nulle tel que (?:)+ne correspond qu'une seule fois et ne se répète pas indéfiniment, et parce que PCRE fait en interne des copies de groupes quantifiés avec des limites, j'ai dû y utiliser un nombre magique ("{1,592}"), qui signifie que nous ne pouvons rechercher que 592 ensembles de chiffres contigus à venir pour trouver un ensemble concurrent qui pourrait être plus long que celui actuellement sous inspection. Plus d'informations sur ce concept ici .

Perl 5 , 88 octets

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

Essayez-le en ligne!

Légèrement non golfé, avec des tests:

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 octets

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

Fonction pure. Prend une liste de chiffres en entrée et renvoie une liste de sous-séquences (sans ordre particulier) en sortie. Je ne sais pas si la clause "doit apparaître au moins deux fois" peut être gérée plus proprement. Essayez-le en ligne!

Japt -h , 12 octets

L'entrée et la sortie sont des chaînes.

ò¦ ñÊf@ÓZè¶X

Essayez-le