একটানা 1-বিট বৃদ্ধি করা হয়

36

বিটগুলির একটি প্যাটার্ন (স্ট্রিং বা অ্যারের ফর্ম্যাট) দেওয়া হয়েছে: [0,1,1,1,0,1,1,0,0,0,1,1,1,1,1,1]

কাজগুলি হ'ল ক্রমান্বয়ে 1-বিটসের যে কোনও সংখ্যাকে 1 থেকে শুরু করে একটি আরোহণের সংখ্যা ক্রম সহ প্রতিস্থাপন করা।

ইনপুট

  • প্যাটার্ন (স্ট্রিং বা অ্যারের হিসাবে প্রাপ্ত হতে পারে) উদাহরণ:
    • স্ট্রিং: 1001011010110101001
    • এরে: [1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1]

আউটপুট

  • আরোহী সংখ্যা ক্রম (একটি স্ট্রিং বা অ্যারে হিসাবে ফিরে আসতে পারে) উদাহরণ:
    • স্ট্রিং: 1 0 0 1 0 1 2 0 1 0 1 2 0 1 0 1 0 0 1
    • এরে: [1, 0, 0, 1, 0, 1, 2, 0, 1, 0, 1, 2, 0, 1, 0, 1, 0, 0, 1]

বিধি

  • (কেবল স্ট্রিংয়ের জন্য প্রয়োগ করুন) ইনপুট স্বতন্ত্র 1এবং এর মধ্যে ফাঁকা স্থান ধারণ করে0
  • অনুমান ইনপুট length > 0
  • (কেবল স্ট্রিংয়ের জন্য প্রয়োগ করুন) আউটপুটটি স্পেস দ্বারা পৃথক করা হয়েছে (বর্ণমালার কোনও সংখ্যা বা অক্ষর না হলে আপনার যদি প্রয়োজন হয় তবে অন্য যে কোনও বিভাজক ব্যবহার করুন)

উদাহরণ: 

Given [0,1,1,1,0,1,1,0,0,0,1,1,1,1,1,1] 
Output [0,1,2,3,0,1,2,0,0,0,1,2,3,4,5,6]

--------------------------------------------------------------------------

Given 0110101111101011011111101011111111     
Output 0 1 2 0 1 0 1 2 3 4 5 0 1 0 1 2 0 1 2 3 4 5 6 0 1 0 1 2 3 4 5 6 7 8

---------------------------------------------------------------------------

Given 11111111111101    
Output 1 2 3 4 5 6 7 8 9 10 11 12 0 1

জয়ের মানদণ্ড: কোডগল্ফ

code-golf  sequence 
— লুইস ফিলিপে দে জেসুস মুনোজ
সূত্র

উত্তর:

19

05 এ বি 1 ই , 4 বাইট

γ€ƶ˜

এটি অনলাইন চেষ্টা করুন! বা পরীক্ষার মামলা হিসাবে

ব্যাখ্যা

γ      # split input into groups of consecutive equal elements
 €ƶ    # multiply each number in each sublist by its 1-based index in the sublist
   ˜   # flatten
— Emigna
সূত্র
1
ওফ, আমার থেকে ভাল। আমি এটা কখনই ভাবিনি।
— ম্যাজিক অক্টোপাস উর্ন
3
আমি কোডগল্ফ বাইট গণনা নিয়মের সাথে 100% পরিচিত নই (এবং গুগলিং কেবল এই পোস্টটি খুঁজে পেয়েছে যা কোনও সিদ্ধান্তে আসে নি)। যদিও আপনার উত্তরটি 4 টি অক্ষর নয় এটি কমপক্ষে 8 বাইট (উদাহরণস্বরূপ, BOM ছাড়াই utf-16-হওয়া উচিত 03 B3 20 AC 01 B6 02 DC) বা 9 বাইট (utf-8 CE B3 E2 82 AC C6 B6 CB 9C:) বা 10 বাইট (উদাহরণস্বরূপ, 2 বাইট বিওএম সহ ইউটিএফ -16) হওয়া উচিত নয় কোনও খেলনাবিহীন এনকোডিংয়ে? (হ্যাঁ, এক পারে একটি খেলনা 8-বিট 1 বাইট হিসাবে প্রতিনিধিত্ব এই 4 প্রতীক সঙ্গে ISO-8859 এনকোডিং অনুরূপ এনকোডিং গঠন করা, কিন্তু যে প্রতারনা মত মনে হয়।)
— ড jimbob
6
হ্যাঁ, ভাল প্রশ্ন কোডটি আসলে 05AB1E কোড পৃষ্ঠা ব্যবহার করে বাইনারি ফাইলে রূপান্তর করা যায় । উদাহরণস্বরূপ, γ€ƶ˜হিসাবে প্রতিনিধিত্ব করা হবে 04 80 8F 98। কোড পৃষ্ঠা সহজতর লেখার কোডকে সহজ করার জন্য বিদ্যমান। এই 4-বাইট ফাইলটি চালানোর জন্য আপনার --osabieপতাকাটি দিয়ে দোভাষীটি চালানো দরকার ।
— আদনান
18

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

