सबसे लंबे समय तक बराबर अनुवर्ती

18

परिभाषाएं

  • एक बाद सन्निहित नहीं हो सकता है, उदाहरण के [1, 1, 1]लिए एक अनुवर्ती है [1, 2, 1, 2, 1]।
  • एक समान परिणाम एक परवर्तीता है जिसमें प्रत्येक तत्व समान है।
  • हो सकता है कि सबसे लंबे समय तक समान परिणाम अद्वितीय न हों, उदाहरण के लिए [1, 1]और [2, 2]सबसे लंबे समय तक दोनों समान परिणाम हैं [2, 1, 1, 2]।

इनपुट

नीचे प्रारूप में से एक में सकारात्मक पूर्णांक की एक गैर-खाली सूची:

  • अपनी भाषा में सकारात्मक पूर्णांक की एक सरणी के मूल कार्यान्वयन के रूप में
  • दशमलव में newline- अलग पूर्णांकों की एक स्ट्रिंग के रूप में
  • यूनीरी में न्यूलाइन-सेपरेटेड पूर्णांक की एक स्ट्रिंग के रूप में
  • किसी भी अन्य उचित प्रारूप

उत्पादन

नीचे दिए गए किसी भी प्रारूप में किसी भी क्रम में सबसे लंबे समय तक समान अनुवर्ती:

  • आपकी भाषा में 2 डी नेस्टेड सरणी के रूप में (यदि इनपुट एक सरणी है)
  • समान रूप से एक समतल सरणी के रूप में समान तत्व सन्निहित हैं
  • किसी भी अन्य उचित प्रारूप

स्कोरिंग

यद्यपि हम कुछ लंबे समय से देख रहे हैं, उपयोग किया जाने वाला कोड बाइट्स की संख्या के संदर्भ में जितना संभव हो उतना कम होना चाहिए, क्योंकि यह कोड-गोल्फ है

परीक्षण के मामलों

इनपुट:

[1, 2, 3]
[1, 2, 2, 1]
[1, 2, 3, 2, 1]
[1, 2, 1, 2, 3, 4, 1]

आउटपुट:

[[1], [2], [3]]
[[1, 1], [2, 2]]
[[1, 1], [2, 2]]
[[1, 1, 1]]

ध्यान दें कि उपरोक्त आउटपुट के लिए, कोई भी आदेश मान्य है।

एक चपटा सरणी भी मान्य है, जब तक कि समान तत्व सन्निहित हैं।

code-golf  array-manipulation 
— लीक नन
स्रोत
4
"सबसे लगातार तत्वों" IMO की बात करना सरल होगा: बाद का उपयोग तब किया जाता है जब आदेश महत्वपूर्ण होता है, लेकिन यहां, इनपुट के प्रत्येक क्रमांकन में अनुमत सही आउटपुट का एक ही सेट होता है।
— श्रीवत्सआर
@ श्रीवत्सआर क्षमा करें, मैंने प्रश्न संपादित किया है।
— लीक नून
क्या एक फ्लैट सूची आउटपुट के लिए काम करती है? उदाहरण के लिए 1 2 3, 1 1 2 2, 1 1 2 2, 1 1 1?
— कॉनर ओ'ब्रायन
@ ConorO'Brien ने कहा कि हाँ यहाँ के अधिकांश उत्तरों को अमान्य कर दिया जाएगा ...
— लीक नून
@LeakyNun में, क्या यह स्वीकार्य विकल्प है?
— कॉनर ओ'ब्रायन

जवाबों:

8

जेली , 5 बाइट्स

ĠLÐṀị

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

ĠLÐṀị  Main link. Argument: A (array)

Ġ      Group; partition the indices of A by their corresponding values.
 LÐṀ   Select all index arrays with maximal length.
    ị  Unindex; retrieve the items of A at the specified indices.
— डेनिस
स्रोत
मुझे लगा कि जेली के पास अधिकतम जल्दी नहीं है ...
— लीक नून
यह तकनीकी रूप से एक अधिकतम त्वरित है, लेकिन हाँ, यह करता है।
— डेनिस
5

ब्रेकीलॉग , 7 बाइट्स

⊇ᶠ=ˢlᵍh

इसे ऑनलाइन आज़माएं!

व्याख्या

⊇ᶠ=ˢlᵍh
⊇ᶠ        Find all subsequences
  =ˢ      Keeping only those for which all elements are equal
    lᵍ    Group by length
      h   Take the first group

