2048 -র মতো অ্যারে শিফট


80

ধরুন আমরা একটি অ্যারেটি স্থানান্তরিত করতে চাই যেমন এটি 2048 গেমের মতো হয় : যদি আমাদের কাছে অ্যারেতে দুটি সমপর্যায়ের দুটি উপাদান থাকে তবে সেগুলি দ্বিগুণ মান উপাদানের সাথে মার্জ করুন। শিফটকে অবশ্যই একটি নতুন অ্যারে ফিরতে হবে, যেখানে প্রতিটি জোড়ের সমান উপাদানগুলির যোগফল তাদের যোগফলের সাথে প্রতিস্থাপিত হয় এবং জোড় ছেদ করা উচিত নয়। শিফটিংটি একবারে সঞ্চালিত হয়, সুতরাং ফলস্বরূপ মানগুলি আবার মার্জ করার দরকার নেই। লক্ষ্য করুন যে যদি আমাদের কাছে টানা 3 টি সমান উপাদান থাকে তবে আমাদের ডানদিকের যোগফলগুলি যোগ করতে হবে, উদাহরণস্বরূপ, [2, 2, 2]হওয়া উচিত , হওয়া উচিত [2, 4]নয় [4, 2]

কাজটি হ'ল সংক্ষিপ্ত ফাংশনটি লিখুন যা একটি অ্যারে নেয় এবং একটি স্থানান্তরিত অ্যারে প্রদান করে।

আপনি ধরে নিতে পারেন যে সমস্ত পূর্ণসংখ্যা কঠোরভাবে ইতিবাচক হবে।

উদাহরণ:

[] -> []
[2, 2, 4, 4] -> [4, 8]
[2, 2, 2, 4, 4, 8] -> [2, 4, 8, 8]
[2, 2, 2, 2] -> [4, 4]
[4, 4, 2, 8, 8, 2] -> [8, 2, 16, 2]
[1024, 1024, 512, 512, 256, 256] -> [2048, 1024, 512]
[3, 3, 3, 1, 1, 7, 5, 5, 5, 5] -> [3, 6, 2, 7, 10, 10]

আমি হ্রাস ব্যবহার করে সমাধানে খুব আগ্রহী :)


11
এটি খুব সুন্দর প্রথম চ্যালেঞ্জ। সাইটে স্বাগতম!
ডিজেএমসিএমহেম

1
ইনপুট অগত্যা বাছাই করা হয় না এবং সংখ্যা শূন্যের চেয়ে বেশি হয়, এটি কেবল সংখ্যার উপর একমাত্র নিষেধাজ্ঞা। আমি মনে করি যে স্ট্যান্ডার্ড ইন্ট 32 এর সীমানায় আমরা সবচেয়ে বড় মানটিকে ফিট করতে পারি। খালি অ্যারে ফলাফল হিসাবে খালি অ্যারে দেয়। অংশগ্রহনের জন্য ধন্যবাদ, এটি প্রশংসা করুন :)
গ্রিনওল্ফ

3
এখনও অস্পষ্ট হিসাবে ভোট দেওয়ার জন্য যারা ভোট দিচ্ছেন তাদের কাছে চ্যালেঞ্জটি মূলত এটিকে ফুটিয়ে তোলে
ব্যবহারকারী 2428118

1
@ টিটাস "লক্ষ্য করুন যে আমাদের যদি টানা 3 টি সমান উপাদান থাকে তবে আমাদের সঠিকতমগুলি যোগ করতে হবে, উদাহরণস্বরূপ, [2, 2, 2] [2, 4] হওয়া উচিত, [4, 2] নয়।"
মার্টিন ইন্ডার

1
খালি অ্যারে সংক্রান্ত রায় দুর্ভাগ্যজনক; এটি আমার নিজের উত্তর সহ কয়েকটি উত্তর অকার্যকর করেছে।
ডেনিস

উত্তর:



19

হাস্কেল, 47 57 50 বাইট

