सबसे लंबी अंकगणितीय परवर्ती

Question

पूर्णांकों के एक गैर खाली परिमित अनुक्रम को देखते हुए, अधिकतम लंबाई के एक अंकगणितीय परिणाम लौटाते हैं।

यदि एक ही अधिकतम लंबाई के कई हैं, तो उनमें से किसी को भी लौटाया जा सकता है।

परिभाषाएं:

एक अंकगणितीय अनुक्रम एक अनुक्रम है a(1),a(2),a(3),a(4),...जैसे कि एक निरंतरता है cजो a(m+1)-a(m) = cसभी के लिए है m। दूसरे शब्दों में: दो बाद की शर्तों के बीच अंतर स्थिर है।

एक दृश्य को देखते हुए b(1),b(2),b(3),b(4),...एक परिणाम को एक दृश्य है b(s(1)),b(s(2)),b(s(3)),b(s(4)),..., जहां 1 <= s(1)और s(m) < s(m+1)सभी के लिए m। दूसरे शब्दों में: मूल अनुक्रम लें और जितनी चाहें उतनी प्रविष्टियाँ निकालें।

उदाहरण

Input                     Output
[4,1,2,3,6,5]             [1,3,5] or [1,2,3]
[5,4,2,-1,-2,-4,-4]       [5,2,-1,-4]
[1,2,1,3,1,4,1,5,1]       [1,1,1,1,1] or [1,2,3,4,5]
[1]                       [1]

कुछ लंबे परीक्षण के मामले:

Length: 25
Input: [-9,0,5,15,-1,4,17,-3,20,13,15,9,0,-6,11,17,17,9,26,11,5,11,3,16,25]
Output: [15,13,11,9] or [17,13,9,5]

Length: 50
Input: [35,7,37,6,6,33,17,33,38,30,38,12,37,49,44,5,19,19,35,30,40,19,11,5,39,11,20,28,12,33,25,8,40,6,15,12,27,5,21,6,6,40,15,31,49,22,35,38,22,33]
Output: [6,6,6,6,6] or [39,33,27,21,15]

Length: 100
Input: [6,69,5,8,53,10,82,82,73,15,66,52,98,65,81,46,44,83,9,14,18,40,84,81,7,40,53,42,66,63,30,44,2,99,17,11,38,20,49,34,96,93,6,74,27,43,55,95,42,99,31,71,67,54,70,67,18,13,100,18,4,57,89,67,20,37,47,99,16,86,65,38,20,43,49,13,59,23,39,59,26,30,62,27,83,99,74,35,59,11,91,88,82,27,60,3,43,32,17,18]
Output: [6,18,30,42,54] or [8,14,20,26,32] or [46,42,38,34,30] or [83,63,43,23,3] or [14,17,20,23,26] or [7,17,27,37,47] or [71,54,37,20,3]

पृष्ठभूमि

मुझे यह विचार तब मिला जब मैंने 2004 से ग्रीन-ताओ-प्रमेय को याद किया, जिसमें कहा गया था कि अपराधों के अनुक्रम में मनमाना लंबाई के परिमित अंकगणितीय अनुक्रम होते हैं।

Answer 1

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

ŒPIE$ÐfṪ

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

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

ŒPIE$ÐfṪ  Main link. Argument: A (list of integers)

ŒP        Powerset; generate all sublists of A, sorted by length.
     Ðf   Filter the powerset by the link to the left:
    $       Combine the two atoms to the left into a monadic link.
  I           Compute all increments.
   E          Test whether they're all equal.
          This returns all arithmetic subsequences, sorted by length.
       Ṫ  Tail; extract the last sequence.

Answer 2

पायथ, 12 11 बाइट्स

