মোট স্লট গণনা করা হচ্ছে

17

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

উদাহরণ স্বরূপ,

[9,10,9,8] => output: 5

কারণ চাকরি বরাদ্দ হবে হিসাবে [9 10 _ 9 8]।
১. প্রথমত, 9 টিতে দুটি শীতল বন্ধ দাগ দরকার _ _। সুতরাং আমরা দিয়ে শুরু 9 _ _।
২. পরবর্তী কাজ 10 পূর্ববর্তী কাজের 9 থেকে আলাদা, সুতরাং আমরা _ _ এর মধ্যে একটি বরাদ্দ করতে পারি। তাহলে আমাদের হবে 9 10 _।
৩. তৃতীয়, 9 এখন বরাদ্দ করা যাবে না, যেহেতু প্রথম কাজ 9 একই কাজ এবং এটি শীতল হওয়ার দরকার নেই। 9 10 _ 9।
৪. সর্বশেষে, ৮ টি আগের আগের দুটি কাজের মতো নয়, সুতরাং এটি ঠিক 9 এর পরে বরাদ্দ করা যেতে পারে এবং যেহেতু এটি শেষ কাজ তাই এটি শীতল হওয়ার দরকার নেই। চূড়ান্ত তালিকাটি 9 10 _ 9 8এবং প্রত্যাশিত আউটপুট 5, যা স্পটগুলির সংখ্যা (বা স্লটের সংখ্যা)

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

[1,2,3,4,5,6,7,8,9,10] => output : 10 ([1 2 3 4 5 6 7 8 9 10])
[1,1,1] => output: 7 ([1 _ _ 1 _ _ 1])
[3,4,4,3] => output: 6 ([3 4 _ _ 4 3])
[3,4,5,3] => output: 4 ([3 4 5 3])
[3,4,3,4] => output : 5 ([3 4 _ 3 4])
[3,3,4,4] => output : 8 ([3 _ _ 3 4 _ _ 4])
[3,3,4,3] => output : 7 ([3 _ _ 3 4 _ 3])
[3,2,1,3,-4] => output : 5 ([3 2 1 3 -4])
[] => output : 0 ([])
[-1,-1] => output : 4 ([-1 _ _ -1])

ইনপুট মান যে কোনও পূর্ণসংখ্যা হতে পারে (negativeণাত্মক, 0, ধনাত্মক)। চাকরি-তালিকার দৈর্ঘ্য 0 <= দৈর্ঘ্য <= 1,000,000।
আউটপুট একটি পূর্ণসংখ্যা হবে, মোট স্লট সংখ্যা, যা আউটপুট হিসাবে পরীক্ষার ক্ষেত্রে নির্দেশিত হয়। প্রথম বন্ধনের অভ্যন্তরের তালিকাটি কীভাবে আউটপুট উত্পন্ন হবে।

কোড-গল্ফের মানদণ্ড জিতেছে

code-golf  number  array-manipulation 
— jayko03
সূত্র
আমরা 0 এর পরিবর্তে কিছু না আউটপুট দিলে কি ঠিক আছে []?
— wastl
8
কোনও উত্তর গ্রহণ করা কি একটু তাড়াতাড়ি নয়?
— নিক কেনেডি
7
@ নিক কেনেডি যেমন বলেছিলেন, এটি খুব দূরের, খুব শীঘ্রই কোনও সমাধান গ্রহণ করা উচিত। কেউ কেউ এমনকি কোনও সমাধান কখনই গ্রহণ না করার পরামর্শ দেয় ।
— শেগি

উত্তর:

5

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

v¯R¬yQiõˆ}2£yåiˆ}yˆ}¯g

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

ব্যাখ্যা:

v           # Loop over the integers `y` of the (implicit) input-list:
 ¯R         #  Push the global_array, and reverse it
   ¬        #  Get the first item (without popping the reversed global_array itself)
    yQi  }  #  If it's equal to the integer `y`:
       õˆ   #   Add an empty string to the global_array
   2£       #  Then only leave the first 2 items of the reversed global_array
     yåi }  #  If the integer `y` is in these first 2 items:
        ˆ   #   Add the (implicit) input-list to the global_array
 yˆ         #  And push the integer `y` itself to the global_array
}¯g         # After the loop: push the global array, and then pop and push its length
            # (which is output implicitly as result)
