একটি একক অঙ্কের দীর্ঘতম পুনরাবৃত্তি উপসূচী

17

চ্যালেঞ্জ:

একটি ধনাত্মক পূর্ণসংখ্যা দেওয়া হয়েছে, দীর্ঘতম একক অঙ্কের অনুপাতটি আউটপুট করুন যা কমপক্ষে দু'বার ঘটে এবং এর অন্য একটি সংখ্যার (বা পূর্ণসংখ্যার শুরু / শেষ) সীমা থাকে।

একটি উদাহরণ:

ইনপুট: 7888885466662716666
একটি একক অঙ্কের দীর্ঘতম অনুচ্ছেদটি 5 এর দৈর্ঘ্য সহ 88888( 7[88888]5466662716666) হবে However তবে, এই উপসর্গটি কেবলমাত্র পূর্ণসংখ্যায় একবার ঘটে।
পরিবর্তে, ইনপুটটির ফলাফলটি ( ) 7888885466662716666হওয়া উচিত , যেহেতু এটি দু'বার (অন্তত) ঘটে।666678888854[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ডিফল্টরূপে আউটপুট দেয় with
  • আপনি ধরে নিতে পারেন ইনপুটটিতে সর্বদা কমপক্ষে একটি বৈধ আউটপুট থাকবে।
  • আই / ও উভয়ই নমনীয়। অঙ্ক / বাইট / অক্ষরের তালিকা / অ্যারে / স্ট্রিম বা একক পূর্ণসংখ্যার পরিবর্তে স্ট্রিং হিসাবে হতে পারে।

সাধারণ নিয়ম:

  • এটি কোড-গল্ফ , তাই বাইট জেতে সংক্ষিপ্ত উত্তর।
    কোড-গল্ফ ভাষাগুলি আপনাকে নন-কোডগলফিং ভাষার সাথে উত্তর পোস্ট করতে নিরুৎসাহিত করবেন না। 'যে কোনও' প্রোগ্রামিং ভাষার জন্য যতটা সম্ভব সংক্ষিপ্ত উত্তর নিয়ে আসার চেষ্টা করুন।
  • স্ট্যান্ডার্ড নিয়মগুলি আপনার উত্তরের জন্য প্রযোজ্য , সুতরাং আপনাকে সঠিক পরামিতি এবং রিটার্ন-টাইপ, সম্পূর্ণ প্রোগ্রাম সহ 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]
code-golf  number  integer  counting  subsequence 
— কেভিন ক্রুইজসেন
সূত্র
1
প্রস্তাবিত পরীক্ষা মামলা: 8888858888866656665666। আমি যদি চ্যালেঞ্জটি সঠিকভাবে ব্যাখ্যা করি তবে ব্র্যাচল্যাগ এবং 05 এবি 1 ই সমাধান দুটিই ব্যর্থ।
— মিঃ এক্সকোডার
@ মিঃ এক্সকোডার যুক্ত হয়েছে, ধন্যবাদ।
— কেভিন ক্রুইজসেন
@ আর্নল্ড হুম, আমার মতে এটি যে কোনওভাবেই বিজয়ী হবে কারণ এটি 222অন্যান্য পূর্ণসংখ্যার দ্বারা আবদ্ধ হওয়ার চেয়ে বহুগুণ বেশি ঘটে । আমি অনুমান করি যে আমাদের কেবল সংঘটিত ঘটনাটি গণনা করা উচিত নয় 1111। ওপি'র জন্য অপেক্ষা করা ভাল indeed
— মিঃ এক্সকডার
2
@Arnauld জন্য 1112221112221111এই subsequences এবং তাদের গন্য আছেন: 1111 (1), 111 (2), 222 (2)। যেহেতু আমরা মাত্র দুবার অন্তত ঘটছে সিকোয়েন্স আউটপুট, আউটপুট একটি হতে পারে: 111, 222, [111,222], [222,111]। (আরও কিছু তথ্যের জন্য চতুর্থ বিধিটি দেখুন)) মূলত 1111কেবল কখনও গণনা করা হবে 1111, হিসাবে 1এবং এবং 111বা 11এবং হিসাবে নয় 11। আমি আপনার পরীক্ষার কেস যুক্ত করব, তবে আউটপুট হয় হয় উভয়ই 111এবং হয় 222।
— কেভিন ক্রুইজসেন

