"অলস সাজান" প্রয়োগ করুন

Question

আমি সংখ্যার একটি তালিকা বাছাই করার কথা, তবে আমি খুব অলস। সমস্ত নম্বর ক্রমবর্ধমান ক্রম না হওয়া অবধি কীভাবে সমস্ত সংখ্যার অদলবদল করা যায় তা চিত্রিত করা সত্যিই কঠিন, তাই আমি আমার নিজস্ব অ্যালগরিদম নিয়ে এসেছি যা গ্যারান্টি দিয়ে দেবে যে নতুন তালিকাটি সাজানো হয়েছে ¹ এখানে কিভাবে এটা কাজ করে:

আকার N এর তালিকার জন্য আমাদের N-1 পুনরাবৃত্তি প্রয়োজন। প্রতিটি পুনরাবৃত্তির উপর,

• N'th সংখ্যা N + 1'th সংখ্যার চেয়ে ছোট কিনা তা পরীক্ষা করুন । যদি এটি হয় তবে এই দুটি সংখ্যা ইতিমধ্যে বাছাই করা হয়েছে এবং আমরা এই পুনরাবৃত্তিটি এড়িয়ে যেতে পারি।

• যদি সেগুলি না হয় তবে এই দুটি সংখ্যা ক্রমযুক্ত না হওয়া পর্যন্ত আপনাকে প্রথম এন সংখ্যা ক্রমাগত হ্রাস করতে হবে ।

আসুন একটি কংক্রিট উদাহরণ গ্রহণ করা যাক। ধরা যাক ইনপুটটি ছিল

10 5 7 6 1

প্রথম পুনরাবৃত্তিতে আমরা 10 এবং 5 এর তুলনা করব 10 টি 5 এর চেয়ে বড়, সুতরাং এটি ছোট হওয়া অবধি এটি হ্রাস করব:

4 5 7 6 1

এখন আমরা 5 এবং 7 তুলনা করি 5 5 এর চেয়ে ছোট, সুতরাং আমাদের এই পুনরাবৃত্তির উপর কিছু করার দরকার নেই। সুতরাং আমরা পরের দিকে যান এবং 7 এবং 6 তুলনা করুন। 7 6 এর চেয়ে বড়, সুতরাং আমরা 6 টির চেয়ে ছোট হওয়া অবধি প্রথম তিনটি সংখ্যা হ্রাস করব এবং আমরা এটি পেয়েছি:

2 3 5 6 1

এখন আমরা 6 এবং 1 এর তুলনা করি Again আবার, 6 1 এর চেয়ে বড়, সুতরাং আমরা 1 টির চেয়ে ছোট হওয়া অবধি প্রথম চারটি সংখ্যা হ্রাস করব এবং আমরা এটি পেয়েছি:

-4 -3 -1 0 1

এবং আমরা শেষ! এখন আমাদের তালিকা নিখুঁত বাছাই ক্রমে। এবং জিনিসগুলিকে আরও উন্নত করতে আমাদের কেবল এন -1 বারের মধ্যে তালিকাটি পুনরাবৃত্তি করতে হয়েছিল , সুতরাং এই অ্যালগরিদমটি ও (এন -১) সময় অনুসারে তালিকা সাজায়, যা আমি নিশ্চিত যে সেখানে সবচেয়ে দ্রুততম অ্যালগরিদম ²

আপনার আজকের চ্যালেঞ্জ এই অলস বাছাইটি বাস্তবায়ন করা। আপনার প্রোগ্রাম বা ফাংশনটি আপনার পছন্দসই মানক বিন্যাসে পূর্ণসংখ্যার একটি অ্যারে দেওয়া হবে এবং আপনাকে অবশ্যই এই অলস বাছাই করে নতুন "সাজানো" তালিকাটি ফিরিয়ে দিতে হবে । অ্যারে কখনই খালি হবে না বা অ-পূর্ণসংখ্যা থাকবে।

এখানে কিছু উদাহরন:

Input: 10 5 7 6 1
Output: -4 -3 -1 0 1

Input: 3 2 1
Output: -1 0 1

Input: 1 2 3
Output: 1 2 3

Input: 19
Output: 19

Input: 1 1 1 1 1 1 1 1 1 
Output: -7 -6 -5 -4 -3 -2 -1 0 1 

Input: 5 7 11 6 16 2 9 16 6 16
Output: -27 -25 -21 -20 -10 -9 -2 5 6 16

Input: -8 17 9 7
Output: -20 5 6 7

সর্বদা হিসাবে, এটি কোড-গল্ফ , তাই আপনি যা করতে পারেন তারতমতম প্রোগ্রামটি লিখুন!