scanl1$(*).succ

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

ব্যাখ্যা / Ungolfed

scanl1 একটি ফাংশন ব্যবহার করে তালিকার বাম দিক থেকে পুনরাবৃত্তি ঘটে যা সর্বশেষ ফলাফলটি গ্রহণ করে এবং ফলাফলের সাথে বর্তমান উপাদানটি একটি নতুন তালিকা উত্পন্ন করে, খালি তালিকা এবং সিঙ্গলেটনগুলিকে "অবিস্মরণিত" রেখে।

(*).succ এর সমতুল্য \x y-> (x+1)*y

ক্রিয়াকলাপটি scanl1( 1,2,3, .. ) দিয়ে শুরু হওয়ার সাথে কেবল সেই কাজটিই একসাথে কাজ করে 1 হয় এবং এর কোনও পূর্ববর্তী উপাদান নেই (এই ক্ষেত্রে এটি তালিকার প্রথম উপাদান যা "সংশোধিত" হবে না) অথবা তাদের একটি শীর্ষস্থানীয় 0 আছে ।

— ბიმო
সূত্র
14

কান্ড , 5 4 3 বাইট

ṁ∫g

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

ব্যাখ্যা

ṁ∫g  -- full function, example input: [1,1,1,0,1]
  g  -- group: [[1,1],[0],[1]]
ṁ    -- map the following and concatenate result (example with [1,1,1])
 ∫   -- | cumulative sum: [1,2,3]
     -- : [1,2,3,0,1]

ইতিহাস সম্পাদনা করুন

scanl1ওভার ব্যবহার করে -1 বাইটzipWith

-1 porting দ্বারা বাইট ডেনিস এর সমাধান

— ბიმო
সূত্র
11

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

অ্যারে হিসাবে ইনপুট নেয়।

a=>a.map(s=n=>s=n*-~s)

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

সংক্ষিপ্ততর a=>a.map(n=>a=n*-~a)(20 বাইট) দুর্ভাগ্যক্রমে ব্যর্থ হবে [1]কারণ তারা যে সংখ্যার পূর্ণসংখ্যাটি ধরে রেখেছে সিঙ্গেলন অ্যারে জোর করে।

— Arnauld
সূত্র
10

জে , 4 বাইট

#.~\

বুবলারের এপিএল সমাধানের একটি বন্দর

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

জে , 8 বাইট

i.&0@|.\

কিভাবে?

এটি কেবল পূর্ববর্তী দূরত্ব 0

       \  for each prefix
     |.   reverse it
    @     and
i.&0      find the index of the first 0

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

— গ্যালেন ইভানভ
সূত্র
8

পাইথন 2 , 39 38 বাইট

-1 বাইট ধন্যবাদ আউটগলফার এরিককে ধন্যবাদ

i=1
for x in input():i*=x;print i;i+=1

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

— যষ্টি
সূত্র
1
আমি আপনাকে মনে করি না ,।
— এরিক আউটগল্ফার
@ এরিক্ট আউটগল্ফার এটি এইভাবে সুন্দর দেখায় সি:
— রড
1
দুঃখিত, তবে কখনও কখনও জীবনে আপনাকে ত্যাগ স্বীকার করতে হয়।
— এরিক আউটগল্ফার
9
আরআইপি ,আপনি আর কোডে নেই, তবে আপনি চিরকাল আমার হৃদয়ে থাকবেন
— রড
6