⊇का प्राकृतिक क्रम सबसे पहले क्रम बनाता है, इसलिए वे पहले समूह में समाप्त होते हैं।

1
ओह, हे, एक और Brachylogist।
— लीक नून
1
किसी तरह आप और मैं एक दूसरे को बार-बार ब्रेकीलॉग चैट में याद किया होगा; मैं इसे महीनों से इस्तेमाल कर रहा हूं, और यह जानकर आश्चर्यचकित था कि जाहिर तौर पर इसके अलावा किसी और व्यक्ति के लिए भी घातक था।
5

अजगर, 5 बाइट्स

S.M/Q

परीक्षण सूट

स्पष्टीकरण:

यह निहित है S.M/QZQ। .Mअधिकतम फ़ंक्शन है, इसलिए .M/QZQउन सभी तत्वों का चयन करता है , जहां /QZइनपुट में तत्व की घटनाओं की संख्या की गणना, अधिकतम है। Sफिर सूची को क्रमबद्ध करें ताकि समान तत्व सन्निहित हों।

— isaacg
स्रोत
3

बैश, 66 बाइट्स

sort|uniq -c|sort -rn|awk 'NR==1{a=$1}$1==a{for(i=a;i--;)print$2}'

ऐसा लगता है कि इसे छोटा होना चाहिए, लेकिन मैं यह पता नहीं लगा सकता कि कैसे।

sort                  # sort the input
|uniq -c              # group runs of identical lines and prefix with count
|sort -rn             # sort by count, with largest at top
|awk '                # pipe to awk...
  NR==1{a=$1}         # on the first line, set the variable "a" to field 1
  $1==a{              # on any line, if first field is a (max count)...
    for(i=a;i--;)     # a times...
    print$2           # print the second field
  }
'

इसे ऑनलाइन आज़माएं!

3 बाइट्स के लिए लीक नून को धन्यवाद !

— Doorknob
स्रोत
— लीकी नून
अपने स्पष्टीकरण को अद्यतन करने पर विचार करें
— लीक नून
3

पायथन 2 , 68 63 बाइट्स

lambda x:sorted(n for n in x if x.count(n)/max(map(x.count,x)))

इसे ऑनलाइन आज़माएं!

— डेनिस
स्रोत
पाइथन 3: पी
— लीकी नून
1
पोर्टिंग यह एक तुच्छ है: बस के printसाथ बदलें return।
— डेनिस
ओह, मैंने सोचा कि पायथन 3 नहीं है map।
— लीक नून
यह 3 में थोड़ा अलग है (एक जनरेटर देता है और यदि दो से अधिक तर्क होते हैं तो पुनरावृत्तियों को काटता है), लेकिन यह वहां है।
— डेनिस
मैंने सोचा कि पायथन ने इसके लिए एक अंतर्निहित
— बीटा डिके
2

गणितज्ञ, 42 31 25 बाइट्स

5 बाइट्स के लिए @GregMartin और दूसरे बाइट के लिए @MartinEnder को धन्यवाद! 

MaximalBy[Length]@*Gather

व्याख्या

MaximalBy[Length]@*Gather  (*                       {1, 2, 3, 2, 1}       *)
                   Gather  (* Gather same numbers:  {{1, 1}, {2, 2}, {3}} *)
                 @*        (* Function composition                        *)
MaximalBy[Length]          (* Find longest:         {{1, 1}, {2, 2}}      *)
— जंगवान मिन
स्रोत
1
आप के साथ 5 बाइट्स बचा सकते हैं Gather@#~MaximalBy~Length&।
— ग्रेग मार्टिन
2
@GregMartin और फिर MaximalBy[Length]@*Gather।
— मार्टिन एंडर
मैंने एक और स्वीकार्य विकल्प जोड़ा है जो आपको कुछ बाइट्स से गोल्फ में मदद कर सकता है।
— लीक नून
2

स्टैक्ड , 55 52 43 बाइट्स