— কেভিন ক্রুইজসেন
সূত্র
গ্লোবাল আরে কি? প্রোগ্রামটি শুরুর ফাঁকা কি?
— অজ্ঞতার
@ এম্বোডিমেন্টফ অজানা হ্যাঁ, এটি একটি একক অ্যারে যাতে আমি কিছু যোগ করতে পারি, যা আমি ধাক্কা দিতে পারি এবং যা আমি পরিষ্কার করতে পারি। এবং এটি প্রকৃতপক্ষে খালি শুরু হয়।
— কেভিন ক্রুইজসেন
3

ব্র্যাচল্যাগ , 10 বাইট

ব্র্যাচল্যাগ সেরা সঞ্চালন করে এমন সমস্যাটি দেখতে সর্বদা দুর্দান্ত

⊆Is₃ᶠ≠ᵐ∧Il

ব্যাখ্যা

⊆I           # Find the minimal ordered superset of the input (and store in I) where:
   s₃ᶠ       #     each substring of length 3
      ≠ᵐ     #     has only distinct numbers
        ∧Il  # and output the length of that superset

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

— Kroppeb
সূত্র
2

আর , 123 বাইট

`-`=nchar;x=scan(,'');while(x!=(y=gsub("([^,]+),(([^,]*,){0,1})\\1(,|$)","\\1,\\2,\\1\\4",x)))x=y;-gsub("[^,]","",y)+(-y>1)

এটি অনলাইনে চেষ্টা করে দেখুন - একক প্রোগ্রাম!

অনলাইনে এটি ব্যবহার করে দেখুন - একাধিক উদাহরণ!

একটি সম্পূর্ণ প্রোগ্রাম যা ইনপুট হিসাবে পূর্ণসংখ্যার কমা-বিচ্ছিন্ন তালিকাটি পড়ে এবং প্রয়োজনীয় স্লটগুলি আউটপুট করে। আমি নিশ্চিত যে এটি আরও কিছুটা চালিত হতে পারে এবং অন্য কয়েকটি ভাষায় এই রেজেক্স-ভিত্তিক সমাধানটি প্রয়োগ করা বাইটে আরও দক্ষ হবে।

দ্বিতীয় টিআইও-তে নোট করুন আমি একাধিক উদাহরণ দেখানোর অনুমতি দেওয়ার জন্য এটি একটি ফাংশনে আবৃত করেছি। এই ফাংশনটি চূড়ান্ত তালিকাটিও দেখায়, তবে এটি বিচ্ছিন্নভাবে চালিত হলে আমার মূল প্রোগ্রামটি আউটপুট নয়।

— নিক কেনেডি
সূত্র
2

টিএসকিউএল কোয়েরি, 158 বাইট

টেবিল হিসাবে ইনপুট ডেটা।

ক্যোয়ারী তাই পুনরাবৃত্তি

বিকল্প (বৃহত্তর 0)

প্রয়োজনীয়, কারণ সংখ্যার তালিকাটি 100 ছাড়িয়ে যেতে পারে যদিও এটি কেবল 32,767 পুনরাবৃত্তিগুলি পরিচালনা করতে পারে - এই কাজটিতে কি সীমাবদ্ধতাটি সত্যই প্রয়োজন?

DECLARE @ table(a int, r int identity(1,1))
INSERT @ VALUES(3),(3),(4),(4);

WITH k as(SELECT null b,null c,1p
UNION ALL
SELECT iif(a in(b,c),null,a),b,p+iif(a in(b,c),0,1)FROM @,k
WHERE p=r)SELECT sum(1)-1FROM k
OPTION(MAXRECURSION 0)

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

— t-clausen.dk
সূত্র
2

আর , 81 70 বাইট