কে (ওকে) , 11 8 বাইট

সমাধান:

{y*1+x}\

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

ব্যাখ্যা:

তালিকার উপরে আইট্রেট করুন। বৃদ্ধি সংগ্রহকারী, বর্তমান আইটেমটি দ্বারা গুণিত করুন (যা আইটেম 0 হলে সংযোজককে পুনরায় সেট করে):

{y*1+x}\ / the solution
{     }\ / iterate (\) over lambda function
     x   / accumulator
   1+    / add 1
 y*      / multiply by current item
— streetster
সূত্র
5

জেলি , 4 বাইট

ŒgÄF

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

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

ŒgÄF  Main link. Argument: A (bit array)

Œg    Group adjacent, identical bits.
  Ä   Accumulate; take the cumulative sum of each chunk.
   F  Flatten.
— ডেনিস
সূত্র
গ্রুপটি দ্রুত চালানোর সাথে সাথে এরিক পরামর্শ দিয়েছিল এটি তিন বাইট হবে! (যদি আমি বুঝতে পারি যে এটি কী করবে সঠিকভাবে)
— dylnan
@ অল্লান সমস্যা হ'ল এত তাড়াতাড়ি আচরণের বিষয়ে সিদ্ধান্ত নেওয়া শক্ত। :( এই কারণেই
— দ্রুতটি
মূল সম্ভাব্য প্রয়োগের জন্য একাধিক
— কুইক
5

আর , 46 31 বাইট

function(a)sequence(rle(a)$l)*a

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

sequence, যা "মূলত আর এর খুব প্রাথমিক ইতিহাসের প্রতি শ্রদ্ধার সাথে বিদ্যমান" , এখানে বেশ কার্যকর।

function(a)                       # function, taking a vector as argument
                    rle(a)$l      # take the lengths of the run-length encoding
           sequence(        )     # and generate the list [1:x for x in lengths]
                             *a   # multiply by a to maintain 0s, and return
— : Giuseppe
সূত্র
5

আরএডি, 8 বাইট

(⊢×1+⊣)⍂

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

কিভাবে?

  • (⊢×1+⊣), যদি ডান যুক্তি হয় 0, ফিরে 0আসুন, অন্যথায় বাম আর্গুমেন্ট বৃদ্ধি করুন
  • ⍂, এলটিআর স্ক্যান ( (A f B) f Cপরিবর্তে A f (B f C)), অ্যারে জুড়ে এটি প্রয়োগ করুন
— Zachary
সূত্র
4

জাভা 8, 55 48 বাইট

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

বাইটগুলি সংরক্ষণ করতে কোনও নতুন ফেরতের পরিবর্তে ইনপুট-অ্যারে পরিবর্তন করে।

-7 বাইটস @ টিমসেইগাইনকে ধন্যবাদ ।

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

ব্যাখ্যা:

a->{             // Method with integer-array parameter and no return-type
  int p=0,       //  Previous integer, starting at 0
      i=0;       //  Index-integer, starting at 0
  for(int v:a)   //  Loop over the values of the input-array:
    a[i++]=v<1?  //   If the current value is 0:
          p=0    //    Reset the previous integer to 0
         :       //   Else:
          ++p;}  //    Increase `p` by 1 first with `++p`
                 //    and set the current item to this new value of `p`