sorted rle toarr:[1#]map MAX@K[1#K=]YES rld

इसे ऑनलाइन आज़माएं!

रन-लेंथ इनपुट द्वारा कार्य करता है, आवृत्तियों को छांटता है, ऐसी घटनाओं को रखता है जिनके लिए घटनाओं की संख्या अधिकतम होती है, और लंबाई डिकोडिंग चलाते हैं। एक फ्लैट सूची के माध्यम से आउटपुट, जैसा कि चुनौती से स्वीकार्य है।

— कोनोर ओ ब्रायन
स्रोत
2

दरअसल , 23 बाइट्स

;╗⌠;╜ck⌡M;♂NM╗⌠N╜=⌡░♂FS

इसे ऑनलाइन आज़माएं , या सभी परीक्षण मामलों को चलाएं !

एक-बाइट सुधार को इंगित करने के लिए लीक नन के लिए धन्यवाद जो वास्तव में मेरे लिए स्पष्ट होना चाहिए था

आराम उत्पादन प्रारूप से -3 बाइट्स

स्पष्टीकरण:

;╗⌠;╜ck⌡M;♂NM╗⌠N╜=⌡░♂FS
;╗                        save a copy of the input to register 0
  ⌠;╜ck⌡M                 for each value in the input list:
   ;                        make a copy on the stack
    ╜c                      count the occurrences in the input list (from register 0)
      k                     make a list: [value, count]
         ;♂N             make a copy, take last value of each list in the 2D list
            M╗           store the maximum count in register 0
              ⌠N╜=⌡░     filter the other copy of the list of [value, count] lists:
               N╜=         take items where the count equals the maximum count
                    ♂FS  take first items (values) and sort them
— मै जाऊं
स्रोत
1

पायथन 2, 138 बाइट्स

lambda l:[[x[0]]*x[1] for x in next(__import__('itertools').groupby(__import__('collections').Counter(l).most_common(),lambda x:x[1]))[1]]
— फ्रांसिस्को कूजो
स्रोत
itertoolsसबसे छोटा कभी नहीं है: पी
— लीक नून
मैंने एक और स्वीकार्य विकल्प जोड़ा है जो आपको कुछ बाइट्स से गोल्फ में मदद कर सकता है।
— लीक नून
1

MATL , 10 बाइट्स

3#XMg1bX"&

इसे ऑनलाइन आज़माएं!

व्याख्या

मेरे ऑक्टेव उत्तर के समान। [10, 20, 30, 20, 10]उदाहरण के रूप में इनपुट पर विचार करें ।

3#XM   % Three-output version of mode function. Gives the first mode, the
       % number of repetitions, and a cell array with all modes
       % STACK: 10, 2, {10; 20}
g      % Convert from cell array to matrix
       % STACK: 10, 2, [10; 20]
1      % Push 1
       % STACK: 10, 2, [10; 20], 1
b      % Bubble up in the stack
       % STACK: 10, [10; 20], 1, 2
X"     % Repeat those number of times vertically and horizontally
       % STACK: 10, [10, 10; 20, 20]
&      % Specify that implicit display will show only the top of the stack.
       % Since this is singleton cell array that contains a matrix, that 
       % matrix is directly displayed
— लुइस मेंडो
स्रोत
मैंने एक और स्वीकार्य विकल्प जोड़ा है जो आपको कुछ बाइट्स से गोल्फ में मदद कर सकता है।
— लीक नून
@LeakyNun मुझे बताने के लिए धन्यवाद
— लुइस
यह मेरी जिम्मेदारी है।
— लीक नून
1

ऑक्टेव , 47 बाइट्स

[~,b,c]=mode(input(0));disp([repmat(c,1,b){:}])

इसे ऑनलाइन आज़माएं!

व्याख्या

क्रमशः दूसरे और तीसरे आउटपुट mode(के रूप में [~,b,c]=mode(...)) पुनरावृत्ति की संख्या ( b) और एक स्तंभ सेल सरणी दे ( )c इनपुट में सबसे दोहराया तत्वों के ) कीinput(0) । सेल एरे cको तब क्षैतिज रूप से bबार -बार दोहराया जाता है ( repmat(c,1,b)), कॉमा- मैट्रिक्स को देने के लिए कॉमा-सेपरेटेड लिस्ट ( {:}) और कॉन्टैनेटेड हॉरिजॉन्टली ( [...]) में परिवर्तित किया जाता है, जो प्रदर्शित होता है ( disp(...))।

— लुइस मेंडो
स्रोत
मैंने एक और स्वीकार्य विकल्प जोड़ा है जो आपको कुछ बाइट्स से गोल्फ में मदद कर सकता है।
— लीक नून
1

05AB1E , 8 5 बाइट्स

क्रम में एक फ्लैट सूची आउटपुट करता है

.M¹Ã{

05AB1E एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

— अदनान
स्रोत
मैंने एक और स्वीकार्य विकल्प जोड़ा है जो आपको कुछ बाइट्स से गोल्फ में मदद कर सकता है।
— लीक नून
@LeakyNun अधिसूचना के लिए धन्यवाद :)
— अदनान
1