sum(l<-rle(s<-scan())$l*3-3,1-l%/%6,((r=rle(diff(s,2)))$l+1)%/%2*!r$v)

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

বেশ কয়েকটি ব্যর্থ চেষ্টার পরে, কোডটি কুরুচিপূর্ণ হয়ে উঠেছে এবং এত ছোট নয়, তবে কমপক্ষে এটি এখন কার্যকর হয় ...

প্রথমত, আমরা একই কাজের ধারাবাহিক রানের দৈর্ঘ্যের মূল্যায়ন করি। যেমন এর জন্য 3, 3, 4, 3দেয়:

Run Length Encoding
  lengths: int [1:3] 2 1 1
  values : num [1:3] 3 4 3

এই রানগুলির প্রতিটি (len - 1) * 3 + 1পদক্ষেপ উত্পাদন করে ( + 1পৃথকভাবে পরিচালনা করা হয়)।

এর পরে, আমরা একই কাজের 2 টি পৃথক স্থানের ঘটনাগুলি প্রক্রিয়া করি: যেমন: x, y, xব্যবহার করে diff(s, lag=2)। ফলস্বরূপ ভেক্টরটি ক্রমানুসারে একটানা রান ( r) এ যোগ rleদেয়। এখন, বিভিন্ন আন্তঃবাহিত বিকল্পগুলির কারণে আমাদের ceiling(r$len/2)সমস্ত রান শূন্যের জন্য পদক্ষেপগুলি যুক্ত করতে হবে। উদাহরণ:

x y x(দৈর্ঘ্য 1) এবং x y x y(দৈর্ঘ্য 2) উভয়ের জন্য 1 টি অতিরিক্ত পদক্ষেপের প্রয়োজন:x y _ x (y)

x y x y x(দৈর্ঘ্য 3) এবং x y x y x y(দৈর্ঘ্য 4) উভয়ের জন্য 2 অতিরিক্ত পদক্ষেপ প্রয়োজন:x y _ x y _ x (y)

: পরিশেষে, আমরা একই কাজ একটি দীর্ঘ রান মাঝখানে এই পরিবর্তনও এর ঘটনার জন্য ক্ষতিপূরণ প্রয়োজন x, x, x, x...তাই 1-l%/%6কেবল পরিবর্তে 1।

— কিরিল এল।
সূত্র
আমি diff(s,lag=2)নৈকট্য সনাক্ত করার জন্য ব্যবহার সম্পর্কে মন্তব্য করার মাঝখানে ছিল ! এখন আপনি আমার সমাধানের চেয়ে বাইট ছোট ...
— জিউসেপ
হ্যাঁ, এখনও
— ক্যারিল এল
2

পাইথন 2 , 67 বাইট

r=[]
for x in input():
 while x in r[-2:]:r+=r,
 r+=x,
print len(r)

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

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

— xnor
সূত্র
2

কাঠকয়লা , 27 23 বাইট

Ｆθ«Ｗ№✂υ±²¦¦¦ι⊞υω⊞υι»ＩＬυ

এটি অনলাইন চেষ্টা করুন! লিঙ্কটি কোডটির ভার্জোজ সংস্করণ। ব্যাখ্যা:

Ｆθ«

কাজের উপর লুপ।

Ｗ№✂υ±²¦¦¦ι⊞υω

ফলটি শীঘ্রই বন্ধ করার সময় কাজটি শেষ দু'জনের মধ্যে একটি।

⊞υι»

ফলাফলটিতে বর্তমান কাজ যুক্ত করুন।

ＩＬυ

দাগ সংখ্যা মুদ্রণ করুন।

— নিল
সূত্র
2

আর , 74 68 বাইট

length(Reduce(function(x,y)c(y,rep("",match(y,x[2:1],0)),x),scan()))

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

কাজের অ্যারে তৈরি করে (বিপরীতে), তারপরে দৈর্ঘ্য নেয়। শুধু একটু খাটো চেয়ে দীর্ঘতর কিরিল এল এর উত্তর , তাই মাঝে মাঝে সরল পদ্ধতির বেশ ভাল। সম্পাদনা: আবার খাটো! আমি কিরিলের পরীক্ষার টেম্পলেটও ধার নিয়েছি।