— কেভিন ক্রুইজসেন
সূত্র
1
আপনি এটিকে 48 এর মধ্যে শেভ করতে পারেন:a->{int p=0,i=0;for(int b:a)a[i++]=b<1?p=0:++p;}
— টিম সেগুইন
@ টিমসিগুইন ধন্যবাদ! এখন যেহেতু আমি এটি দেখতে পাচ্ছি আমি বিশ্বাস করতে পারি না যে আমি নিজেই এটি সম্পর্কে ভাবিনি।
— কেভিন ক্রুইজসেন
1
আমি পি থেকে মুক্তি পেতে সক্ষম হয়েছি, তবে এটি একই আকার :(a->{int i=0;for(int v:a)a[i]+=v*i++<1?0:a[i-2];}
— টিম সেগুইন
4

টিআইএস- , 68 + 33 = 101 বাইট

কোড (68 বাইট):

@0
MOV UP ACC
SUB 47
MOV ACC ANY
@1
ADD 1
JRO UP
SUB ACC
MOV ACC ANY

লেআউট (33 বাইট):

2 1 CC I0 ASCII - O0 NUMERIC - 32

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

ব্যাখ্যা:

|    Input 0    |    Input is given in ASCII (`0` is 48, `1` is 49)
+--------+------+
| Node 0 |      |    This node prepares the input data
+--------+      |
| MOV UP ACC    |    Read in a character
| SUB 47        |    Subtract 47 to map [48, 49] to [1, 2]
| MOV ACC ANY   |    Send the 1 or 2 to the next node
|               |    Implicitly wrap back to top of node
+--------+------+
| Node 1 |      |    This node does the incrementing/printing
+--------+      |
| ADD 1         |    Increment counter (starts at zero)
| JRO UP        |    Get value from above, and jump forward that many lines  (skip next line or not)
| SUB ACC       |    Reset counter to zero (if input was zero)
| MOV ACC ANY   |    Send the counter value downward to be printed
|               |    Implicitly wrap back to top of node
+---------------+
|   Output 0    |    Output is space-delimited numeric values
— Phlarx
সূত্র
4

গাইয়া , 5 বাইট

ẋ+⊣¦_

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

ব্যাখ্যা

ẋ+⊣¦_     Full program
ẋ         Split into chunks of equal adjacent values.
   ¦_     And for each chunk, flattening the result afterwards...
 +⊣       Reduce it cumulatively on + (addition); aka cumulative sums

ওহ, আমি ভেবেছিলাম এসই কোড ফন্টগুলি মনোস্পেস ....

— মিঃ এক্সকোডার
সূত্র
এগুলি মনোস্পেস ... প্রথম লাইনে একটি জায়গা নেই।
— মাইক্রোথপিক
সম্পাদনা দেখুন। এটি এখনও ভুল পথে চালিত।
— মিঃ এক্সকডার
আপনি অবশ্যই কোনও মোবাইল ডিভাইস বা অন্য কোনও কিছু থেকে সন্ধান করছেন - এটি আমার কাছে দুর্দান্ত দেখাচ্ছে
— মাইক্রোথপিক
@ মাইস্টেপিক আমি নই ...
— মিঃ এক্সকোডার
4

সি (জিসিসি) , 45 44 38 বাইট

f(a,i)int*a;{while(--i)*++a*=-~a[-1];}

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

টবি স্পিডকে ধন্যবাদ একটি বাইট সংরক্ষণ করুন!

শর্তের সময় * = এবং একটি স্মার্ট ব্যবহার করে 6 বাইট সংরক্ষণ করুন।

— মতেজ মুলেজ
সূত্র
আপনি 1 বাইট সংরক্ষণ করতে পারেন: *(a-1)→a[-1]
— টবি স্পিড
পিপিসিজিতে আপনাকে স্বাগতম! :)
— শেগি
4

পার্ল 6 , 29 24 18 বাইট

শানকে -6 বাইট ধন্যবাদ!

*.map:{($+=1)*=$_}

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

অভ্যন্তরীণ ফাংশনটি এর দ্বারা পারে ($+=1)*=*তবে তার পরে বেনামে ভেরিয়েবলটি ফাংশন কল জুড়ে থাকবে। আমরা এটি একটি সুস্পষ্ট কোড ব্লকে মোড়ানো দ্বারা পেতে পারি।

ব্যাখ্যা:

*.map:               # Map the array to
      {($+=1)    }   # The anonymous variable incremented
             *=$_    # Multiplied by the element
— জো কিং
সূত্র
আমি 16 বাইট একই মূল পদ্ধতির নিচে: *.map(($+=1)*=*)। এই সমাধানটিতে এমন প্রবক্তা রয়েছে যে ফাংশনটিতে $কলগুলি জুড়ে রাষ্ট্রের চলকটি স্থির থাকে, সুতরাং যদি চূড়ান্ত উপাদানটি একটি কলে চলে যায় এবং পরের কলটিতে প্রথম উপাদানটি পাস করা হয় তবে উভয়ই ননজারো হয়, তবে গণনাটি ভুল নম্বর দিয়ে শুরু হবে।
— শন
@ শীন, হ্যাঁ আমি মনে করি যখন আমি প্রাথমিকভাবে উত্তর দিয়েছিলাম তখন তার সাথে লড়াই করেছিলাম। ভাগ্যক্রমে আমি তারপরে একটি উপায় শিখেছি
— জো কিং
আপনার কাছে আরও একটি বাইট বন্ধ কোপ পারেন: *.map:{...}।
— শন
3

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