---

¹ এটির অর্থ যা বোঝায় এটির অর্থ এটি নয় তবে এটি প্রযুক্তিগতভাবে সত্য

² আমি সম্পূর্ণ মজা করছি, দয়া করে আমাকে ঘৃণা করবেন না

Comments

আমি মনে করি আপনি যদি এইভাবে এটি করেন তবে আপনি অলস নন

— জার্গ হালসারম্যান

@ জার্গহলসারম্যান ভাল কিছু পূর্ণসংখ্যার ভারী ভারী ... ঠিক তেমন ওজন বহন করার মুডে নয়, কেবল উপরের জিনিসগুলি বের করে নেওয়া ভাল

— এরিক দ্য আউটগলফার

<sarcasm>এই বাছাই করা অ্যালগরিদমটি এখনও O(N^2)সময় জটিলতায় আটকে থাকে কারণ আপনাকে হ্রাস করতে তালিকার পূর্বের অ্যাক্সেসযুক্ত আইটেমগুলির মধ্যে দিয়ে যেতে হবে। আমি পরিবর্তে তালিকাটি পিছনের দিকে যাওয়ার পরামর্শ দিন এবং প্রয়োজনীয় হিসাবে ধাপে কেবল একটি সংখ্যা হ্রাস করুন। এটি আপনাকে সত্য O(N)জটিলতা দেবে! </sarcasm>

— মান কালি

@ ভ্যালুআইঙ্ক O(n^2)মেমরি অ্যাক্সেসের ক্ষেত্রে তবে এটি O(n)তুলনার জন্য নয় ?

— কোল জনসন

@ কোল জনসন প্রযুক্তিগতভাবে হ্যাঁ, তবে সময়ের জটিলতার জন্য অ্যালগরিদমের সমস্ত পদক্ষেপ বিবেচনায় নেওয়া দরকার। আপনাকে এখনও প্রতিটি পুনরাবৃত্তির পূর্ববর্তী সমস্ত সূচকগুলির মধ্যে পুনরাবৃত্তি করতে হবে, সুতরাং এটি এখনও বেরিয়ে আসে O(N^2)।

— মান কালি

Answer 1

জেলি ,  14 12 11  9 বাইট

-২ বাইটস ইটিএইচ প্রডাকশনগুলিকে ধন্যবাদ (সর্বনিম্ন ডায়াড ব্যবহার করুন «)

I’«0Ṛ+\Ṛ+

পূর্ণসংখ্যার তালিকা গ্রহণ এবং ফিরিয়ে দেওয়া একটি মোনাডিক লিঙ্ক।

এটি অনলাইন চেষ্টা করুন! অথবা পরীক্ষার স্যুটটি দেখুন ।

আমি সত্যিই মনে করি না যে এটি অলস - যথেষ্ট!

কিভাবে?

I’«0Ṛ+\Ṛ+ - Link: list of integers, a              e.g. [ 8, 3, 3, 4, 6, 2]
I         - increments between consecutive items of a   [-5, 0, 1, 2,-4 ]
 ’        - decrement (vectorises)                      [-6,-1, 0, 1,-5 ]
   0      - literal 0
  «       - minimum of decremented increments and zero  [-6,-1, 0, 0,-5 ]
    Ṛ     - reverse                                     [-5, 0, 0,-1,-6 ]
      \   - cumulative reduce with:
     +    -   addition                                  [-5,-5,-5,-6,-12]
       Ṛ  - reverse                                     [-12,-6,-5,-5,-5]
        + - addition (with a)                           [-4,-3,-2,-1, 1, 2]

Answer 2

হাস্কেল , 40 বাইট

f(a:r)|h:t<-f r=h-max(r!!0-a)1:h:t
f x=x

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

Comments

এই চ্যালেঞ্জের জন্য একটি অলস ভাষা উপযুক্ত বলে মনে হচ্ছে

— টমসডিং করুন

Answer 3

জাভাস্ক্রিপ্ট (ES6), 61 বাইট

a=>a.map((b,i)=>a=(b-=a[i+1])>0?a.map(c=>i--<0?c:c-b-1):a)&&a

পরীক্ষার মামলা

let f =

a=>a.map((b,i)=>a=(b-=a[i+1])>0?a.map(c=>i--<0?c:c-b-1):a)&&a