-6 প্রতিস্থাপন বাইট max(0,which(y==x[2:1])) সঙ্গে match(y,x,0) ।

— : Giuseppe
সূত্র
@ গিয়াস্পেপ্পে ফাংশনটি কী করে c?
— অজ্ঞতার
@ এম্বোডিমেন্টোফিজেন্স - এর cঅর্থ দাঁড়ায় combine, যদিও concatenateএটি আরও ভাল হতে পারে; এটি তার যুক্তিগুলিকে একক তালিকায় একত্রিত করে।
— জিউসেপে
ধন্যবাদ, আমি ভেবেছিলাম এটি অদ্ভুত যে কোনও ভাষার গল্ফিংয়ের জন্য ডিজাইন করা হয়নি তার একটি অক্ষরের ফাংশন থাকবে
— অবহিতকরণের
1

পার্ল 6 , 98 বাইট

{($!=$,|$_ Z$_ Z .[1..*+1])>>.repeated.squish(:with({$+^=[*] $! ne$^a ne$^b,$b==($!=$a)})).sum+$_}

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

ব্লারহ, এটি করার আরও ভাল উপায় হতে পারে। আমি এটি 100% নিশ্চিত নই যে এটি সম্পূর্ণরূপে সঠিক, যদিও এটি যে সমস্ত প্রান্তের ক্ষেত্রে আমি ভাবতে পারি তা পাস করে।

মূলত, ইনপুট তালিকার সমস্ত ট্রিপল্টকে উভয় পাশের প্যাডিংয়ের সাথে গোষ্ঠীকরণের মাধ্যমে এটি শুরু হয়। উদাহরণস্বরূপ, [1,2,1,2]হয়ে যায় (Any,1,2), (1,2,1), (2,1,2), (1,2,Nil)। আমরা repeatedপ্রতিটি ট্রিপলেটে উপাদানগুলি পেয়েছি, হয়ে উঠছি (), (1), (2), ()।

এরপরে এটি squishপরপর উপাদানগুলি একই তালিকার মতো নয়, তবে একই আকারের (কোনও কিছুকে স্কোয়াশ না করা [1,1,1]) এবং প্রথম উপাদানটি এর আগে উপাদানটির সমান নয় (কারণ আমরা ঘন্টাগুলিকে একত্রিত করতে পারি না [1,1,2,2]), এবং অবশেষে এর আগে উপাদানটিও স্কুইড করা হয়নি ( [1,2,1,2,1,2])। সুতরাং (1), (2)উপরের উদাহরণে একসাথে স্কুইশ করা হবে।

অবশেষে, আমরা sumএই তালিকার সমস্ত দৈর্ঘ্যের একটি পাই যা আমাদের সন্নিবেশিত ঘন্টাগুলি উপস্থাপন করে এবং মূল তালিকার দৈর্ঘ্য যুক্ত করে।

উদাহরণ স্বরূপ:

(1,1,1) => (Any,1,1),(1,1,1),(1,1,Nil) => (1),(1,1),(1) => (no squishes) => 4+3 = 7
(1,2,1,2,1,2) => (Any,1,2), (1,2,1), (2,1,2), (1,2,1), (2,1,2), (1,2,Nil) => (),(1),(2),(1),(2),() => squish (1),(2) and (1),(2) => 2+6 = 8
— জো কিং
সূত্র
1

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

f=([x,...a],p,q)=>1/x?1+f(x!=p&x!=q?a:[x,...a,x=f],x,p):0

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

মন্তব্য