सीजेएम , 22 बाइट्स

{$e`z~\__:e>f=.*\]ze~}

यह एक अनाम ब्लॉक (फ़ंक्शन) है जो इनपुट को स्टैक के शीर्ष से लेता है और इसे आउटपुट से बदल देता है। आउटपुट एक चपटा हुआ सरणी विथक्वाल तत्व है जो सन्निहित है।

इसे ऑनलाइन आज़माएं!

व्याख्या

[10 20 30 20 10 ]उदाहरण के रूप में इनपुट पर विचार करें ।

{      e# Begin block
       e#   STACK: [10 20 30 20 10]
  $    e#   Sort
       e#   STACK: [10 10 20 20 30]
  e`   e#   Run-length encoding
       e#   STACK: [[2 10] [2 20] [1 30]]
  z    e#   Zip
       e#   STACK: [[2 2 1] [10 20 30]]
  ~    e#   Dump array contents onto the stack
       e#   STACK: [2 2 1] [10 20 30]
  \    e#   Swap
       e#   STACK: [10 20 30] [2 2 1]
  __   e#   Duplicate twice
       e#   STACK: [10 20 30] [2 2 1] [2 2 1] [2 2 1]
  :e>  e#   Fold maximum over array. Gives the maximum of the array
       e#   STACK: [10 20 30] [2 2 1] [2 2 1] 2
  f=   e#   Map "is equal" with number (2) over the array ([2 2 1])
       e#   STACK: [10 20 30] [2 2 1] [1 1 0]
  .*   e#   Vectorized multiplication
       e#   STACK: [10 20 30] [2 2 0]
  \    e#   Swap
       e#   STACK: [2 2 0] [10 20 30]
  ]    e#   Pack into array
       e#   STACK: [[2 2 0] [10 20 30]]
  z    e#   Zip
       e#   STACK: [[2 10] [2 20] [0 30]]
  e~   e#   Run-length decoding
       e#   STACK: [10 10 20 20]
}      e# End block
— लुइस मेंडो
स्रोत
0

APL (Dyalog) , 22 बाइट्स

आवश्यक है ⎕ML←3कई सिस्टम पर डिफ़ॉल्ट की होती है।

कार्यक्रम: s/⍨(⌈/=⊢)≢¨s←⊂⍨(⍋⊃¨⊂)⎕

⎕ संख्यात्मक (मूल्यांकित) इनपुट प्राप्त करें

(… ) टैसिट
 ⍋ आरोही वस्तुओं के सूचकांकों  को पूरे एरे
 ⊃¨ से
 ⊂उठाता है

⊂⍨ इसके बढ़ने पर कटौती करके विभाजन

s← के रूप में की दुकान रों

≢¨ टैली प्रत्येक

(... ) tacit फ़ंक्शन
 ⌈/ अधिकतम (टैली)  तर्क (लम्बाई) के
 = बराबर होता
 ⊢है

s/⍨ फिल्टर रों उस के साथ

समारोह: {s/⍨(⌈/=⊢)≢¨s←⊂⍨⍵[⍋⍵]}

{... } अनाम फ़ंक्शन जहां तर्क है⍵

⍵[⍋⍵] सॉर्ट (आरोही आइटम के सूचकांक के साथ लिट। इंडेक्स)

⊂⍨ इसके बढ़ने पर कटौती करके विभाजन

s← के रूप में की दुकान रों

≢¨ टैली प्रत्येक

(... ) tacit फ़ंक्शन
 ⌈/ अधिकतम (टैली)  तर्क (लम्बाई) के
 = बराबर होता
 ⊢है

s/⍨ फिल्टर है कि के साथ इसे ऑनलाइन कोशिश करो!

— एडम
स्रोत
मैंने एक और स्वीकार्य विकल्प जोड़ा है जो आपको कुछ बाइट्स से गोल्फ में मदद कर सकता है।
— लीक नून
0

PHP, 69 बाइट्स

<?print_r(preg_grep("#".max($r=array_count_values($_GET))."#",$r));

ऑनलाइन संस्करण

आउटपुट स्वरूप

की = मान, मूल्य = गिनती

Array
(
    [1] => 2
    [2] => 2
)

PHP, 96 बाइट्स

<?foreach($_GET as$v)$r[$m[]=count($l=preg_grep("#^{$v}$#",$_GET))][$v]=$l;print_r($r[max($m)]);

ऑनलाइन संस्करण

आउटपुट स्वरूप

1 डी कुंजी = मूल्य