console.log(JSON.stringify(f([10, 5, 7, 6, 1]))) // -4 -3 -1 0 1
console.log(JSON.stringify(f([3, 2, 1]))) // -1 0 1
console.log(JSON.stringify(f([1, 2, 3]))) // 1 2 3
console.log(JSON.stringify(f([19]))) // 19
console.log(JSON.stringify(f([1, 1, 1, 1, 1, 1, 1, 1, 1]))) // -7 -6 -5 -4 -3 -2 -1 0 1
console.log(JSON.stringify(f([5, 7, 11, 6, 16, 2, 9, 16, 6, 16]))) // 27 -25 -21 -20 -10 -9 -2 5 6 16
console.log(JSON.stringify(f([-8, 17, 9, 7]))) // -20 5 6 7

Answer 4

জেলি , 12 বাইট

I»1U
0ị;Ç_\U

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

কিভাবে এটা কাজ করে

I»1U  Helper link. Argument: l (list of integers)
I     Compute the increments (difference between items) of l.
 »1   For each item n, take the maximum of n and 1.
   U  Reverse.

0ị;Ç_\U  Main link. Argument: l (list of integers)
   Ç     Call the helper link with argument l.
  ;      Concatenate this with
0ị       the 0th last item of the (1-indexed) l. (Can't use Ṫ because it modifies l)
    _\   Cumulatively reduce the result by subtraction.
      U  Reverse.

খেলতে মূল ধারণাটি হ'ল: আপনি যদি ইনপুট এবং আউটপুট অ্যারেগুলি বিপরীত করেন তবে আউটপুটটি কেবল প্রতিটি ডেল্টা 0 বা তারও বেশি -1 এর সাথে প্রতিস্থাপিত হয় the উদাহরণ স্বরূপ:

[10,  5,  7,  6,  1]   input
[ 1,  6,  7,  5, 10]   reverse
[   5,  1, -2,  5  ]   deltas
[  -1, -1, -2, -1  ]   min(deltas, -1)
[ 1, -1, -2, -1, -1]   reverse and concat the last item of the original
[ 1,  0, -2, -3, -4]   re-apply deltas
[-4, -3, -2,  0,  1]   reverse

Answer 5

k, 20 বাইট

{x-|+\0,1_0|1+-':|x}

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

ব্যাখ্যা:

{                  } /function, x is input
                 |x  /reverse x
              -':    /difference between every element
            1+       /add one to each difference
          0|         /make minimum difference be 0
      0,1_           /swap first difference with a 0
    +\               /cumulative sum
   |                 /reverse again
 x-                  /subtract from x

Answer 6

হাস্কেল, 56 বাইট

a#(x:y:z)=map(+min(y-x-1)0)(a++[x])#(y:z)
a#x=a++x
([]#)

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

তালিকার প্রথম অংশটি প্যারামিটারে রাখুন a। প্রতিটি পদক্ষেপে পরবর্তী উপাদানটির xশেষে যুক্ত করুন aএবং এর সমস্ত উপাদানকে সর্বনিম্ন (y-x-1)এবং এর দ্বারা বৃদ্ধি করুন 0।

Answer 7

পাইথন , 54 বাইট

f=lambda a,*r:r and[f(*r)[0]-max(r[0]-a,1)]+f(*r)or[a]

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

ইনপুট মতো স্প্ল্যাটেড লাগে f(1,2,3)। একটি তালিকা আউটপুট। ক্ষতিকারক সময় ব্যবহার করে।

Answer 8

সি #, 76 বাইট

a=>{for(int d=0,i=a.Length-1;i>0;a[--i]-=d)d=a[i-1]-d<a[i]?d:a[i-1]-a[i]+1;}

এটি তালিকায় স্থান পরিবর্তন করে। এটি তালিকার পেছনের দিকে চলে যায় এবং প্রতিটি সংখ্যায় প্রয়োগ করতে ব-দ্বীপে চলমান মোট রাখে।

Answer 9

জাভাস্ক্রিপ্ট (ES6), 59 বাইট

f=([n,...a],p=a[0]-n)=>a+a?[(a=f(a))[0]-(p>1?p:1),...a]:[n]

Comments

কি দারুন. আমি একটি জেএস সমাধান লিখতে চলেছিলাম, কিন্তু তখন আমি এটি দেখতে পেলাম। আমি পরামিতিগুলির মতো স্প্রেড অপারেটরটি ব্যবহার করার কথা ভাবি নি

— andrewarchi

f=দুটি বাইট সংরক্ষণের জন্য আপনি জেএস উত্তরের জন্য ছেড়ে যেতে পারেন

— অ্যান্ড্রুয়ার্কি

@ অ্যান্ড্রুআর্চি ধন্যবাদ, তবে এই নির্দিষ্ট ফাংশনটির নিজেকে কল করতে হবে ( f(a)) তাই এটির এখনও নাম প্রয়োজন।

— ইটিএইচ প্রোডাকশনস

আমি ভুলে গিয়েছিলাম এটি পুনরাবৃত্ত

— অ্যান্ড্রুয়ারচি

Answer 10

ব্রেন-ফ্লাক , 153 বাইট tes

{(({})<>[({})])(({}({}))[({}[{}])])<>(([{}]({})))([({}<(())>)](<>)){({}())<>}{}{((<{}>))<>{}}{}<>{}{{}({}<>{}())((<>))}{}{}}{}<>{}([]){{}({}<>)<>([])}<>

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

এটি পতাকার +1জন্য অন্তর্ভুক্ত -r।

#While True
{

    #Push the last value left in the array minus the counter onto the alternate stack
    (({})<>[({})])

    #Put the counter back on top of the alternate stack
    (({}({}))[({}[{}])])

    #Toggle
    <>

    #Find the difference between the last two inputs left on the array
    (([{}]({})))

    #Greater than or equal to 0?
    ([({}<(())>)](<>)){({}())<>}{}{((<{}>))<>{}}{}<>{}

    #If So:
    {

      #Pop the truthy/falsy value
      {}

      #Increment the counter by the difference between elements +1
      ({}<>{}())

      #Push two falsys
      ((<>))

    #Endwhile
    }

    #Pop the two falsys
    {}{}

#Endwhile
}

#Pop the falsy

{}

#Toggle back
<>

#Pop the counter

#Reverse the stack
{}
([]){{}({}<>)<>([])}<>

Answer 11

আর, 56 বাইট

function(s){s-c(rev(cumsum(rev(pmax(0,-diff(s)+1)))),0)}

Comments

এর দুর্দান্ত ব্যবহারের জন্য diff, আমি কীভাবে এটি কাজ করব তা অনুধাবন করার চেষ্টা করছিলাম ... উপায় দ্বারা, আপনি -2 বাইটের জন্য ফাংশন বডিটির চারপাশের ব্রেসগুলি পরিত্রাণ পেতে পারেন তবে আরও ভাল, আপনি s=scan()কোনও ফাংশনের পরিবর্তে ব্যবহার করতে পারেন সংজ্ঞা আরও কিছু বাইট সংরক্ষণ করুন। এটি দুর্দান্ত হবে যদি আপনি অনলাইনে এটির চেষ্টা করার কোনও লিঙ্ক অন্তর্ভুক্ত করেন যাতে অন্যান্য লোকেরা যাচাই করতে পারে যে এই কোডটি সমস্ত পরীক্ষার ক্ষেত্রে কাজ করে।

— জিউসেপ

কোন চিন্তা করো না! আমরা সকলেই কোথাও শুরু করি :)

— জিউসেপ

Answer 12

জাভাস্ক্রিপ্ট (ES6), 68 বাইট

a=>a.map((v,i)=>(d=v-o[i+1]+1)>1?o=o.map((v,j)=>j>i?v:v-d):0,o=a)&&o

ইনপুট এবং আউটপুট হল পূর্ণসংখ্যার একটি অ্যারে।

পরীক্ষার স্নিপেট

f=
a=>a.map((v,i)=>(d=v-o[i+1]+1)>1?o=o.map((v,j)=>j>i?v:v-d):0,o=a)&&o

<input id=I oninput="O.value=f(this.value.split` `.map(x=>+x)).join` `">
<input id=O disabled>

Answer 13

জাভাস্ক্রিপ্ট (ES6), 50 বাইট

f=a=>(b=[...a]).some((_,i)=>a[i]-->=a[i+1])?f(a):b

ব্যাখ্যা:

এটি একটি পুনরাবৃত্তির সমাধান, যা প্রথমে অ্যারেটিকে ক্লোন করে, তারপরে কোনও মান অ্যারের পরবর্তী উপাদানটির চেয়ে বড় বা সমান না হওয়া পর্যন্ত সমস্ত মানকে হ্রাস করে।

যতক্ষণ পর্যন্ত কোনও উপাদান ক্রমবর্ধমান না থাকে ততক্ষণ ফাংশনটি নিজেকে কল করে। উপাদানগুলি শেষ পর্যন্ত বাছাই করা হলে ক্লোনটি ফেরত দেওয়া হয়। (আমরা নিজেই অ্যারেটি ফিরিয়ে দিতে পারি না, কারণ some()পদ্ধতিটি এর সমস্ত উপাদানগুলিকে হ্রাস করে--এর দ্বারা সমস্ত বন্ধ করে দেয়))

পরীক্ষার কেস:

f=a=>(b=[...a]).some((_,i)=>a[i]-->=a[i+1])?f(a):b

console.log(f([10,5,7,6,1])+'');
console.log(f([1,1,1,1,1,1,1,1,1])+'');
console.log(f([5,7,11,6,16,2,9,16,6,16])+'');
console.log(f([19])+'');
console.log(f([-8,17,9,7])+'');
console.log(f([1,2,3,4,5,6,7])+'');

Answer 14

এসডাব্লুআই-প্রোলগ, 194 বাইট

:-use_module(library(clpfd)).
f([],[],_,_).
f([A|B],[M|N],P,D):-A#=M-D-E,A#<P,abs(M,S),T#=S+1,E in 0..T,label([E]),f(B,N,A,D+E).
l([],[]).
l(A,B):-reverse(Z,B),f([X|Y],Z,X+1,0),reverse(A,[X|Y]).

এটি অনলাইনে এখানে চেষ্টা করতে সক্ষম হতে পারে: http://swish.swi-prolog.org/p/LazySort.pl

আপনি জিজ্ঞাসা করেছেন l(L, [10,5,7,6,1]).যা "এল এর জন্য সমাধান করুন, যেখানে এল এই তালিকার অলস সাজানো সংস্করণ" says

দুটি ফাংশন হ'ল:

• lঅ্যাজাইসোর্ট (এ, বি) - এ বলে যে এ হ'ল বি এর অলসেসর্টড সংস্করণ, যদি তারা উভয়ই খালি তালিকা হয়, বা যদি বি এর বিপরীত দ্বারা A অর্জন করা যায়, তালিকায় চলার জন্য সহায়ক ফাংশনটি কল করে এবং একটি সঞ্চয়ের সাথে বিয়োগফল করে প্রতিটি মান পূর্বের মানের চেয়ে কম ঠেলে দেওয়া এবং তার ফলাফলটিকে চারদিকে ডান দিকে ফিরিয়ে দেওয়া।
• fসহায়ক দুটি তালিকার সাথে তালিকার পূর্ববর্তী সংখ্যার মান এবং একটি ঘূর্ণন পার্থক্য সংগ্রহকারীকে মেলে এবং বর্তমান তালিকার অবস্থানের মূল মানটি বিয়োগকারী পার্থক্য সংযোজক হিসাবে সমাধান করে, forceচ্ছিকভাবে জোর করার জন্য প্রয়োজনীয় একটি নতুন মান বিয়োগ তালিকার পূর্ববর্তী সংখ্যার নীচে মান, এবং তালিকার fলেজের জন্য এখন বর্ধিত পার্থক্য সঞ্চয়ের সাথে পুনরাবৃত্তভাবে সমাধান করতে হবে।

সুইশের উপর পরীক্ষার কেসগুলির স্ক্রিনশট:

Answer 15

জাভাস্ক্রিপ্ট (ES6), 61 বাইট

a=>a.reduceRight((r,e)=>[e-(d=(c=e-r[0]+1)>d?c:d),...r],d=[])

সংক্ষিপ্ততম সমাধান নয় তবে আমি ব্যবহারের সুযোগটি পেরিয়ে যেতে পারিনি reduceRight।

Answer 16

সি # (.নেট কোর) , 89 88 86 79 বাইট

• কিছুটা ভিন্ন পদ্ধতির সাহায্যে মাত্র 1 বাইট সংরক্ষণ করা হয়েছে।
• এসগুলির সরলকরণের সাথে আরও 2 টি বাইট সংরক্ষণ করেছেন for।
• ভিজুয়ালমেলনের আশ্চর্যজনক গল্ফিং দক্ষতার জন্য 7 বাইট সংরক্ষণ করা হয়েছে।

a=>{for(int i=0,j,k;++i<a.Length;)for(k=a[i-1]-a[j=i]+1;--j>=0;)a[j]-=k>0?k:0;}

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

প্রথমে forঅ্যারের মাধ্যমে পুনরাবৃত্তি হয়, তারপরে এটি হ্রাস গণনা করে এবং অবশেষে দ্বিতীয় তৃতীয় অবস্থান forপর্যন্ত প্রয়োজনে উপাদানগুলি হ্রাস করে i।

কোনও নতুন ফিরিয়ে দেওয়া (এখনও নিয়মের অভ্যস্ত হওয়া) পরিবর্তে কেবল মূল অ্যারেটি সংশোধন করা বৈধ?

Comments

হ্যাঁ, মূল অ্যারেটি সংশোধন করা পুরোপুরি ঠিক আছে। :)

— ডিজেএমসিএমহেম

@ ডিজেএমসিহেম ধন্যবাদ, একটি নতুন তৈরি করতে আমি খুব অলস বোধ করেছি। :)

— চার্লি