f = (             // f is a recursive function taking:
  [x,             //   x   = next job
      ...a],      //   a[] = array of remaining jobs
  p,              //   p   = previous job, initially undefined
  q               //   q   = penultimate job, initially undefined
) =>              //
  1 / x ?         // if x is defined and numeric:
    1 +           //   add 1 to the grand total
    f(            //   and do a recursive call to f:
      x != p &    //     if x is different from the previous job
      x != q ?    //     and different from the penultimate job:
        a         //       just pass the remaining jobs
      :           //     else:
        [ x,      //       pass x, which can't be assigned yet
          ...a,   //       pass the remaining jobs
          x = f   //       set x to a non-numeric value
        ],        //
      x,          //     previous job = x
      p           //     penultimate job = previous job
    )             //   end of recursive call
  :               // else:
    0             //   stop recursion
— Arnauld
সূত্র
1

সি (জিসিসি) , 69 বাইট

f(j,l)int*j;{j=l>1?(*j-*++j?j[-1]==j[l>2]?j++,l--,3:1:3)+f(j,l-1):l;}

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

সোজা পুনরাবৃত্তি।

f(j,l)int*j;{               //Jobs, (array) Length
    j=l>1                   //if l > 1, do a recursion:
        ? (*j-*++j          // check if first and second elements are equal (j++)
            ? j[-1]==       //  1st!=2nd; check if first and third are equal
                j[l>2]      //  (first and second if l==2, but we already know 1st!=2nd)
                ? j++,l--,3 //   1st==3rd (j++,l--) return 3+f(j+2,l-2)
                : 1         //   1st!=3rd (or l==2) return 1+f(j+1,l-1)
            : 3             //  1st==2nd            return 3+f(j+1,l-1)
          )+f(j,l-1)        // j and l were modified as needed
        : l;                // nothing more needed  return l
}
— attinat
সূত্র
1

স্মলটালক, 125 বাইট

c:=0.n:=q size.1to:n-2do:[:i|(j:=q at:i)=(k:=q at:i+1)ifTrue:[c:=c+2].j=(m:=q at:i+2)ifTrue:[c:=c+1]].k=m ifTrue:[c:=c+1].c+n

ব্যাখ্যা

c : accumulator of proximity penalty
q : input array.
n := q length
i : iteration index from 1 to: n-2 (arrays are 1-based in Smalltalk).
j := memory for element i, saves some few bytes when reused
k := similar to j but for i+1.
m := similar to k but for i+2.
— লিয়ান্ড্রো ক্যানিগলিয়া
সূত্র
এটি কি স্নিপেট নয় ?
— এটিনিট
1

পার্ল 5 -pl , 42 40 বাইট

