Виклик:

Враховуючи додатне ціле число, виведіть найдовший одноцифровий підряд, який відбувається принаймні вдвічі, і має межі іншої цифри (або початок / кінець цілого числа).

Приклад:

Введення: 7888885466662716666
Найдовшим підрядом однієї цифри було б 88888( 7[88888]5466662716666) довжиною 5. Однак це підпорядкування відбувається лише один раз у цілому.
Натомість результат для введення 7888885466662716666повинен бути 6666( 78888854[6666]271[6666]), оскільки він виникає (принаймні) двічі.

Правила виклику:

• Довжина підрядників має пріоритет над тим, скільки разів вона виникає. (Тобто з введенням 8888858888866656665666, ми виводимо 88888( [88888]5[88888]66656665666; довжина 5, трапляється двічі), а не 666( 88888588888[666]5[666]5[666]; довжина 3, трапляється тричі).
• Якщо довжина декількох підрядів однакова, ми виводимо одне з найбільшою кількістю випадків. Тобто з введенням 3331113331119111ми виводимо 111( 333[111]333[111]9[111]; довжина 3, трапляється тричі), а не 333( [333]111[333]1119111; також довжина 3, але виникає двічі)
• Якщо кількість подій і довжина декількох підрядів рівні, ви можете вивести будь-який з них або всі (у будь-якому порядку). Тобто з введенням 777333777333, можливими виходами є 777:; 333; [777, 333]; або [333, 777].
• Підпорядкованість повинна мати межі інших цифр (або початок / кінець цілого числа). Тобто з введенням 122222233433результат є 33( 1222222[33]4[33]; довжина 2, трапляється двічі), а не 222( 1[222][222]33433, довжина 3, відбувається два рази з обома недійсними).
  • Це стосується всіх чисел, які зараховуються до лічильника подій. Тобто з введенням 811774177781382результат є 8( [8]117741777[8]13[8]2; довжина 1, трапляється тричі), а не 77( 811[77]41[77]781382/ 811[77]417[77]81382; довжина 2, зустрічається двічі з одним недійсним) ні 1( 8[1][1]774[1]7778[1]382; довжина 1, відбувається чотири рази з двома недійсними).
• Ви можете припустити, що вхід не буде містити жодних цифр 0(він збігатиметься [1-9]+). (Це дозволяє уникнути того, щоб мати справу з тестовими випадками, 10002000які повинні виводитися 000, де більшість мов виводиться 0за замовчуванням.)
• Можна припустити, що вхід завжди буде містити принаймні один дійсний вихід.
• Введення / виведення є гнучкими. Може бути списком / масивом / потоком цифр / байтів / символів або як рядок замість одного цілого числа.

Загальні правила:

• Це код-гольф , тому найкоротша відповідь у байтах виграє.
  Не дозволяйте мовам коду-гольфу відштовхувати вас від публікації відповідей з мов, що не кодують гольф. Спробуйте придумати якомога коротшу відповідь на "будь-яку" мову програмування.
• Стандартні правила застосовуються до вашої відповіді, тому вам дозволяється використовувати STDIN / STDOUT, функції / метод із відповідними параметрами та повним програмами типу "повернення". Твій дзвінок.
• Лазівки за замовчуванням заборонені.
• Якщо можливо, додайте посилання з тестом для вашого коду.
• Також настійно рекомендується додавати пояснення до своєї відповіді.

Тестові приклади:

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 байт

γТ1›ÏD€gZQÏ.M

Спробуйте в Інтернеті!

Пояснення

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

Желе , 12 байт

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

Спробуйте в Інтернеті!

Попередня версія - 14 байт

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

Спробуйте в Інтернеті!

Як це працює?

Œ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 байт

Вводиться як рядок. Повертає ціле число.

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

Спробуйте в Інтернеті!

Прокоментував

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

Сітківка , 56 байт

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

N$`
$.&
-1G`

Спробуйте в Інтернеті! Посилання включає тестові випадки. Пояснення:

L`(.)\1*

Перерахуйте всі максимально повторені цифри підрядів.

O`

Сортувати список за порядком.

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

Перелічіть усі множини підрядів з їх "підрахунком".

N`

Сортувати у порядку зростання кількості.

.+;

Видаліть рахунки.

N$`
$.&

Сортувати за зростанням по довжині. (Якщо довжини рівні, попередній порядок за рахунком зберігається.)

-1G`

Зберігайте останнє, тобто найдовше значення.

R , 102 байти

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

Спробуйте в Інтернеті!

Оскільки відповіді на відповідь ще не було, я вирішив спробувати, і ну ... це було непросто. Я не знаю, чи це гарний підхід, але ось він іде.

Вектори вводу та виводу символів.

Perl 6 , 58 56 байт

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

Спробуйте в Інтернеті!

Python 2 , 123 120 байт

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]

Спробуйте в Інтернеті!

Powershell, 101 байт

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

Пояснений тестовий сценарій:

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

Вихід:

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

Пітон 2 , 114 113 байт

-1 байт завдяки 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]

Спробуйте в Інтернеті!

Haskell, 72 байти

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

Як це працює

(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 байт

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

Спробуйте в Інтернеті!

• Введення: вектор відокремлених цілих цифр, наприкладc(1,8,8...)

• Вихід: вектор відокремлених цілих цифр

Розкручений код із поясненням:

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

Альтернативна версія, що приймає вектор цілих чи знакових цифр:

R , 88 байт

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

Спробуйте в Інтернеті!

• Введення: вектор розділених символів або цифр, наприклад, c("1","8","8"...)абоc(1,8,8...)

• Вихід: вектор відокремлених символів, якщо вхід був вектором символів, вектор цифр, якщо вхід був вектором цифр

Червоний , 256 250 байт

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

Спробуйте в Інтернеті!

Дійсно, справді довге рішення цього разу ... (зітхання)

Приймає дані як рядок.

Пояснення:

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 байт

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

Спробуйте в Інтернеті!

Пояснення (застаріле)

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

Кредити

• -9 байт та кров’янисті плями завдяки Кевіну Кройссену

Рубі , 68 67 байт

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

Спробуйте в Інтернеті!

Вхідні та вихідні масиви символів.

Підхід досить простий: ми визначаємо прогони послідовних цифр ( chunkвикористовуючи унар +як функцію ідентичності) і приймаємо максимум - спочатку за розміром пробігу (скидаємо на нуль, якщо кількість його виникнення <2), а потім за самим підрахунком .

PCRE, 152 байти

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

Дивіться це в дії на: https://regex101.com/r/0U0dEp/1 (просто подивіться перший матч у кожному тестовому випадку)

Це просто заради задоволення, оскільки регулярно вираження не є реальною мовою програмування саме по собі, а рішення обмежене: P

Оскільки група нульової ширини, наприклад, відповідає (?:)+лише один раз і не повторюється нескінченно, і оскільки PCRE внутрішньо створює копії груп, кількісно оцінені з обмеженнями, мені довелося використовувати там магічне число ("{1,592}"), яке означає, що ми можемо лише переглянути до 592 суміжних наборів цифр попереду, щоб знайти конкуруючий набір, який може бути довший, ніж той, який зараз перевіряється. Більше інформації про цю концепцію тут .

Perl 5 , 88 байт

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

Спробуйте в Інтернеті!

Трохи невольф, з тестами:

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

Мова Вольфрама (Mathematica) , 67 байт

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

Чиста функція. Приймає список цифр у якості вхідних даних і повертає список підрядів (не в конкретному порядку) як вихід. Не впевнений, чи можна керуватися пунктом "повинно з’явитися принаймні двічі" більш чітко. Спробуйте в Інтернеті!

Japt -h, 12 байт

Введення та вихід - це рядки.

ò¦ ñÊf@ÓZè¶X

Спробуй це