e#l|a:b<-l,e==a= -2*a:b|1<2=e:l
map abs.foldr(#)[]

ব্যবহার reduce(বা foldএটি হাস্কেল হিসাবে বলা হয়, এখানে একটি ডান ভাঁজ foldr)। ব্যবহারের উদাহরণ: map abs.foldr(#)[] $ [2,2,2,4,4,8]-> [2,4,8,8]

সম্পাদনা করুন: +10 বাইটগুলি এটিকে অরসোর্টড অ্যারেগুলির জন্যও কাজ করে তোলে। মার্জ করা সংখ্যাগুলি দ্বিতীয় সংযোজন রোধ করতে নেতিবাচক মান হিসাবে areোকানো হয়। তারা একটি ফাইনাল দ্বারা সংশোধন করা হয় map abs


নেতিবাচক সঙ্গে কৌশলটি সত্যিই দুর্দান্ত!
xnor

14

ব্রেন-ফ্লাক , 158 96 96

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

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

ব্যাখ্যা:

1 তালিকাটি বিপরীত করুন (সমস্ত জিনিস অন্য স্ট্যাকের দিকে নিয়ে যাওয়া, তবে এটি কোনও ব্যাপার নয়)

{({}<>)<>}<>
{        }   #keep moving numbers until you hit the 0s from an empty stack
 ({}<>)      #pop a number and push it on the other stack
       <>    #go back to the original stack
          <> #after everything has moved, switch stacks

2 যতক্ষণ না এই স্ট্যাকের কোনও কিছুই অবশিষ্ট না থাকে 3-6 পদক্ষেপ করুন:

{                                                                                         }

3 শীর্ষ দুটি উপাদান নকল করুন (2 3 -> 2 3 2 3)

(({}<>)<><(({})<<>({}<>)>)>)

(({}<>)<>                   #put the top number on the other stack and back on the very top
         <(({})             #put the next number on top after:
               <<>({}<>)>   #copying the original top number back to the first stack
                         )>)

4 উপরের একটি 1 রাখুন যদি শীর্ষ দুটি সমান হয় তবে একটি 0 অন্যথায় (উইকি থেকে)

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

5 যদি শীর্ষ দুটি সমান হয় (শীর্ষে শূন্য নয়) পরবর্তী দুটি যোগ করুন এবং ফলাফলটি চাপ দিন

{{}(<({}{})>)}{}
{            }   #skip this if there is a 0 on top
 {}              #pop the 1
   (<      >)    #push a 0 after:
     ({}{})      #pop 2 numbers, add them together and push them back on 
              {} #pop off the 0

6 শীর্ষ উপাদানটিকে অন্য স্ট্যাকে নিয়ে যান

({}<>)<>

7 অন্য স্ট্যাকের দিকে স্যুইচ করুন এবং প্রচ্ছন্নভাবে মুদ্রণ করুন

<>

pls ভাষার নামের পরে কমা যুক্ত করে, অন্যথায় এটি লিডারবোর্ড টাইকে ভেঙে দেয়: P
ASCII-

9

পিএইচপি, 116 বাইট

<?$r=[];for($c=count($a=$_GET[a]);$c-=$x;)array_unshift($r,(1+($x=$a[--$c]==$a[$c-1]))*$a[$c]);echo json_encode($r);

অথবা

<?$r=[];for($c=count($a=$_GET[a]);$c--;)$r[]=$a[$c]==$a[$c-1]?2*$a[$c--]:$a[$c];echo json_encode(array_reverse($r));

-4 বাইটস যদি আউটপুট একটি অ্যারে হতে পারে print_r 'json_encode` এর পরিবর্তে `

176 বাইটস এটি একটি রেজেক্স দিয়ে সমাধান করতে

echo preg_replace_callback("#(\d+)(,\\1)+#",function($m){if(($c=substr_count($m[0],$m[1]))%2)$r=$m[1];$r.=str_repeat(",".$m[1]*2,$c/2);return trim($r,",");},join(",",$_GET[a]));

1
ফলাফলটি সর্বদা সাজানো না হওয়ায় আপনি বাছাই করতে পারবেন না: [4, 4, 2, 8, 8, 2] -> [8, 2, 16, 2]
ক্রিপ্টো

@ ক্রাইপ্টো নতুন পরীক্ষার কেস যুক্ত করার পরে আপনি ঠিক আছেন। সাজানোর ব্যবহার ঠিক হওয়ার আগে
Jgrg Hülsermann

for($i=count($a=$argv);--$i;)$b[]=($a[$i]==$a[$i-1])?2*$a[$i--]:$a[$i];print_r(array_reverse($b));একই ধারণা তবে খাটো
ক্রিপ্টো

@ ক্রাইপ্টো আমি আউটপুট সম্পর্কে স্ট্রিং প্রতিনিধিত্ব বা অ্যারের হিসাবে নিশ্চিত নই। testcase জন্য []আমি প্রয়োজন $r=[];আপনার সাহায্যের জন্য ধন্যবাদ
Jörg Hülsermann

9

জিএনইউ সেড, 41 38 37

+1 -র জন্য +1 অন্তর্ভুক্ত
করে ডিজিটাল ট্রমা
-1 ধন্যবাদ -1 শৈশুমারকে ধন্যবাদ

:
s,(.*)(1+) \2\b,\1!\2\2!,
t
y,!, ,

ইনপুট এবং আউটপুট হ'ল অ্যানারিতে স্থান পৃথক স্ট্রিং ( এই sensকমত্যের ভিত্তিতে )।

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


y,!, ,1 বাইট সংরক্ষণ করতে ব্যবহার করুন ।
শৈশুমারা

@ সেশোমারা দুহ ... আমি কেন এটি ভাবিনি? ধন্যবাদ!
রিলে 22

8

রেটিনা , 32

\d+
$*
r`\b\1 (1+)\b
$1$1
1+
$.&

rলাইনে 3 ডান থেকে বামে রেজেক্স মিলটি সক্রিয় করে। এবং এর অর্থ হ'ল \1রেফারেন্সটি (1+)ক্যাপচারিং গ্রুপের আগে এটি উল্লেখ করা উচিত re

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


চমৎকার .. ম্যাচের জন্য ডান থেকে বাম বিকল্পটি বেশ কার্যকর! এটি। নেট রেজেক্স বা রেটিনা বৈশিষ্ট্যের অংশ?
দাদা

লাইনফিড-বিচ্ছেদকে ইনপুট ফর্ম্যাট হিসাবে ব্যবহার করে আমি কেবল ২ at- এ আমার পোস্ট করতে চলেছিলাম : retina.tryitonline.net/… প্রধান সঞ্চয়স্থানটি আসে এবং দ্বিতীয় প্রতিস্থাপন থেকে মুক্তি পাওয়ার জন্য লিখিত প্রতিরূপ ব্যবহার করে।
মার্টিন এেন্ডার

@ দাদা এটি একটি। নেট বৈশিষ্ট্য (এবং এটি স্বেচ্ছাসেবী দৈর্ঘ্যের চেহারাগুলি সক্ষম করতে হুডের নীচে ব্যবহৃত হয়)। রেটিনার এখনও কোনও অনন্য রেগেক্স বৈশিষ্ট্য নেই (যদিও এর কিছু অনন্য বিকল্প বৈশিষ্ট্য রয়েছে)।
মার্টিন এেন্ডার

1
@ মার্টিনএন্ডার ওকে ধন্যবাদ! । নেট রেগেক্স সত্যিই দুর্দান্ত! হিংসাত্মক পার্ল কোডার স্পট হয়েছে
দাদা

@ মার্টিনএন্ডার আমি আপনার সমাধানটি অন্য উত্তরটির নিশ্চয়তা দেওয়ার পক্ষে যথেষ্ট আলাদা
ডিজিটাল ট্রমা

8

পার্ল, 41 বাইট

এর জন্য +1 অন্তর্ভুক্ত -p

STDIN এ ইনপুট ক্রম দিন:

shift2048.pl <<< "2 2 2 4 4 8 2"

shift2048.pl:

#!/usr/bin/perl -p
s/.*\K\b(\d+) \1\b/2*$1.A/e&&redo;y/A//d

8

পাইথন, 61 বাইট

def f(l):b=l[-2:-1]==l[-1:];return l and f(l[:~b])+[l[-1]<<b]

বুলিয়ান bপরীক্ষা করে শেষ দুটি উপাদান ধসে পড়বে কিনা তা যাচাই করে পরীক্ষা করে যে দৈর্ঘ্য 1 বা 0 এর তালিকার জন্য সেগুলি নিরাপদ যে শেষ উপাদানটি যদি 1সমান বা 2অসম জন্য গুণকের সাথে যুক্ত হয়। এটি তালিকার পুনরাবৃত্তির ফলাফলের সাথে যুক্ত হয়েছে যে অনেকগুলি উপাদান শেষ হয়ে কেটেছে। ডেনিসকে 1 বাইটের জন্য ধন্যবাদ!


[l[-1]<<b]একটি বাইট সংরক্ষণ করে।
ডেনিস

l[-2:-1]is[l[-2]]
mbomb007

2
আমার 0 এবং 1 আকারের তালিকার জন্য এটি কাজ করা দরকার
xnor

7

পার্ল, 43 + 1 ( -p) = 44 বাইট

টন হসপেল ৪১ বাইট উত্তর নিয়ে এসেছিল , এটি পরীক্ষা করে দেখুন!

-4 টন হসপেলকে ধন্যবাদ!

সম্পাদনা : যোগ করা হয়েছে \b, এটি ছাড়া যেমন এটি ইনপুটটিতে ব্যর্থ হয়েছিল ঠিক তেমন 24 4ফলাফল যা ছিল 28

$_=reverse reverse=~s/(\b\d+) \1\b/$1*2/rge

-pপতাকা সহ চালান :

perl -pe '$_=reverse reverse=~s/(\b\d+) \1\b/$1*2/rge' <<< "2 2 2 4 4"


reverseদুবার ডান-ভাঁজ (ঠিক যেমন s/(\d+) \1/$1*2/geবাম-ভাঁজ 2 2 2হবে, তার 4 2পরিবর্তে হয়ে যাবে 2 4) ব্যবহার করার চেয়ে আমি আর কোনও উপায় দেখতে পাচ্ছি না । তাই 14 বাইট ধন্যবাদ হারিয়েছে reverse... তবুও আমি মনে করি যে আরও একটি (আরও ভাল) উপায় থাকতে হবে (এটি পরবর্তীতে পার্ল!), আপনি যদি এটি খুঁজে পান তবে আমাকে জানান!


reverse reverseকিছুটা লম্বা মনে হচ্ছে আমি পার্লের কোনও বিশেষজ্ঞ নই, তবে আপনি কী শর্টকাট বানাতে পারবেন এমন কোনও উপায় আছে reverse(যদি কিছুই না হয়, [আব] ব্যবহার করছেন eval)?
সাইয়েস

ভাল সেক্সিগার লক্ষ্য করুন আপনি কেবলমাত্র($_)
টন হসপেল

টনহোস্পেল ধন্যবাদ প্রকৃতপক্ষে, চেহারাটির reverseমতো দস্তাবেজটি reverseতর্ক ছাড়াই ডাকা যাবে না (ভাল উদাহরণগুলি দেখায় এটি হতে পারে, তবে কেবলমাত্র একটি প্রোটোটাইপ রয়েছে reverse LIST)), তাই আমি $_ডিফল্ট যুক্তি হিসাবে ভুলে গিয়েছিলাম ;)
দাদা

LISTখালি থাকতে পারে ...
টন হসপেল

@ টনহসপেল সত্যই, তবে সাধারণত যখন কোনও অপারেটর $_ডিফল্ট যুক্তি হিসাবে ব্যবহার করে, ডকটি কোনও পরামিতি (যেমন printবা lenght...) ছাড়াই একটি প্রোটোটাইপ নির্দিষ্ট করে । বা সম্ভবত এটি আমার একটি ভুল ধারণা impression
দাদা 11

7

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

f=a=>a.reduceRight((p,c)=>(t=p[0],p.splice(0,c==t,c==t?c+t:c),p),[])
    
console.log([
  [],
  [2, 2, 4, 4],
  [2, 2, 2, 4, 4, 8],
  [2, 2, 2, 2],
  [4, 4, 2, 8, 8, 2],
  [1024, 1024, 512, 512, 256, 256],
  [3, 3, 3, 1, 1, 7, 5, 5, 5, 5],
].map(f))


2
খারাপ নয়, তবে সম্পাদিত স্নিপেট অনুসারে: [1024, 1024, 512, 512, 256, 256]সমাধান হচ্ছে কি [2048, 512, 1024]না [2048, 1024, 512]...?
ওয়েলওয়েস্ট

7

পার্ল 5.10, 61 50 বাইট ( পতাকার জন্য 49 + 1)

টন হসপেলকে ধন্যবাদ11 বাইট সংরক্ষণের জন্য !

-aপতাকা সহ রেগেক্স মুক্ত সমাধান :

@a=($F[-1]-$b?$b:2*pop@F,@a)while$b=pop@F;say"@a"

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


চমৎকার বিকল্প পদ্ধতি। একটি করুণ অ্যারেগুলি প্রায়শই পার্লের স্ট্রিংগুলিতে হেরে যায়। তবুও, আপনি আপনার কোডটি @a=($F[-1]-$b?$b:2*pop@F,@a)while$b=pop@F;say"@a"(50 বাইট) গল্ফ করে কিছুটা কাছাকাছি যেতে পারেন
টন হসপেল

@ টনহসপেল সত্যই, আমি স্ট্রিং-ভিত্তিক সমাধানগুলি এড়াতে চাইছি (কেবল এটি দেখানোর জন্য যে পার্ল এর চেয়ে আরও বেশি কিছু করতে পারে!)। আমি যাই হোক জিততে খেলি না: গল্ফিং টিপসের জন্য ধন্যবাদ!
পল পিকার্ড

7

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

@ এল 4 এম 2 এর জন্য 1 বাইট সংরক্ষণ করা হয়েছে

নিরবচ্ছিন্ন অ্যারেগুলির জন্য এখন স্থির করা হয়েছে যে এটি স্পষ্ট করে দেওয়া হয়েছে যে এই জাতীয় ইনপুটগুলি প্রত্যাশিত।

f=(a,l=[],m)=>(x=a.pop())*!m-l?f(a,x).concat(l):x?f(a,2*x,1):[l]

console.log(f([2, 2, 4, 4]));
console.log(f([2, 2, 2, 4, 4, 8]));
console.log(f([2, 2, 2, 2]));
console.log(f([4, 2, 2]));


1
আপনি স্রেফ সম্পাদিত সম্পাদনার পরামর্শ দিতে
যাচ্ছিলাম

a=>(a.reverse()+'').replace(/(.),\1/g,(c,i)=>i*2).split`,`.reverse()?
l4m2

@ l4m2 এটি একক-অঙ্কের ইনপুটগুলির জন্য কাজ করে তবে এতে ব্যর্থ হবে [1024, 1024, 512, 512, 256, 256](আমি মনে করি এই পরীক্ষার কেসটি পরে যুক্ত করা যেতে পারে)।
আর্নল্ড

@ আরনাউল্ড আচ্ছা আপনারাও ব্যর্থ হন ...
l4m2

f=(a,l=[],m)=>(x=a.pop())*!m-l?f(a,x).concat(l):x?f(a,2*x,1):[l]?
l4m2

6

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

D¥__X¸«DgL*ê¥X¸«£vy2ôO})í˜

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

সাধারণ পদক্ষেপ

  1. ক্রমাগত উপাদানগুলি যেখানে পৃথক রয়েছে তা সন্ধান করতে বিয়োগ দ্বারা হ্রাস করুন
  2. ধারাবাহিক উপাদানগুলির দৈর্ঘ্য খুঁজতে সেই জায়গাগুলির সূচকগুলিতে বিয়োগফলকে হ্রাস করুন
  3. এই দৈর্ঘ্যের অংশগুলিতে ইনপুট বিভক্ত করুন
  4. জোড়ায় বিভক্ত অংশগুলি
  5. প্রতিটি জোড়া যোগ করুন
  6. প্রতিটি যোগফল বিপরীত
  7. 1-মাত্রিক তালিকায় ফ্ল্যাট করুন

5

গণিত, 53 বাইট

Join@@(Reverse[Plus@@@#~Partition~UpTo@2]&/@Split@#)&

ব্যাখ্যা

Split@#

অভিন্ন উপাদানগুলির রান নিয়ে গঠিত সাবলিস্টগুলিতে ইনপুটটি বিভক্ত করুন। অর্থাত্ {2, 2, 2, 4, 8, 8}হয়ে ওঠে {{2, 2, 2}, {4}, {8, 8}}

#~Partition~UpTo@2

প্রতিটি সাবলিস্টকে পার্টিশনের দৈর্ঘ্যে সর্বোচ্চ 2 অংশে ভাগ করুন ition অর্থাত্ {{2, 2, 2}, {4}, {8, 8}}হয়ে যায় {{{2, 2}, {2}}, {{4}}, {{8, 8}}}

Plus@@@

প্রতিটি পার্টিশন মোট। অর্থাত্ {{{2, 2}, {2}}, {{4}}, {{8, 8}}}হয়ে ওঠে {{4, 2}, {4}, {16}}

Reverse

ফলাফলগুলি বিপরীত করুন কারণ ম্যাথামেটিকার Partitionকমান্ড বাম থেকে ডানে চলে গেছে, তবে আমরা পার্টিশনগুলি অন্য দিক হতে চাই। অর্থাত্ {{4, 2}, {4}, {16}}হয়ে ওঠে {{2, 4}, {4}, {16}}

Join@@

ফলস ফ্ল্যাট করুন। অর্থাত্ {{2, 4}, {4}, {16}}হয়ে ওঠে {2, 4, 4, 16}


হাই জেএইচএম! উত্তরের জন্য ধন্যবাদ. আমি ম্যাথামেটিকাকে খুব ভাল করে বুঝতে পারি না, তাই আপনি কী চলছে তা সম্পর্কে কিছুটা ব্যাখ্যা যোগ করতে পারবেন?
isaacg

Plus@@@হয় Tr/@এবং আমি মনে করি আপনি প্রথম বন্ধনী এড়াতে পারবেন এবং Join@@আপনি যদি ##&@@ফলাফলের উপর ব্যবহার করেন তবে Reverse(যদিও এটি পরীক্ষা করা হয়নি)।
মার্টিন ইন্ডার

5

জাভা 7, 133 বাইট

Object f(java.util.ArrayList<Long>a){for(int i=a.size();i-->1;)if(a.get(i)==a.get(i-1)){a.remove(i--);a.set(i,a.get(i)*2);}return a;}

ইনপুট একটি অ্যারেলিস্ট, এবং এটি কেবল পিছনের দিকে লুপ করে, যেখানে প্রয়োজন সরিয়ে এবং দ্বিগুণ করে।

Object f(java.util.ArrayList<Long>a){
    for(int i=a.size();i-->1;)
        if(a.get(i)==a.get(i-1)){
            a.remove(i--);
            a.set(i,a.get(i)*2);
        }
    return a;
}

আপনি Long3 লাইনে রেফারেন্সের সাথে তুলনা করছেন ==। বিবেচনা করুন a.get(i)-a.get(i-1)==0
Jakob

4

পার্ল, 37 বাইট

জন্য +4 অন্তর্ভুক্ত -0n

এসটিডিআইএন-এ পৃথক লাইন হিসাবে ইনপুটটি চালান:

perl -M5.010 shift2048.pl
2
2
2
4
4
8
2
^D

shift2048.pl:

#!/usr/bin/perl -0n
s/\b(\d+
)(\1|)$//&&do$0|say$1+$2


4

পিএইচপি, 86 100 99 94 বাইট

for($r=[];$v=+($p=array_pop)($a=&$argv);)array_unshift($r,end($a)-$v?$v:2*$p($a));print_r($r);

পিএইচপি 7.0 প্রয়োজন; কমান্ড লাইন আর্গুমেন্ট থেকে মান গ্রহণ করে।

এটি দিয়ে চালান -nrবা অনলাইনে চেষ্টা করুন


2
[২, ২, ২] [২,৪] এর পরিবর্তে [৪,২] ফিরিয়ে দেয়
ক্রিপ্টো

for($r=[];$v=($p=array_pop)($a=&$_GET[a]);)array_unshift($r,end($a)-$v?$v:2*$p($a));print_r($r);1 বাইট সংক্ষিপ্ত
জার্গ হালসারম্যান

3

জুলিয়া 205 বাইট

t(x)=Val{x}
s(x)=t(x)()
f^::t(1)=f
^{y}(f,::t(y))=x->f(((f^s(y-1))(x)))
g()=[]
g{a}(::t(a))=[a]
g{a}(::t(a),B...)=[a;g(B...)]
g{a}(::t(a),::t(a),B...)=[2a;g(B...)]
K(A)=g(s.(A)...)
H(A)=(K^s(length(A)))(A)

বলা হচ্ছে ফাংশন H

যেমন H([1,2,2,4,8,2,])

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

  • t(a) মান (ক) উপস্থাপন করে একটি মান-প্রকার।
  • s(a) মান মানের উদাহরণ is
  • gএটি এমন একটি ফাংশন যা পার্থক্যের মানগুলিতে (মানের ধরণগুলি ব্যবহার করে) এবং এর পরামিতিগুলির সংখ্যা প্রেরণ করে। এবং এটি দুর্দান্ত
  • Kঠিক gতাই মোড়ানো

অতিরিক্ত শীতল অংশ:

f^::t(1)=f
^{y}(f,::t(y))=x->f(((f^s(y-1))(x)))

এটি ^অপারেটরকে ফাংশনে প্রয়োগ করতে সংজ্ঞায়িত করে । সুতরাং যে K^s(2)(X)হিসাবে একই K(K(X)) , যাতে Hশুধু কল করছে Kউপর Kবার একটি গুচ্ছ - যথেষ্ট বার অবশ্যই কোনো নেস্টেড ক্ষেত্রে সঙ্কুচিত করতে

এটি আরও অনেক খাটো করা যায়, তবে এই উপায়টি এত মজাদার।


3

পাওয়ারশেল ভি 2 +, 81 বাইট

param($n)($b=$n[$n.count..0]-join','-replace'(\d+),\1','($1*2)'|iex)[$b.count..0]

সুস্পষ্ট অ্যারে হিসাবে ইনপুট নেয় $n, এটিকে বিপরীতমুখী করে $n[$n.count..0], -joinকমা দিয়ে উপাদানগুলিকে একত্রিত করে, তারপরে -replaceপ্রথম উপাদান, ক *2এবং প্যারেন্সের চারপাশে ঘিরে অঙ্কের জুড়ি মেলাতে রেজিেক্স। যে পাইপগুলি ফলাফল দেয় (যা ইনপুটটির জন্য @(2,2,4,4)দেখতে ভাল হবে (4*2),(2*2)) এর উপর iex(সংক্ষিপ্ত Invoke-Expressionএবং এর অনুরূপ eval), যা গুণকে প্রকৃত সংখ্যায় রূপান্তর করে। ফলস্বরূপ অ্যারে এতে সঞ্চয় $bকরে, পাইপলাইনে এটি প্যারেন্সে রাখার জন্য এনপ্যাপুলেট করে, তারপরে বিপরীত $bহয় [$b.count..0]। পাইপলাইনে ফলাফলের উপাদানগুলি ফেলে দেয় এবং আউটপুট অন্তর্ভুক্ত থাকে।


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

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

PS C:\Tools\Scripts\golfing> @(),@(2,2,4,4),@(2,2,2,4,4,8),@(2,2,2,2),@(4,4,2,8,8,2),@(1024,1024,512,512,256,256),@(3,3,3,1,1,7,5,5,5,5)|%{"$_ --> "+(.\2048-like-array-shift.ps1 $_)}
Invoke-Expression : Cannot bind argument to parameter 'Command' because it is an empty string.
At C:\Tools\Scripts\golfing\2048-like-array-shift.ps1:7 char:67
+   param($n)($b=$n[$n.count..0]-join','-replace'(\d+),\1','($1*2)'|iex)[$b.count. ...
+                                                                   ~~~
    + CategoryInfo          : InvalidData: (:String) [Invoke-Expression], ParameterBindingValidationException
    + FullyQualifiedErrorId : ParameterArgumentValidationErrorEmptyStringNotAllowed,Microsoft.PowerShell.Commands.InvokeExpressionCommand

Cannot index into a null array.
At C:\Tools\Scripts\golfing\2048-like-array-shift.ps1:7 char:13
+   param($n)($b=$n[$n.count..0]-join','-replace'(\d+),\1','($1*2)'|iex)[$b.count. ...
+             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : InvalidOperation: (:) [], RuntimeException
    + FullyQualifiedErrorId : NullArray

 --> 
2 2 4 4 --> 4 8
2 2 2 4 4 8 --> 2 4 8 8
2 2 2 2 --> 4 4
4 4 2 8 8 2 --> 8 2 16 2
1024 1024 512 512 256 256 --> 2048 1024 512
3 3 3 1 1 7 5 5 5 5 --> 3 6 2 7 10 10

3

জাভাস্ক্রিপ্ট - 103 বাইট

v=a=>{l=a.length-1;for(i=0;i<l;i++)a[l-i]==a[l-1-i]?(a[l-i-1]=a[l-i]*2,a.splice(l-i,1)):a=a;return a}


এটি কাজ করে না। [2,2,4,4]ফলন দিয়ে পরীক্ষা করা হচ্ছে [2,2,4,4]
কনর ও'ব্রায়েন

1
হা. নোড ভি 6.2.1
কনর ও'ব্রায়ান

আমার খারাপ .. আমি এটি একই ফাইলে অন্য জেএস কোডের সাথে চালাচ্ছি এবং গ্লোবাল ভেরিয়েবলগুলি মিশ্রিত হয়েছে।
অ্যালেক্সিস_এ

3

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

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

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

ব্যাখ্যা:

{({}<>)<>}<>   Reverse stack

{   While input exists
  (
    ({}<>)   Push copy of last element to the other stack
    <>[({})] And subtract a copy of the next element
  )   Push the difference
  {   If the difference is not 0
    ((<{}>)) Push two zeroes
  }{}  Pop a zero
  {   If the next element is not zero, i.e the identical element
    ({}<>{})  Add the element to the copy of the previous element
    (<>)      Push a zero
  }{}    Pop the zero
}<>  End loop and switch to output stack


2

জুলিয়া, 73 82 বাইট

f(l)=l==[]?[]:foldr((x,y)->y[]==x?vcat(2x,y[2:end]):vcat(x,y),[l[end]],l[1:end-1])

পিছন থেকে সামনের দিকে তালিকাগুলি তৈরি করতে ডান ভাঁজ ব্যবহার করুন (শুরুতে এবং শেষে তালিকার বিপরীতে কোনওটি ব্যবহার করতে পারেন)।

বর্তমান তালিকার শীর্ষস্থানীয় যদি পূর্বের উপাদানটি পুনরায় চাপানোর জন্য সমান না হয়, তবে কেবল এটি প্রেন্ডিং করুন।

অন্যথায় তালিকার মাথাটি মুছে ফেলুন (একধরনের নির্মম শোনায়) এবং উপাদানটির সময় 2 বার প্রিন্ট করুন।

উদাহরণ

f([3,3,3,1,1,7,5,5,5,5]) 
returns a new list:
[3,6,2,7,10,10]

2

র‌্যাকেট 166 বাইট

(λ(l)(let g((l(reverse l))(o '()))(cond[(null? l)o][(=(length l)1)(cons(car l)o)]
[(=(car l)(second l))(g(drop l 2)(cons(* 2(car l))o))][(g(cdr l)(cons(car l)o))])))

Ungolfed:

(define f
  (λ (lst)
    (let loop ((lst (reverse lst)) 
               (nl '()))
      (cond                            ; conditions: 
        [(null? lst)                   ; original list empty, return new list;
               nl]
        [(= (length lst) 1)            ; single item left, add it to new list
              (cons (first lst) nl)]
        [(= (first lst) (second lst))  ; first & second items equal, add double to new list
              (loop (drop lst 2) 
                    (cons (* 2 (first lst)) nl))]
        [else                          ; else just move first item to new list
              (loop (drop lst 1) 
                    (cons (first lst) nl))]  
        ))))

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

(f '[])
(f '[2 2 4 4]) 
(f '[2 2 2 4 4 8]) 
(f '[2 2 2 2]) 
(f '[4 4 2 8 8 2])
(f '[1024 1024 512 512 256 256]) 
(f '[3 3 3 1 1 7 5 5 5 5])
(f '[3 3 3 1 1 7 5 5 5 5 5])

আউটপুট:

'()
'(4 8)
'(2 4 8 8)
'(4 4)
'(8 2 16 2)
'(2048 1024 512)
'(3 6 2 7 10 10)
'(3 6 2 7 5 10 10)

1

জাপট , 12 বাইট

ò¦ ®ò2n)mxÃc

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

আনপ্যাকড এবং কীভাবে এটি কাজ করে

Uò!= mZ{Zò2n)mx} c

Uò!=    Partition the input array where two adjacent values are different
        i.e. Split into arrays of equal values
mZ{     Map the following function...
Zò2n)     Split into arrays of length 2, counting from the end
          e.g. [2,2,2,2,2] => [[2], [2,2], [2,2]]
mx        Map `Array.sum` over it
}
c       Flatten the result

জোনাথন অ্যালানের জেলি সমাধান থেকে কিছু ধারণা পেয়েছেন ।


0

গণিত, 51 বাইট

Abs[#//.{Longest@a___,x_/;x>0,x_,b___}:>{a,-2x,b}]&

{Longest@a___,x_/;x>0,x_,b___}পরপর দুটি অভিন্ন ধনাত্মক সংখ্যাযুক্ত একটি তালিকার সাথে মেলে এবং এই দুটি সংখ্যাকে রূপান্তর করে -2xLongestম্যাচগুলি যতটা সম্ভব দেরি করতে বাধ্য করে।

প্রক্রিয়াটি ধাপে ধাপে চিত্রিত করা হয়:

   {3, 3, 3, 1, 1, 7, 5, 5, 5, 5}
-> {3, 3, 3, 1, 1, 7, 5, 5, -10}
-> {3, 3, 3, 1, 1, 7, -10, -10}
-> {3, 3, 3, -2, 7, -10, -10}
-> {3, -6, -2, 7, -10, -10}
-> {3, 6, 2, 7, 10, 10}

0

Vim, 28 বাইট

G@='?\v(\d+)\n\1<C-@>DJ@"<C-A>-@=<C-@>'<CR>

একটি ম্যাক্রো যা রেজেক্স পরপর সংখ্যার সাথে মিলে পিছনে অনুসন্ধান করে এবং তাদের একসাথে যুক্ত করে।

ইনপুট অ্যারে প্রতি লাইনে এক নম্বর হওয়া দরকার। এই ফর্ম্যাটটি আমাকে স্ট্রোকগুলি বাঁচায়, যা দুর্দান্ত, তবে আসল কারণ হ'ল ওভারল্যাপিং রেজেক্স ম্যাচগুলি ঘিরে কাজ করা। স্ট্রিংটি দেওয়া হয়েছে 222, যদি আপনি /22কেবল প্রথম জুটি মেলে তবে ওভারল্যাপিং দ্বিতীয় জোড়াটি নয়। দুটি জোড় বিভিন্ন লাইনে শুরু হলে ওভারল্যাপের নিয়মগুলি আলাদা। এই চ্যালেঞ্জটি [2, 2, 2]হয়ে ওঠে [2, 4], সুতরাং ওভারল্যাপিং জুটির সাথে মিল পাওয়া সমালোচনা।

দ্রষ্টব্য: চ্যালেঞ্জটি কেবল একটি একক পাসের জন্য জিজ্ঞাসা করেছে। যে কারণে, আপনার প্রয়োজন :set nowrapscan। এর সাথে :set wrapscanআমি এমন একটি সংস্করণ তৈরি করতে পারি যা একাধিক পাসে কাজ শেষ করে, যদিও লিখিত হিসাবে এই সমাধানটি সবসময় তা করে না।

  • <C-@>: সাধারণত, একটি কমান্ড লাইনে, কমান্ডটি <CR>না চালিয়ে আক্ষরিক টাইপ করার জন্য আপনাকে এড়িয়ে যেতে হবে<C-V> । তবে আপনি <C-@>অনস্কেপড টাইপ করতে পারেন এবং এটি একটি <C-J>/ হিসাবে গণ্য হবে <NL>, <CR>আপনি ম্যাক্রো চালানোর সময় যেমন হবে তবে আপনি টাইপ করার সময় নয়। পড়ার চেষ্টা করুন :help NL-used-for-Nul
  • @=: আমি সহজেই এই সময় রেকর্ড করা ম্যাক্রো ব্যবহার করতে পারছি না কারণ ইনপুটটির কোনও মিলের জুড়ি না থাকার সম্ভাবনা রয়েছে। যদি ম্যাক্রো চালানোর সময় এটি ঘটে থাকে তবে ব্যর্থ অনুসন্ধান ম্যাক্রোকে ব্যর্থ করবে। তবে এটি যদি (অন্তর্ভুক্ত প্রথম) রেকর্ডিং পাসের সময় ঘটে থাকে, তবে সাধারণ মোডের বাকি কমান্ডগুলি চলবে, ফাইলটির ক্ষতি করে। খারাপ দিকটি @=হ'ল আমি পুনরাবৃত্তির কলটিতে একটি বাইট হারিয়েছি; কখনও কখনও আপনি @@একটি পুনরাবৃত্ত কল হিসাবে ব্যবহার করতে পারেন , তবে এটি @"এই ক্ষেত্রে 4 বাইট থেকে চালানো হবে ।
  • DJ@"<C-A>-: DJলাইনটি মোছা করে এবং একটি রেজিস্টারে নম্বর (কোনও নতুন লাইন নেই) রাখে, তাই আমি এটিতে একটি সংখ্যা যুক্তির জন্য ম্যাক্রো হিসাবে চালাতে পারি <C-A>। আমাকে করতে হবে -পরে তাই আমি মত ক্ষেত্রে একটি দ্বিতীয় ম্যাচ পাবেন না [4, 2, 2]

0

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

{my @b;loop ($_=@^a-1;$_>=0;--$_) {@b.unshift($_&&@a[$_]==@a[$_-1]??2*@a[$_--]!!@a[$_])};@b}

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