$a{$_}=~s/.*/$\=$&if++$\<$&;$\+3/e}{$_=0

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

— wastl
সূত্র
-pপ্রতিস্থাপন ব্যবহার করে এবং পুনরায় কাজ করে এটিকে 35 এ কেটে ফেলুন : এটি অনলাইনে চেষ্টা করুন!
— এক্সকালি
@ এক্সকালি যা খালি ইনপুটটির জন্য কিছুই দেয় না, তবে আমি 39
— পৌঁছে গেলাম
1
1,1,1 এর জন্য কাজ করছে বলে মনে হয় না ।
— নয়েলহোফ
@ ননহ্নহোফ ফিক্সড
— ওয়াচটল
0

ব্যাচ, 184 বাইট

@echo off
@set l=-
@set p=-
@set n=0
@for %%j in (%*)do @call:c %%j
@exit/b%n%
:c
@if %1==%l% (set l=-&set/an+=2)else if %1==%p% set l=-&set/an+=1
@set p=%l%&set l=%1&set/an+=1

ইনপুট হ'ল কমান্ড-লাইন আর্গুমেন্টের মাধ্যমে এবং আউটপুটটি প্রস্থান কোডের মাধ্যমে হয়। ব্যাখ্যা:

@set l=-
@set p=-

শেষ দুটি কাজ সন্ধান করুন।

@set n=0

গণনা শুরু করুন।

@for %%j in (%*)do @call:c %%j

প্রতিটি কাজ প্রক্রিয়া।

@exit/b%n%

চূড়ান্ত গণনা আউটপুট।

:c

প্রতিটি কাজের জন্য:

@if %1==%l% (set l=-&set/an+=2)else if %1==%p% set l=-&set/an+=1

আমরা যদি সম্প্রতি কাজটি প্রক্রিয়াজাত করি, তবে দাগ কমে যাওয়ার উপযুক্ত সংখ্যায় যুক্ত করুন। অতিরিক্তভাবে, শেষ কাজটি সাফ করুন যাতে পরবর্তী কাজটি কেবল এই কাজের মতো হলেই শীতল হওয়া বন্ধ করে দেয়।

@set p=%l%&set l=%1&set/an+=1

শেষ দুটি কাজ আপডেট করুন এবং এই কাজের জন্য একটি স্পট বরাদ্দ করুন।

— নিল
সূত্র
0

সুইফট, 114 বাইট

func t(a:[Int]){
var s=1
for i in 1...a.count-1{s = a[i-1]==a[i] ? s+3:i>1&&a[i-2]==a[i] ? s+2:s+1}
print("\(s)")}

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

— onnoweb
সূত্র
2
ব্যর্থ হয়েছে 3,4,3,4, 5 বাজি দেওয়া উচিত, 6 নয়
— ক্যারিল এল
কাইসিএল ফিক্স ছাড়াও কিরিলএল। দ্রষ্টব্য, s = aহতে পারে s=a, এবং আপনি s+=একাধিকের চেয়ে বেশি করতে পারেন s=s+...এবং এর পরে স্পেসগুলি সরিয়ে ফেলতে পারেন ?: for i in 1...a.count-1{s+=a[i-1]==a[i] ?3:i>1&&a[i-2]==a[i] ?2:1}9 বাইট সংরক্ষণ করতে।
— ড্যানিয়েল উইদিস 22'19
0

পাইথন 3 , 79 75 বাইট

-3 বাইটস মাইপেলিয়ন
-1 বাইট সারা জে ধন্যবাদ জানায়

f=lambda a,b=[]:a and f(*[a[1:],a,a[:1]+b,[b]+b][a[0]in b[:2]::2])or len(b)

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

— জোনাস অউসেভিসিয়াস
সূত্র
1
a[0]in b[:2]and f(a,['']+b)or f(a[1:],[a[0]]+b)f(*[a[1:],a,[a[0]]+b,['']+b][a[0]in b[:2]::2])2 বাইট সংরক্ষণ করতে পারে ।
— মাইপেটলিয়ন 22'19
1
[a[0]]+ba[:1]+b1 বাইট সংরক্ষণ করতে পারে ।
— মাইপিটলিয়ন
1
প্রতিস্থাপন করা হচ্ছে ['']+bসঙ্গে [b]+b- সংরক্ষণ একটি বাইট bমান কোন একটি তালিকা, তাই এটি কখনোই সমান হবেনa
— সারা জে
0

জাভা (জেডিকে) , 110 বাইট

j->{int p,q;for(p=q=j.length;p-->1;q+=j[p]==j[p-1]?2:(p>1&&j[p]==j[p-2]&(p<3||j[p-1]!=j[p-3]))?1:0);return q;}

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

অসলোফড মন্তব্য কোড:

j -> {
    int p, q = j.length; // Run all jobs
    for (p = q; p-- > 1;) { // reverse iterate
        q += j[p] == j[p - 1] ? 2 : // add 2 if prev same
        (p > 1 && j[p] == j[p - 2] & // 1 if 2prev same
        (p < 3 || j[p - 1] != j[p - 3]) // except already done
        ) ? 1 : 0; // otherwise 0
    }
    return q;
}
— ড্যানিয়েল উইদিস
সূত্র
3,4,3,4,3,48 এর পরিবর্তে 7
— টির
এটি একটি দুষ্ট সামান্য সমস্যা।
— ড্যানিয়েল উইদিস
0

জেলি , 20 বাইট

ṫ-i⁹⁶x;
⁶;ç³Ṫ¤¥¥³¿L’

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

যদিও এটি @ এরিকথআউটগলফারের সংক্ষিপ্ত উত্তরের মতোই , তবে আমি এটি না দেখে এটি লিখেছি। যে কোনও ক্ষেত্রে তার ভাল!

ব্যাখ্যা

সহায়ক ডায়াডিক লিঙ্কটি বাম আইটেম হিসাবে এবং বর্তমান আইটেমটি ডান হিসাবে গ্রহণ করে

ṫ-            | take the last two items in the list
  i⁹          | find the index of the new item
    ⁶x        | that many space characters
      ;       | prepend to new item

প্রধান মোনাডিক লিঙ্ক, ইনপুট হিসাবে পূর্ণসংখ্যার তালিকা গ্রহণ করে

⁶             | start with a single space
 ;            | append...
  ç³Ṫ¤¥       | the helper link called with the current list
              | as left item and the next input item as right
       ¥³¿    | loop the last two as a dyad until the input is empty
          L   | take the length
           ’  | subtract one for the original space
— নিক কেনেডি
সূত্র
0

জাভাস্ক্রিপ্ট (ভি 8), 101 বাইট

f=a=>for(var c=0,i=0;i<a.length;i++,c++)a[i-1]==a[i]?c+=2:a[i-2]==a[i]&&(c++,a[i-1]=void 0)
return c}

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

