Meydan okuma:

Pozitif bir tamsayı verildiğinde, en az iki kez meydana gelen en uzun tek basamaklı alt diziyi girin, AND başka bir basamağın (veya tamsayı başlangıç ​​/ bitişinin) sınırlarına sahiptir.

Bir örnek:

Girdi: 7888885466662716666
Tek bir basamağın en uzun sırası 5 uzunluğunda 88888( 7[88888]5466662716666) olur. Ancak, bu sıra tamsayıda yalnızca bir kez olur.
Bunun yerine, girişin sonucu ( ) 7888885466662716666olmalıdır , çünkü (en az iki kez).666678888854[6666]271[6666]

Zorluk kuralları:

• Takiplerin uzunluğu, gerçekleşme süresine göre önceliklidir. (Yani girdi ile 8888858888866656665666, çıkış yaparız ; 88888( [88888]5[88888]66656665666uzunluk 5, iki kez gerçekleşir) ve değil 666( 88888588888[666]5[666]5[666]; uzunluk 3, üç kez gerçekleşir).
• Birden fazla alt dizinin uzunluğu eşitse, en büyük oluşum sayısıyla sonuçlanır. Girdi ile 3331113331119111, çıkış 111( 333[111]333[111]9[111]; uzunluk 3, üç kez meydana gelir) ve değil 333( [333]111[333]1119111; uzunluk 3 de, ancak iki kez meydana gelir)
• Birden fazla alt dizinin oluşum sayısı ve uzunluğu eşitse, bunlardan birini veya tümünü (herhangi bir sırayla) çıktı alabilirsiniz. Yani giriş ile 777333777333olası çıkışlar 777:; 333;[777, 333]; veya [333, 777].
• Alt dizinin diğer basamakların (veya tamsayının başlangıcı / bitişi) sınırları olmalıdır. Yani girdi 122222233433ile sonuç 33( 1222222[33]4[33]; uzunluk 2, iki kez olur) ve değil 222(1[222][222]33433 uzunluk 3, iki geçersiz ile iki kez meydana gelir).
  • Bu, olay sayacında sayılan tüm sayılar için geçerlidir. Girdi 811774177781382ile sonuç 8( [8]117741777[8]13[8]2; uzunluk 1, üç kez oluşur) ve değil 77( 811[77]41[77]781382/ 811[77]417[77]81382; uzunluk 2, bir geçersiz ile iki kez oluşur ) veya 1( 8[1][1]774[1]7778[1]382; uzunluk 1, iki geçersiz ile dört kez oluşur).
• Girişin herhangi bir rakam içermediğini varsayabilirsiniz 0(eşleşir [1-9]+). (Bu 10002000çıktı gibi test davaları ile uğraşmak zorunda kalmamaktır000 , nerede dillerin çoğu çıkış alacaktı 0varsayılan olarak.)
• Girdinin her zaman en az bir geçerli çıktı içereceğini varsayabilirsiniz.
• G / Ç'nin her ikisi de esnektir. Bir liste / dizi / basamak / bayt / karakter akışı veya tek bir tamsayı yerine dize olabilir.

Genel kurallar:

• Bu kod golf , bayt en kısa cevap kazanır.
  Kod golf dillerinin, kod yazmayan dillerle yanıt göndermenizi engellemesine izin vermeyin. 'Herhangi bir' programlama dili için mümkün olduğunca kısa bir cevap bulmaya çalışın.
• Cevabınız için standart kurallar geçerlidir , bu nedenle STDIN / STDOUT, fonksiyonlar / yöntem uygun parametreler ve dönüş tipi, tam programlar ile kullanılabilir. Çağrınız.
• Varsayılan Loopholes yasaktır.
• Mümkünse, lütfen kodunuz için test içeren bir bağlantı ekleyin.
• Ayrıca, cevabınız için bir açıklama eklemeniz önemle tavsiye edilir.

Test senaryoları:

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 bayt

γТ1›ÏD€gZQÏ.M

Çevrimiçi deneyin!

açıklama

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

Jöle , 12 bayt

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

Çevrimiçi deneyin!

Önceki sürüm - 14 bayt

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

Çevrimiçi deneyin!

Nasıl çalışır?

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

Girişi dize olarak alır. Bir tamsayı döndürür.

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

Çevrimiçi deneyin!

Yorumlananlar

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 bayt

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

N$`
$.&
-1G`

Çevrimiçi deneyin! Bağlantı, test senaryolarını içerir. Açıklama:

L`(.)\1*

Tüm maksimum tekrarlanan rakam dizilerini listeleyin.

O`

Listeyi sıraya göre sıralayın.

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

Birden çok alt diziyi "sayıları" ile listeleyin.

N`

Artan sayım sırasına göre sıralayın.

.+;

Sayıları silin.

N$`
$.&

Artan uzunluk sırasına göre sıralayın. (Uzunlukların eşit olduğu durumlarda, sayımdan önceki sipariş korunur.)

-1G`

Son yani en uzun değeri koruyun.

R , 102 bayt

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

Çevrimiçi deneyin!

Henüz bir R cevabı olmadığından, denemeye karar verdim ve iyi ... kolay değildi. Bunun iyi bir yaklaşım olup olmadığını gerçekten bilmiyorum, ama işte gidiyor.

Karakter vektörlerini girer ve çıkarır.

Perl 6 , 58 56 bayt

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

Çevrimiçi deneyin!

Python 2 , 123120 bayt

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]

Çevrimiçi deneyin!

Powershell, 101 bayt

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

Açıklanmış test komut dosyası:

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

Çıktı:

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

Python 2 , 114113 bayt

TFeld sayesinde -1 bayt .

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]

Çevrimiçi deneyin!

Haskell, 72 bayt

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

Nasıl çalışır

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

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

Çevrimiçi deneyin!

• Girdi: ayrılmış tamsayı hane vektörü ör.c(1,8,8...)

• Çıktı: ayrılmış tamsayı hane vektörü

Açıklamalı kaydedilmemiş kod:

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

Tamsayı veya karakter basamaklı vektörü kabul eden alternatif sürüm:

R , 88 bayt

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

Çevrimiçi deneyin!

• Girdi: ayrılmış karakterler için bir vektör ya da basamak örn c("1","8","8"...)veyac(1,8,8...)

• Çıktı: giriş bir karakter vektörüyse ayrılmış karakterlerden oluşan bir vektör, giriş bir basamak vektörü ise basamaktan oluşan bir vektör

Kırmızı , 256250 bayt

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

Çevrimiçi deneyin!

Gerçekten, bu sefer gerçekten uzun bir çözüm ... (iç çek)

Girdiyi dize olarak alır.

Açıklama:

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 bayt

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

Çevrimiçi deneyin!

Açıklama (eski)

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

Kredi

• Kevin Cruijssen sayesinde -9 bayt ve hata tespit

Yakut , 68 67 bayt

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

Çevrimiçi deneyin!

Girdilerin girdi ve çıktı dizileri.

Yaklaşım oldukça basittir: ardışık basamakların çalışmalarını tanımlarız ( kimlik fonksiyonu olarak chunktekli kullanarak +) ve maksimum - ilk önce çalışma boyutuna göre (oluşum sayısı <2 ise sıfıra sıfırlar), sonra sayının kendisi .

PCRE, 152 bayt

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

Aşağıdaki işlemlerde görün: https://regex101.com/r/0U0dEp/1Çalışırken şu adreste (sadece her test senaryosundaki ilk maça bakın)

Bu sadece eğlence içindir, çünkü regex kendi başına gerçek bir programlama dili değildir ve çözüm sınırlıdır: P

Çünkü sıfır genişlikli bir grup gibi (?:)+ yalnızca bir kez eşleştiğinden ve süresiz olarak tekrar etmediğinden ve PCRE dahili olarak sınırlarla ölçülen grupların kopyalarını oluşturduğundan, orada bir sihirli sayı ("{1,592}") kullanmak zorunda kaldım. şu anda incelenmekte olandan daha uzun olabilecek bir rakip küme bulmak için yalnızca 592 bitişik basamak kümesine bakabileceğimiz anlamına gelir. Burada bu kavram hakkında daha fazla bilgi .

Perl 5 , 88 bayt

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

Çevrimiçi deneyin!

Testlerle hafif soluksuz:

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 Dili (Mathematica) , 67 bayt

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

Saf fonksiyon. Rakamların listesini girdi olarak alır ve çıktı olarak (belirli bir sırada değil) bir alt liste listesi döndürür. "En az iki kez görünmelidir" deyiminin daha temiz işlenip işlenemeyeceğinden emin değilim. Çevrimiçi deneyin!

Japt -h, 12 bayt

Giriş ve çıkış dizgidir.

ò¦ ñÊf@ÓZè¶X

Dene