scanl1$((*)=<<).(+)

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

ব্যাখ্যা: কোডটি সমান scanl1(\b a->(b+a)*a), bবর্তমান বিটটি কোথায় এবং aসংযোজক। scanl1একটি তালিকা নেয়, সংগ্রহকারীর হিসাবে প্রথম তালিকার উপাদানটি ইনস্ট্যান্ট করে এবং তালিকার উপরে ভাঁজ করে এবং একটি নতুন তালিকায় মধ্যবর্তী মানগুলি সংগ্রহ করে।

সম্পাদনা করুন: বিএমও আমাকে কয়েক সেকেন্ড এবং 4 বাইট দ্বারা হারিয়েছে ।

— Laikoni
সূত্র
3

পাইথ , 6 বাইট

m=Z*hZ

এখানে চেষ্টা করুন!

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

m = Z * hZ - সম্পূর্ণ প্রোগ্রাম Full প্রশ্ন = মূল্যায়ন ইনপুট।
মি - প্রতিটি পূর্ণসংখ্যার জন্য Q.
 = জেড - ভেরিয়েবল জেড (0 থেকে পূর্বনির্ধারিত) নির্ধারণ করুন ...
   * এইচজেড - (জেড + 1) * ডি; (d শেষে অন্তর্ভুক্ত)
— মিঃ এক্সকোডার
সূত্র
3

নিয়মিত এক্সপ্রেশন ব্যবহার করে একটি উত্তর পেতে চেয়েছিলেন। পাঠকদের জন্য অনুশীলন হিসাবে আমি ছেড়ে যেতে সম্ভবত একটি সহজ সমাধান আছে।

পাওয়ারশেল কোর , 86 বাইট

Filter F{($_-split"(0)(\B|\b)"|?{$_-ne''}|%{$_-replace'(1+)',(1..$_.Length)})-join' '}

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

— জেফ ফ্রিম্যান
সূত্র
3

কিউ বেসিক, 60 বাইট

INPUT s$
FOR i=1TO LEN(s$)
b=MID$(s$,i)>="1
v=-b*v-b
?v
NEXT

স্ট্রিং হিসাবে ইনপুট নেয়; আউটপুটটিকে নিউলাইনগুলি দ্বারা পৃথক সংখ্যার হিসাবে দেয়।

ব্যাখ্যা

আমরা স্ট্রিং পড়তে s$এবং লুপ iথেকে 1তার দৈর্ঘ্য পর্যন্ত।

MID$(s$,i)অক্ষর থেকে স্ট্রিংয়ের i(1-ইনডেক্সড) স্ট্রিংয়ের শেষে পায়। এটি যদি একটি দিয়ে শুরু হয় তবে 1এটি অভিধানিকভাবে >=স্ট্রিং হবে "1"; এটি একটি দিয়ে শুরু হয় 0, এটি হবে না। তাই bপায় 0যদি সূচিতে চরিত্র iহল 0, বা -1যদি চরিত্র1 ।

পরবর্তী, আমরা বর্তমান মান আপডেট করি v। আমরা যদি কেবল একটি পড়ি 0, আমরা vহয়ে উঠতে চাই 0; অন্যথায়, আমরা vএকে একে বৃদ্ধি করতে চাই। অন্য কথায় v = (-b) * (v+1),; গণিতের সরলকরণ কোডটিতে দেখা সংক্ষিপ্ত প্রকাশ দেয়। শেষ পর্যন্ত, আমরা মুদ্রণ vএবং লুপ।

— DLosc
সূত্র
3

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

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

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

ব্যাখ্যা:

([]){  For each element in the input
    {}
    <>(())<>  Push a one to the other stack
    { If the element is one,
       {}<>({}({}))(<>)  Add the one to a copy of the previous number in the series
    }{}  Pop the element
([])}  End loop
{}<>   Pop extra zero
{({}[()]<>)<>}<>   And reverse the output stack, subtracting one from each element
— জো কিং
সূত্র
3

