Herausforderung:

Bei einer positiven Ganzzahl geben Sie die längste einstellige Teilfolge aus, die mindestens zweimal vorkommt, UND hat die Grenzen einer anderen Ziffer (oder den Anfang / das Ende der Ganzzahl).

Ein Beispiel:

Eingabe: 7888885466662716666
Die längste Teilfolge einer einzelnen Ziffer wäre 88888( 7[88888]5466662716666) mit einer Länge von 5. Diese Teilfolge kommt jedoch nur einmal in der ganzen Zahl vor.
Stattdessen ist das Ergebnis für die Eingabe 7888885466662716666sollte 6666( 78888854[6666]271[6666]), da es (mindestens) zweimal vorkommt.

Herausforderungsregeln:

• Die Länge der Teilsequenzen hat Vorrang vor der Häufigkeit ihres Auftretens. (Dh mit Eingabe geben 8888858888866656665666wir aus 88888( [88888]5[88888]66656665666; Länge 5 tritt zweimal auf) und nicht 666( 88888588888[666]5[666]5[666]; Länge 3 tritt dreimal auf).
• Wenn die Länge mehrerer Teilsequenzen gleich ist, geben wir die mit der größten Häufigkeit aus. Dh mit Input geben 3331113331119111wir aus 111( 333[111]333[111]9[111]; Länge 3, kommt dreimal vor) und nicht 333( [333]111[333]1119111; Länge 3 auch, kommt aber zweimal vor)
• Wenn die Anzahl der Vorkommen und die Länge mehrerer Teilsequenzen gleich sind, können Sie eine oder alle (in beliebiger Reihenfolge) ausgeben. Dh mit Eingang 777333777333, sind die möglichen Ausgänge: 777; 333; [777, 333]; oder [333, 777].
• Die Subsequenz muss Grenzen anderer Ziffern haben (oder den Anfang / das Ende der ganzen Zahl). Dh bei Eingabe ist 122222233433das Ergebnis 33( 1222222[33]4[33]; Länge 2 kommt zweimal vor) und nicht 222( 1[222][222]33433Länge 3 kommt zweimal vor, beide ungültig).
  • Dies gilt für alle Nummern, die auf den Vorkommenszähler angerechnet werden. Dh bei Eingabe ist 811774177781382das Ergebnis 8( [8]117741777[8]13[8]2; Länge 1, kommt dreimal vor) und nicht 77( 811[77]41[77]781382/ 811[77]417[77]81382; Länge 2, kommt zweimal mit einer ungültigen vor) oder 1( 8[1][1]774[1]7778[1]382; Länge 1, kommt viermal mit zwei ungültigen vor).
• Sie können davon ausgehen, dass die Eingabe keine Ziffern enthält 0(sie stimmt überein [1-9]+). (Damit soll vermieden werden, dass Testfälle wie 10002000diese ausgegeben werden müssen 000, bei denen die meisten Sprachen 0standardmäßig ausgegeben werden.)
• Sie können davon ausgehen, dass die Eingabe immer mindestens eine gültige Ausgabe enthält.
• I / O sind beide flexibel. Kann eine Liste / ein Array / ein Datenstrom aus Ziffern / Bytes / Zeichen oder eine Zeichenfolge anstelle einer einzelnen Ganzzahl sein.

Allgemeine Regeln:

• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.
  Lassen Sie sich von Code-Golf-Sprachen nicht davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, für jede Programmiersprache eine möglichst kurze Antwort zu finden.
• Für Ihre Antwort gelten Standardregeln. Daher dürfen Sie STDIN / STDOUT, Funktionen / Methoden mit den richtigen Parametern und vollständige Programme vom Rückgabetyp verwenden. Ihr Anruf.
• Standardlücken sind verboten.
• Fügen Sie nach Möglichkeit einen Link mit einem Test für Ihren Code hinzu.
• Außerdem wird dringend empfohlen, eine Erklärung für Ihre Antwort hinzuzufügen.

Testfälle:

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 Bytes

γТ1›ÏD€gZQÏ.M

Probieren Sie es online!

Erläuterung

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

Gelee , 12 Bytes

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

Probieren Sie es online!

Vorherige Version - 14 Bytes

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

Probieren Sie es online!

Wie es funktioniert?

Œ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

Übernimmt die Eingabe als Zeichenfolge. Gibt eine ganze Zahl zurück.

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

Probieren Sie es online!

Kommentiert

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

Netzhaut , 56 Bytes

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

N$`
$.&
-1G`

Probieren Sie es online! Link enthält Testfälle. Erläuterung:

L`(.)\1*

Listen Sie alle maximal wiederholten Ziffernfolgen auf.

O`

Sortieren Sie die Liste in der Reihenfolge.

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

Listen Sie alle multiplen Teilfolgen mit ihrer "Anzahl" auf.

N`

In aufsteigender Reihenfolge der Anzahl sortieren.

.+;

Löschen Sie die Zählungen.

N$`
$.&

In aufsteigender Reihenfolge der Länge sortieren. (Wenn die Längen gleich sind, bleibt die vorherige Reihenfolge aufgrund der Anzahl erhalten.)

-1G`

Behalten Sie den letzten bzw. längsten Wert bei.

R , 102 Bytes

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

Probieren Sie es online!

Da es noch keine R-Antwort gab, habe ich beschlossen, es zu versuchen, und nun ... es war nicht einfach. Ich weiß nicht wirklich, ob es ein guter Ansatz ist, aber jetzt geht es los.

Ein- und Ausgabevektoren von Zeichen.

Perl 6 , 58 56 Bytes

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

Probieren Sie es online!

Python 2 , 123 120 Bytes

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]

Probieren Sie es online!

Powershell, 101 Byte

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

Erklärtes Testskript:

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

Ausgabe:

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

Python 2 , 114 113 Bytes

-1 Byte dank 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]

Probieren Sie es online!

Haskell, 72 Bytes

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

Wie es funktioniert

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

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

Probieren Sie es online!

• Eingabe: Ein Vektor mit getrennten ganzzahligen Ziffern, zc(1,8,8...)

• Ausgabe: Ein Vektor mit getrennten ganzzahligen Ziffern

Abgerollter Code mit Erklärung:

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

Alternative Version, die einen Vektor mit ganzen Zahlen oder Zeichen akzeptiert:

R 88 Bytes

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

Probieren Sie es online!

• Eingabe: Ein Vektor aus getrennten Zeichen oder Ziffern, z. B. c("1","8","8"...)oderc(1,8,8...)

• Ausgabe: ein Vektor von getrennten Zeichen, wenn die Eingabe ein Vektor von Zeichen war, ein Vektor von Ziffern, wenn die Eingabe ein Vektor von Ziffern war

Rot , 256 250 Bytes

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

Probieren Sie es online!

Wirklich, wirklich lange Lösung dieses Mal ... (Seufzer)

Nimmt die Eingabe als String.

Erläuterung:

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

Probieren Sie es online!

Erklärung (veraltet)

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

Credits

• -9 Bytes und Bugspotting dank Kevin Cruijssen

Ruby , 68 67 Bytes

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

Probieren Sie es online!

Ein- und Ausgabe von Zeichen-Arrays.

Der Ansatz ist ziemlich einfach: Wir identifizieren die Läufe von aufeinanderfolgenden Ziffern (unter chunkVerwendung von unary +als Identitätsfunktion) und nehmen das Maximum - zuerst durch die Größe des Laufs (zurückgesetzt auf Null, wenn die Anzahl seiner Vorkommen <2 ist), dann durch die Anzahl selbst .

PCRE, 152 Bytes

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

Sehen Sie es in Aktion auf: https://regex101.com/r/0U0dEp/1 (schauen Sie sich nur das erste Match in jedem Testfall an)

Dies ist nur zum Spaß, da Regex keine echte Programmiersprache für sich ist und die Lösung begrenzt ist: P

Da eine Gruppe mit der Breite Null, wie z. B. (?:)+nur einmal übereinstimmt und sich nicht unbegrenzt wiederholt, und PCRE intern Kopien von Gruppen erstellt, die mit Grenzwerten quantifiziert wurden, musste ich eine magische Zahl verwenden ("{1,592}") Das heißt, wir können nur bis zu 592 aufeinanderfolgende Ziffernfolgen durchsuchen, um eine Konkurrenzmenge zu finden, die möglicherweise länger ist als die, die derzeit geprüft wird. Mehr Infos zu diesem Konzept hier .

Perl 5 , 88 Bytes

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

Probieren Sie es online!

Leicht ungolfed, mit 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 Byte

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

Funktion pur. Nimmt eine Liste von Ziffern als Eingabe und gibt eine Liste von Untersequenzen (in keiner bestimmten Reihenfolge) als Ausgabe zurück. Nicht sicher, ob die Klausel "muss mindestens zweimal vorkommen" sauberer gehandhabt werden kann. Probieren Sie es online!

Japt -h, 12 Bytes

Eingabe und Ausgabe sind Zeichenfolgen.

ò¦ ñÊf@ÓZè¶X

Versuch es