দীর্ঘতম পাটিগণিত অনুচ্ছেদ

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),...একটি subsequence একটি ক্রম 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

বাইটের জন্য @ লিক্যনুনকে ধন্যবাদ !

Answer 3

এমএটিএল, 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

@ লুইস মেন্ডো ধন্যবাদ! আমি সর্বদা ভাবতাম কীভাবে লুপের পুনরাবৃত্তি পাবেন #।

— সোয়েভার

@ লুইস মেন্ডো ওহ ভাল ধরা, আপনি ঠিক বলেছেন। এই দ্বিগুণ 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)

খুব ধীর এবং স্মৃতি নিবিড়। আইডিয়নে এটি পরীক্ষা করুন ।

বিকল্প সংস্করণ, 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)

এটি তাত্ক্ষণিকভাবে সমস্ত পরীক্ষার কেস সম্পূর্ণ করে। আইডিয়নে এটি পরীক্ষা করুন ।

Comments

বাইট বা গতি, এটাই প্রশ্ন

— ডাউনরেপ_নেশন

Answer 5

Pyth 8593c76, মার্চ 24 শে চেকআউট , 10 বাইট

efq-VTtT)y

এটি ঠিক ডোরকনব্বের জবাবের মতোই, মার্চের পিছনে ব্যতীত, একটি 2 বাইট ফাংশন ছিল ( q ... )) যাচাই করে একটি তালিকার সমস্ত উপাদান একই ছিল কিনা, যা একই, যা !P{আপনি সবচেয়ে ভাল করতে পারেন তা পরীক্ষা করে বর্তমানে।

Answer 6

জাভাস্ক্রিপ্ট (ES6), 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 গুণ বেশি সময় ... অসম্পূর্ণ:

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