প্যাকযুক্ত কোডটি নিম্নরূপ দেখায়:

function f(a)
{
    var c = 0;
    for (var i = 0; i < a.length; i++, c++)
    {
        if (a[i - 1] == a[i])
            c+=2;
        else if (a[i - 2] == a[i])
            c++,a[i-1]=undefined;
    }

    return c;
}

আমার প্রথম কোড-গল্ফ প্রচেষ্টা, অ্যারে সঙ্কুচিত করে এবং এটি পুনরাবৃত্তির সাথে পাস করার মাধ্যমে সম্ভবত অনেকগুলি অনুকূল করা যেতে পারে।

— Broxzier
সূত্র
পিপিসিজিতে আপনাকে স্বাগতম! এটি একটি দুর্দান্ত প্রথম পোস্ট!
— আর
0

Zsh , 66 60 বাইট

অন্তর্নিহিত থেকে -6 বাইট "$@"

for j
{((i=$a[(I)$j]))&&a=
a=("$a[-1]" $j)
((x+=i+1))}
<<<$x

এটি অনলাইন চেষ্টা করুন! আমি set -xশুরুতে যুক্ত করার পরামর্শ দিচ্ছি যাতে আপনি পাশাপাশি অনুসরণ করতে পারেন।

for j                   # Implicit "$@"
{                       # Use '{' '}' instead of 'do' 'done'
    (( i=$a[(I)$j] )) \ # (see below)
        && a=           # if the previous returned true, empty a
    a=( "$a[-1]" $j )   # set the array to its last element and the new job
    (( x += i + 1 ))    # add number of slots we advanced
}
<<<$x                   # echo back our total
((i=$a[(I)$j]))
    $a[     ]           # Array lookup
       (I)$j            # Get highest index matched by $j, or 0 if not found
  i=                    # Set to i
((           ))         # If i was set nonzero, return true

aসর্বদা সর্বশেষ দুটি কাজ থাকে, সুতরাং যদি অনুসন্ধানে কোনও মিল খুঁজে পাওয়া যায় তবে a[2]আমরা তিনটি বাড়িয়েছি (যেহেতু কাজের স্লট হবে[... 3 _ _ 3 ...] )।

যদি a সেট না করা থাকে, তবে অনুসন্ধান ব্যর্থ হবে এবং পাটিগণিতের সম্প্রসারণ একটি ত্রুটি ফিরিয়ে দেবে, তবে এটি কেবল প্রথম কাজেই ঘটে এবং মারাত্মক নয়।

$[x+=i+1]পরিবর্তে আমরা যদি ব্যবহার করি তবে আমরা আরও একটি বাইট সংরক্ষণ করতে পারি এবং ব্যবহারকারীর সিস্টেমে সম্পূর্ণরূপে অঙ্কগুলি সমন্বিত কোনও আদেশ নেই।

— GammaFunction
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.