ef!P{-VTtTy

परीक्षण सूट।

          y  powerset of implicit input, generate all subsequences
ef       T   find the last subsequence (sorted increasing in length) where...
       Tt      bifurcate over tail, giving [1,2,3,4,5] [2,3,4,5]
     -V        vectorize over -, giving differences of each consecutive pair
    {          dedup (remove duplicate elements)
   P           pop, resulting in [] if all differences were equal
  !            boolean not, resulting in True if all differences were equal

एक बाइट के लिए @LeakyNun को धन्यवाद !

Answer 3

MATL, 19 18 17 16 18 बाइट्स

1 बाइट बचाया (और 2 बाइट्स वापस जोड़ा) लुइस के लिए धन्यवाद!

"GX@XN!"@dun2<?vx@

एक काफी भोली दृष्टिकोण जो ब्रूट बल की जाँच करता है, इनपुट के सभी क्रमबद्ध क्रमों की जाँच करता है। जाहिर है कि इसमें अधिक समय लग सकता है। एक बाइट को बचाने के लिए, मैंने सबसे छोटे उप-अनुक्रम (लंबाई = 1) के साथ शुरू किया है और बड़े अनुक्रम (लंबाई = एन) तक काम किया है।

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

व्याख्या

                % Impilicitly grab input array (N)
"               % For each value in this array
    G           % Explicitly grab the input
    X@          % Loop index, will be [1, 2, ... length(N)] as we iterate
    XN          % Determine all permutations of k elements (nchoosek). The output is 
                % each k-length permutation of the input as a different row. Order doesn't 
                % matter so the result is always ordered the same as the input
    !           % Take the transpose so each k-length permutation is a column
    "           % For each column
        d       % Compute the difference between successive elements
        un      % Determine the number of unique differences
        2<?     % If there are fewer than 2 unique values
            vx  % Vertically concatenate everything on the stack so far and delete it
            @   % Push the current permuatation to the stack
                % Implicit end of if statement
                % Implicit end of for loop
                % Implicit end of for loop
                % Implicitly display the stack

Comments

@LuisMendo धन्यवाद! मैं हमेशा सोचता था कि लूप पुनरावृत्ति कैसे प्राप्त करें #।

— स्वेवर

@LuisMendo ओह अच्छा पकड़, तुम सही हो। वह डबल diffएक खाली एरे देता है जिसे नकारा नहीं जा सकता।

— स्वेवर

Answer 4

पायथन 2, 124 115 98 97 बाइट्स

p=[[]]
for n in input():p+=[x+[n][:2>len(x)or n-x[-1]==x[1]-x[0]]for x in p]
print max(p,key=len)

बहुत धीमी और स्मृति गहन। Ideone पर इसका परीक्षण करें ।

वैकल्पिक संस्करण, 98 बाइट्स

p={()}
for n in input():p|={x+(n,)[:2>len(x)or n-x[-1]==x[1]-x[0]]for x in p}
print max(p,key=len)

यह सभी परीक्षण मामलों को तुरंत पूरा करता है। Ideone पर इसका परीक्षण करें ।

Comments

बाइट या गति, यह सवाल है

— downrep_nation

Answer 5

पाइथ चेकआउट 8593c76, मार्च 24 , 10 बाइट्स

efq-VTtT)y

यह बिल्कुल वैसा ही है जैसे कि डॉर्कनोब का जवाब, मार्च में वापस जाने के अलावा, एक 2 बाइट फंक्शन ( q ... )) था जिसने जाँच की थी कि क्या किसी सूची के सभी तत्व समान थे, जो कि उसी तरह है !P{, जो आप कर सकते हैं वर्तमान में।

Answer 6

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

a=>{for(m=i=0,l=a.length;i<l;i++)for(j=i;++j<l;)for(t=n=a[k=i],c=0;k<l;k++)a[k]==t&&(t+=a[j]-n,++c>m)?q=a[m=c,p=n,j]-n:q;return a.slice(-m).map(_=>(p+=q)-q)}

जेली के उत्तर की तुलना में लगभग 20 गुना अधिक ... Ungolfed:

function subsequence(a) {
    var max = 0;
    for (var i = 0; i < a.length; i++) {
        for (var j = i + 1; j < a.length; j++) {
            var target = a[i];
            var count = 0;
            for (var k = i; k < a.length; k++) {
                if (a[k] == target) {
                    count++;
                    target += a[j] - a[i];
                    if (count > max) {
                        max = count;
                        start = a[i];
                        step = a[j] - a[i];
                    }
                }
            }
        }
    }
    var result = new Array(max);
    for (var i = 0; i < max; i++) {
        result[i] = start + step * i;
    }
    return result;
}