2 डी की = प्रत्येक मान के लिए इनपुट सरणी में स्थिति

Array
(
    [1] => Array
        (
            [0] => 1
            [4] => 1
        )

    [2] => Array
        (
            [1] => 2
            [3] => 2
        )

)

PHP, 97 बाइट्स

<?foreach($_GET as$v)$r[count($l=preg_grep("#^{$v}$#",$_GET))][$v]=$l;ksort($r);print_r(end($r));
— जार्ग हुल्सरमन
स्रोत
मैंने एक और स्वीकार्य विकल्प जोड़ा है जो आपको कुछ बाइट्स से गोल्फ में मदद कर सकता है।
— लीक नून
0

जावास्क्रिप्ट (ईएस 6), 84 83 बाइट्स

एक क्रमबद्ध चपटा सरणी देता है।

a=>a.sort().filter((_,i)=>b[i]==Math.min(...b),b=a.map(i=>a.filter(j=>i-j).length))

परीक्षण के मामलों

कोड स्निपेट दिखाएं

— Arnauld
स्रोत
मैंने एक और स्वीकार्य विकल्प जोड़ा है जो आपको कुछ बाइट्स से गोल्फ में मदद कर सकता है।
— लीक नून
@LeakyNun अधिसूचना के लिए धन्यवाद।
— अरनौलद
0

सीजेएम, 24 बाइट्स

{$e`_$W=0=\{0=1$=},e~\;}

मैं 05ab1e में ऐसा करना चाहता था, लेकिन मैंने हार मान ली: पी

यह एक ब्लॉक है। इनपुट और आउटपुट स्टैक पर सरणियाँ हैं।

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

{                      e# Stack:                | [1 2 3 2 1]
 $                     e# Sort:                 | [1 1 2 2 3]
  e`                   e# RLE encode:           | [[2 1] [2 2] [1 3]]
    _$W=               e# Copy elements:        | [[2 1] [2 2] [1 3]] [2 1]
       0=              e# First element:        | [[2 1] [2 2] [1 3]] 2
         \             e# Swap:                 | 2 [[2 1] [2 2] [1 3]]
          {0=1$=},     e# Filter where x[0]==2: | 2 [[2 1] [2 2]]
                  e~   e# RLE decode:           | 2 [1 1 2 2]
                    \; e# Delete back:          | [1 1 2 2]
                      }
— फल तोड़ना
स्रोत
यह केवल तभी काम करता है जब सबसे छोटा पूर्णांक सबसे आम तत्वों से संबंधित हो। आपको $W=पहले की बजाय आवश्यकता होगी 0=।
— मार्टिन एंडर
मैंने एक और स्वीकार्य विकल्प जोड़ा है जो आपको कुछ बाइट्स से गोल्फ में मदद कर सकता है।
— लीक नून
0

क्लोजर, 65 बाइट्स

#(let[P partition-by C count](last(P C(sort-by C(P +(sort %))))))

Ungolfed:

(def f #(->> %
             (sort-by      identity)   ; sort so that identical values are one after another, same as sort
             (partition-by identity)   ; partition by identity (duh!)
             (sort-by      count)      ; sort by item count
             (partition-by count)      ; partition by item count
             last))                    ; get the last partition
— NikoNyrh
स्रोत
0

सी #, 145 बाइट्स

l=>{var t=Enumerable.Range(0,l.Max()+1).Select(i=>l.Count(a=>a==i));return t.Select((a,i)=>Enumerable.Repeat(i,a)).Where(d=>d.Count()==t.Max());}

यह और भी बेहतर होना चाहिए, हालांकि मैं एक तरह से फंस गया हूं।

व्याख्या

l =>                                                   //Takes the list
{                                                      //...
    var t = Enumerable.Range(0, l.Max() + 1)           //Makes a range till the count, so that the items together with their indices are double defined (i.e. the items are 0,1,2,3... and the indices are the same)
                      .Select(i =>                     //Takes the items
                          l.Count(a => a == i));       //And replaces them with the count of themselves in the list (so the item has the index with its old value and the count as it's actual value)
    return t.Select((a, i) =>                          //Then it takes this list and selects the items together with the indices
        Enumerable.Repeat(i, a))                       //Repeats them as often as they appeared in the list
                  .Where(d => d.Count() == t.Max());   //And just keeps those which appear the maximum amount of times
};                                                     //...

संभवतः एक पूरी तरह से अलग दृष्टिकोण बहुत कम होगा, इसलिए सी # चुनौती अभी भी खुली है :)

— MetaColon
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.