সি (জিসিসি), 57 52 51 বাইট

f(a,l,c,i)int*a;{for(c=i=0;i<l;)a[i++]=c=a[i]*-~c;}

আর্নৌল্ডের জাভাস্ক্রিপ্ট উত্তর বন্দর , জায়গায় অ্যারে পরিবর্তন করে। এটি এখানে অনলাইনে চেষ্টা করুন ।

— OOBalance
সূত্র
এটি কে ওআরআর সি বলে বলা কি আরও সঠিক হবে না?
— টিম সেগুইন
সম্ভবত, তবে এটি উত্তরের অনেক ক্ষেত্রে সত্য হবে। আমি কোনও বিশেষজ্ঞ নই, তবে এটি সম্পূর্ণভাবে সম্ভব যে কেএন্ডআর সি এমনকি বৈধ নয়। বিষয়টি হ'ল আমরা এই সাইটের ভাষার মান সম্পর্কে সত্যই যত্ন নিই না। যদি জিসিসি আপনাকে আরও আধুনিক সামগ্রীর সাথে কেএন্ডআর সি মিশ্রিত করতে দেয় তবে গল্ফিংয়ের উদ্দেশ্যে এটি বৈধ সি কারণ জিসিসি এটি সংকলন করবে। আরও দেখুন: কোডগল্ফ.স্ট্যাকেক্সেঞ্জারওয়েজ
— ২২২০৩
আমি এখনই অনুসন্ধান না করা পর্যন্ত বুঝতে পারিনি যে সি 11 এখনও পুরানো শনাক্তকারী তালিকা ফাংশন সিনট্যাক্স সমর্থন করে, তাই কিছুই নয়। তবে আপনার বক্তব্য নির্বিশেষে ধারণ করে।
— টিম সেগুইন
1
পরামর্শf(a,l,c)int*a;{for(c=0;l--;)c=*a++*=c+1;}
3

শেক্সপিয়ার, 365 বাইট

I.Ajax,.Ford,.Act I:.Scene I:.[enter Ajax and Ford]Ajax:Open mind!Scene V:.Ford:Am I nicer than the sum of a big red old cute hard cat a big red old cute joy?Ford:If so,you is the sum of thyself a son!Ford:If not,you is zero!Ford:Open heart!Ajax:you is a big red old cute hard cat.Ajax:Speak mind!Ajax:Open mind!Ford:Am I nicer than zero?Ajax:If so, let us Scene V.

এখানে চেষ্টা করুন

কম গল্ফ সংস্করণ

I.Ajax,.Ford,.
Act I:.
Scene I:.
[enter Ajax and Ford]
Ajax:Open mind!
Scene V:.
Ford:Am I nicer than the sum of a big red old cute hard cat a big red old cute joy?     <- smallest way to 48 (ascii "0") I could think of
Ford:If so,you is the sum of thyself a son!
Ford:If not,you is zero!
Ford:Open heart!
Ajax:you is a big red old cute hard cat.    <- get value of 32 or space
Ajax:Speak mind!                            <- then output it
Ajax:Open mind!
Ford:Am I nicer than zero?
Ajax:If so, let us Scene V.                 <- loop through inputs
— আল আর
সূত্র
280 বাইট । পরীক্ষা করে দেখুন SPL টিপস পৃষ্ঠা টিপস golfing জন্য।
— জো কিং
3

সি ++, 47 বাইট

[](int*a,int*b){for(int c=0;a!=b;)c=*a++*=1+c;}

একটি ল্যাম্বদা যা শুরুতে এবং শেষের পয়েন্টারগুলিকে স্থলে একটি অ্যারে পরিবর্তন করে।

এটি অনলাইন চেষ্টা করুন! (জাভাস্ক্রিপ্ট প্রয়োজন)

জেনেরিক সংস্করণ 55 বাইটে (এটি পাটিগণিত ধরণের উপাদানগুলির সাথে কোনও পাত্রে কাজ করে):

[](auto a,auto b){for(auto c=*a-*a;a!=b;)c=*a++*=1+c;};
— টবির গতি
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.