উত্তর:

6

05 এ বি 1 ই , 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
— Emigna
সূত্র
@ রিলে: দুর্ভাগ্যক্রমে এটি প্রথম উপাদানটি পাবে যা অগত্যা সর্বাধিক সাধারণ নয়।
— Emigna
উফ .. আমি বুলেটটি মিস করেছি।
— রিলে
5

জেলি , 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.
— মিঃ এক্সকোডার
সূত্র
5

জাভাস্ক্রিপ্ট (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
— Arnauld
সূত্র
হয়তো আমি এখানে কিছু ভুল বলছি, তবে যেহেতু ...sইনপুটটিকে অঙ্কের অক্ষরের তালিকায় রূপান্তরিত করে , কেবল স্ট্রিংয়ের পরিবর্তে ইনপুটটিকে অঙ্কের অক্ষরের একটি তালিকা হিসাবে নেওয়া কি সংক্ষিপ্ত নয়? আমি নমনীয় আই / ও অনুমোদিত করেছি। (তবে আমি ধরে নিচ্ছি এটি এটি আপনার কোডের অন্য একটি অংশে হস্তক্ষেপ করে?)
— কেভিন ক্রুইজসেন
2
@ কেভিন ক্রুইজসেন সমস্যাটি হ'ল শেষ ক্রমটি প্রক্রিয়া করতে আমার একটি অতিরিক্ত পুনরাবৃত্তি প্রয়োজন। ইতিমধ্যে একটি তালিকা থাকা [...s,0]সত্ত্বেও আমার করা দরকার s।
— আর্নৌল্ড
4

রেটিনা , 56 বাইট

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

N$`
$.&
-1G`

এটি অনলাইন চেষ্টা করুন! লিঙ্কে পরীক্ষার কেস অন্তর্ভুক্ত রয়েছে। ব্যাখ্যা:

L`(.)\1*

সমস্ত সর্বাধিক পুনরাবৃত্ত অঙ্কের উপসর্গগুলি তালিকাবদ্ধ করুন।

O`

ক্রম অনুসারে তালিকাটি সাজান।

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

তাদের "গণনা" সহ সমস্ত একাধিক অনুচ্ছেদ তালিকাবদ্ধ করুন।

N`

গণনার ক্রমবর্ধমান ক্রমে বাছাই করুন।

.+;

গণনাগুলি মুছুন।

N$`
$.&

দৈর্ঘ্যের আরোহণ ক্রম অনুসারে বাছাই করুন। (যেখানে দৈর্ঘ্য সমান, গণনার কারণে পূর্ববর্তী ক্রম সংরক্ষণ করা হয়েছে))

-1G`

শেষ অর্থাৎ দীর্ঘতম মান রাখুন।

— নিল
সূত্র
4

আর , 102 বাইট

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

এটি অনলাইন চেষ্টা করুন!

যেহেতু এখনও কোনও আর উত্তর ছিল না, তাই আমি চেষ্টা করে দেখলাম, এবং ভাল ... এটি সহজ ছিল না। আমি সত্যিই জানি না এটি একটি ভাল পদ্ধতির কিনা, কিন্তু এখানে এটি যায়।

অক্ষরের ভেক্টরগুলি ইনপুট এবং আউটপুট দেয়।

— কিরিল এল।
সূত্র
এই চ্যালেঞ্জটি সহ আর এর জন্য 100 বাইটের কাছাকাছি খুব ভাল।
— এনজিএম
3

পাওয়ারশেল, 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
— mazzy
সূত্র
3

হাস্কেল, 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
— nimi
সূত্র
ডেটা.লাইস্ট বেসের অংশ নয় বলে আপনার কি ভাষা হিসাবে হ্যাসেল + তালিকাগুলি ব্যবহার করার দরকার নেই ?
— ბიმო
@ বিডব্লিউও: জানেন না। আমি সর্বদা একটি সরল "হাস্কেল" ব্যবহার করেছি, এমনকি যখন আমি একটি বিদেশী লাইব্রেরি আমদানি করি (যেমন Glossগ্রাফিকাল আউটপুট বা Matrix)। আমি যদি আমদানির জন্য বাইট গণনাটি অন্তর্ভুক্ত না করতে চাই তবে আমি "হাস্কেল + কিছু" ব্যবহার করি। আমি মনে করি আমাদের মেটাতে এই বিষয় ছিল, কিন্তু আমি এটি আর খুঁজে পাচ্ছি না। যদি আমি সঠিকভাবে মনে রাখি, আমাদের "স্ট্যান্ডার্ড লাইব্রেরি" এর কোনও সাধারণ সংজ্ঞা ছিল না। হাস্কেলের জন্য রেফারেন্সটি কী হওয়া উচিত? হাস্কেল রিপোর্ট, জিএইচসি এর বেস, হাস্কেল প্ল্যাটফর্ম, অন্য কিছু?
— নিমি
আইএমও এটি সি / জাভাস্ক্রিপ্ট / .. এর মতো হওয়া উচিত (এটি যদি বিবেচিত হয়) আমাদের হাস্কেল (জিএইচসি) বা হাস্কেল (হাগস) ইত্যাদি ব্যবহার করা প্রয়োজন কারণ প্রয়োগটি পিপিসিজে কোনও ভাষা নির্দিষ্ট করে। সুতরাং একটি জিএইচসি উত্তরের জন্য যাতে বেস অন্তর্ভুক্ত থাকবে এবং অন্য
— সমস্তগুলির জন্য
এটির পরীক্ষার জন্য আপনার কাছে কি সম্ভবত টিআইও লিঙ্ক রয়েছে? বা Data.Listsলাইব্রেরি টিআইও বা অন্য কোনও অনলাইন হাস্কেল সংকলকটিতে উপলব্ধ নয়?
— কেভিন ক্রুইজসেন
1
@ কেভিন ক্রুজসেন: হ্যাঁ Data.Listsটিআইও-তে অনুপস্থিত। আপনি এই সংস্করণ দিয়ে এটি পরীক্ষা করতে পারেন ।
— নিমি
3

আর , 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])

এটি অনলাইন চেষ্টা করুন!

  • ইনপুট: পৃথক পৃথক সংখ্যার ভেক্টর যেমন egc(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]
}

বিকল্প সংস্করণ পূর্ণসংখ্যা বা চরিত্রের সংখ্যার ভেক্টর গ্রহণ করে:

আর , 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...)

  • আউটপুট: পৃথক অক্ষরগুলির একটি ভেক্টর যদি ইনপুট অক্ষরের একটি ভেক্টর ছিল, অঙ্কগুলির একটি ভেক্টর যদি ইনপুটটি সংখ্যার ভেক্টর ছিল

— digEmAll
সূত্র
আপনি একটি ব্যাখ্যা যোগ করতে পারেন? আমি জানি না কিভাবে এটি কাজ করছে।
— জয়সি
@ জয়সি: শেষ! (আমি বিশদগুলি কেবলমাত্র অ-আর ব্যবহারকারীদের জন্য জেনে
— রেখেছি
TY! এটা এখন জ্ঞান করে তোলে।
— জয়সি
2

লাল , 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
]
— গ্যালেন ইভানভ
সূত্র
2

জাভা (জেডিকে 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.
}                                       //

ক্রেডিট

— অলিভিয়ার গ্রাগোয়ার
সূত্র
1
আমি ভয় করি আপনার চেকটিতে একটি ছোট্ট ত্রুটি আছে j*o>M। আমি যদি সঠিকভাবে বুঝতে পারি তবে এটি সর্বাধিক লাগে length * occurrence-count। 1113311133933933933933উদাহরণস্বরূপ, একটি পরীক্ষার ক্ষেত্রে যেমন 111হবে (3 * 2 = 6), এবং এটি 33হবে (2 * 6 = 12)। সুতরাং এটি দীর্ঘতম হওয়ার 33পরিবর্তে 111কমপক্ষে দু'বার সর্বাধিক উপস্থিতি আউটপুট করে। এছাড়াও, var r="";for(;O-->0;)r+=D;return r;থেকে golfed যাবে for(;O-->0;)System.out.print(D);জাভা 10, বা জাভা 11 এমনকি খাটো: return(D+"").repeat(O);।
— কেভিন ক্রুইজসেন
@ কেভিন ক্রুইজসেন আমার মনে হয় আমি এটি ঠিক করেছি।
— অলিভিয়ার গ্রাগোয়ার
1
এটি প্রকৃতপক্ষে আরও ভাল দেখাচ্ছে এবং একই সাথে গল্ফিং বাইটগুলির দুর্দান্ত উপায়। আপনি কেবল আপনার ব্যাখ্যা আপডেট করতে ভুলে গেছেন। আর তুমি গলফ 1 এর আরও বেশি বাইট পরিবর্তন করতে পারেন int X[][]=new int[10][99],d,l=99,থেকে int l=99,X[][]=new int[10][l],d,।
— কেভিন ক্রুইজসেন
1
ধন্যবাদ কেভিন ক্রুজসেন! আমি d++<9পরিবর্তে লিখে আরও একটি বাইট গল্ফ ++d<10। বিশ্রামের জন্য দুঃখিত: আমি বরং আজ ক্লান্ত হয়েছি = _ =
— অলিভিয়ার গ্রাগোয়ার
2

রুবি , 68 67 বাইট

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

এটি অনলাইন চেষ্টা করুন!

অক্ষরের আউটপুট এবং আউটপুটগুলি।

পদ্ধতির দিকটি বেশ সহজবোধ্য: আমরা ধারাবাহিক অঙ্কগুলির chunkরানগুলি +সনাক্ত করি ( পরিচয় ফাংশন হিসাবে আনারি ব্যবহার করে ) এবং সর্বোচ্চটি গ্রহণ করি - প্রথমে রানের আকার অনুসারে (শূন্যটিতে পুনরায় সেট করুন যদি এর উপস্থিতি গণনা <2 হয়) তবে তারপরে গণনাটি নিজেই ।

— কিরিল এল।
সূত্র
2

পিসিআরই, 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 (প্রতিটি পরীক্ষার ক্ষেত্রে প্রথম ম্যাচটি দেখুন)

এটি কেবল মজাদার জন্য, যেহেতু রেজেক্স নিজের এবং নিজের মধ্যে বাস্তব প্রোগ্রামিং ভাষা নয় এবং সমাধানটি সীমাবদ্ধ: পি

কারণ শূন্য-প্রস্থের গোষ্ঠী যেমন (?:)+কেবল একবারেই মিলছে এবং অনির্দিষ্টকালের জন্য পুনরাবৃত্তি করে না এবং পিসিআরই অভ্যন্তরীণভাবে সীমাগুলির সাথে সংযুক্ত গ্রুপগুলির অনুলিপি তৈরি করে, আমাকে সেখানে একটি ম্যাজিক নম্বর ব্যবহার করতে হয়েছিল ("{1,592}"), যা এর অর্থ আমরা বর্তমানে প্রতিদ্বন্দ্বী সেটটি সন্ধান করতে এগিয়ে কেবলমাত্র 592 সংখ্যার সংক্ষিপ্ত সেট দেখতে পারি যা বর্তমানে তদারকির চেয়ে দীর্ঘতর হতে পারে। এই ধারণাটি সম্পর্কে আরও তথ্য এখানে ।

— jaytea
সূত্র
1

পার্ল 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
— কেজেটিল এস।
সূত্র
1

ওল্ফ্রাম ভাষা (গণিত) , 67 বাইট

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

খাঁটি ফাংশন। ইনপুট হিসাবে অঙ্কের তালিকা নিয়ে থাকে এবং আউটপুট হিসাবে সাবকোয়েন্সগুলির (কোনও নির্দিষ্ট ক্রমে নয়) একটি তালিকা প্রদান করে। নিশ্চিত না যে "কমপক্ষে দু'বার উপস্থিত হতে হবে" ধারাটি আরও পরিষ্কারভাবে পরিচালনা করা যায় কিনা। এটি অনলাইন চেষ্টা করুন!

— LegionMammal978
সূত্র
1
আপনি সম্ভবত এটির জন্য একটি টিআইও লিঙ্ক যুক্ত করতে পারেন?
— কেভিন ক্রুইজসেন
আপনি যদি সত্যিই জেদ করেন ...
— LegionMammal978
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.