পনির ষোলটি গাদা 4x4 স্কোয়ারে রাখা হয়। এগুলি থেকে লেবেলযুক্ত । সবচেয়ে ছোট গাদা এবং বৃহত্তমটি । $1$ $16$ $1$ $16$

হাংরি মাউস এত ক্ষুধার্ত যে এটি সর্বদা সরাসরি বৃহত্তম স্তূপের কাছে যায় (অর্থাত্ ) এবং এখনই এটি খায়। $16$

এর পরে, এটি সবচেয়ে বড় প্রতিবেশী স্তূপে যায় এবং দ্রুত সেইটিকে খায়। (হ্যাঁ ... এটি সত্যিই ক্ষুধার্ত।) এবং এরপরে আর কোনও প্রতিবেশী গাদা নেই until

একটি গাদা 8 টি প্রতিবেশী (অনুভূমিকভাবে, উল্লম্ব এবং ত্রিভুজযুক্ত) থাকতে পারে। চারপাশে কোনও মোড়ানো নেই।

উদাহরণ

আমরা নিম্নলিখিত গাদা পনির দিয়ে শুরু করি:

\begin{matrix} 3 & 7 & 10 & 5 \\ 6 & 8 & 12 & 13 \\ 15 & 9 & 11 & 4 \\ 14 & 1 & 16 & 2 \end{matrix}

$\begin{matrix} 3&7&10&5\\ 6&8&12&13\\ 15&9&11&4\\ 14&1&16&2 \end{matrix}$

হাংরি মাউস প্রথমে খায় এবং তারপরে এর বৃহত্তম প্রতিবেশী গাদা, যা । $16$ $11$

\begin{matrix} 3 & 7 & 10 & 5 \\ 6 & 8 & 12 & 13 \\ 15 & 9 & 🐭 & 4 \\ 14 & 1 & ↑ & 2 \end{matrix}

$\begin{matrix} 3&7&10&5\\ 6&8&12&13\\ 15&9&🐭&4\\ 14&1&\color{grey}\uparrow&2 \end{matrix}$

এর পরবর্তী পদক্ষেপগুলি , , , , , , , , এবং এই সঠিক ক্রমে। $13$ $12$ $10$ $8$ $15$ $14$ $9$ $6$ $7$ $3$

\begin{matrix} 🐭 & \leftarrow & ↙ & 5 \\ ↗ & ↙ & ↑ & \leftarrow \\ ↓ & ↖ & ↗ & 4 \\ ↗ & 1 & ↑ & 2 \end{matrix}

$\begin{matrix} 🐭&\color{grey}\leftarrow&\small\color{grey}\swarrow&5\\ \small\color{grey}\nearrow&\small\color{grey}\swarrow&\color{grey}\uparrow&\color{grey}\leftarrow\\ \color{grey}\downarrow&\small\color{grey}\nwarrow&\small\color{grey}\nearrow&4\\ \small\color{grey}\nearrow&1&\color{grey}\uparrow&2 \end{matrix}$

হাংরি মাউসের চারপাশে আর কোনও পনির নেই, তাই এটি সেখানেই থামে।

চ্যালেঞ্জ

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

উপরের উদাহরণের জন্য, প্রত্যাশিত উত্তরটি । $12$

বিধি

ইনপুট ম্যাট্রিক্সের আকার স্থির হওয়ায় আপনি এটি 2D অ্যারে বা এক-মাত্রিক অ্যারে হিসাবে নিতে পারেন।
থেকে প্রতিটি মান হ'ল একবারে উপস্থিত হওয়ার গ্যারান্টিযুক্ত। $1$ $16$
এটি কোড-গল্ফ ।

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

[ [ 4,  3,  2,  1], [ 5,  6,  7,  8], [12, 11, 10,  9], [13, 14, 15, 16] ] --> 0
[ [ 8,  1,  9, 14], [11,  6,  5, 16], [13, 15,  2,  7], [10,  3, 12,  4] ] --> 0
[ [ 1,  2,  3,  4], [ 5,  6,  7,  8], [ 9, 10, 11, 12], [13, 14, 15, 16] ] --> 1
[ [10, 15, 14, 11], [ 9,  3,  1,  7], [13,  5, 12,  6], [ 2,  8,  4, 16] ] --> 3
[ [ 3,  7, 10,  5], [ 6,  8, 12, 13], [15,  9, 11,  4], [14,  1, 16,  2] ] --> 12
[ [ 8,  9,  3,  6], [13, 11,  7, 15], [12, 10, 16,  2], [ 4, 14,  1,  5] ] --> 34
[ [ 8, 11, 12,  9], [14,  5, 10, 16], [ 7,  3,  1,  6], [13,  4,  2, 15] ] --> 51
[ [13, 14,  1,  2], [16, 15,  3,  4], [ 5,  6,  7,  8], [ 9, 10, 11, 12] ] --> 78
[ [ 9, 10, 11, 12], [ 1,  2,  4, 13], [ 7,  8,  5, 14], [ 3, 16,  6, 15] ] --> 102
[ [ 9, 10, 11, 12], [ 1,  2,  7, 13], [ 6, 16,  4, 14], [ 3,  8,  5, 15] ] --> 103

code-golf matrix

— Arnauld
সূত্র

32

মাউস চরিত্রটির জন্য +1

— লুইস মেন্ডো

2

... এটি 103 করুন:[[9, 10, 11, 12], [1, 2, 7, 13], [6, 16, 4, 14], [3, 8, 5, 15]]

— জোনাথন অ্যালান

9

কী চমৎকার লেখা চ্যালেঞ্জ! আমি সেরা মনোনয়নের জন্য এটি মাথায় রাখব।

— xnor

9

ভুল লেখার পরে আমি কিছুটা দুঃখ পেয়েছিলাম যে এটি কোনও ক্ষুধার্ত মুজ নয়।

— আকোজি

1

এই চ্যালেঞ্জটি আমাকে টেক্সো কম্পিউটারের জন্য ম্যাজ প্রোগ্রামে মাউসের স্মরণ করিয়ে দেয়। এই গেমটি ১৯৫০ এর দশকে ফিরে লেখা হয়েছিল এবং কিংবদন্তি অনুসারে টেক্সোটি বিশ্বের প্রথম ট্রানজিস্টরাইজড কম্পিউটার ছিল। হ্যাঁ, বিশ্বাস করুন বা না করুন, আপনার দাদার দিনে কেউ ভিডিও গেম লিখছিল।

— ওয়াল্টার মিট্টি

11

পাইথন 2 , ₁₃₃ 130 বাইট

a=input();m=16
for i in range(m):a[i*5:i*5]=0,
while m:i=a.index(m);a[i]=0;m=max(a[i+x]for x in[-6,-5,-4,-1,1,4,5,6])
print sum(a)

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

16 টি উপাদানের একটি সমতল তালিকা নেয়।

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

a=input();m=16

# Add zero padding on each row, and enough zeroes at the end to avoid index error
for i in range(m):a[i*5:i*5]=0,

# m == maximum element found in last iteration
# i == index of last eaten element
# eaten elements of `a` are reset to 0
while m:i=a.index(m);a[i]=0;m=max(a[i+x]for x in[-6,-5,-4,-1,1,4,5,6])
print sum(a)

— Bubbler
সূত্র

সংলগ্ন-সেল এক্সপ্রেশনটি a[i+x]for x in[-6,-5,-4,-1,1,4,5,6]ছোট করা যেতে পারে a[i+j+j/3*2-6]for j in range(9)(শূন্য এন্ট্রি ক্ষতিগ্রস্থ নয়)। পাইথন 3 অবশ্যই দৈর্ঘ্য -8 বাইস্টেরিংয়ের হার্ডকডিং দ্বারা ছোট করতে পারে তবে পাইথন 2 এখনও সামগ্রিকভাবে আরও ভাল হতে পারে।

— xnor

1

যদিও আপনার শূন্য প্যাডিং লুপ চালাক, এটা দেখে মনে হচ্ছে এটা খাটো একটি 2 ডি তালিকা নেওয়া: a=[0]*5 for r in input():a=r+[0]+a। সম্ভবত একটি আরও ছোট স্ট্রিং স্লাইসিং সমাধান রয়েছে যার পুনরাবৃত্তি প্রয়োজন হয় না।

— xnor

8

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

i=x=a=input()
while x:x,i=max((y,j)for j,y in enumerate(a)if i>[]or 2>i/4-j/4>-2<i%4-j%4<2);a[i]=0
print sum(a)

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

বুবলার থেকে অভিযোজিত পদ্ধতি এবং পরীক্ষার কেসগুলি । STDIN এ ফ্ল্যাট তালিকা নেয় T

কোডটি দুটি সমতল সূচকগুলি কিনা স্পর্শ করে iএবং jস্পর্শকোষের কোষকে প্রতিনিধিত্ব করে কিনা তা পরীক্ষা করে দেখায় যে সারি পৃথক i/4-j/4এবং কলামের পার্থক্য উভয়ই i%4-j%4-২ এবং ২ এর মধ্যে রয়েছে The

— xnor
সূত্র

8

এমএটিএল , 50 49 47 বাইট

16:HZ^!"2G@m1ZIm~]v16eXK68E16b"Ky0)Y)fyX-X>h]s-

ইনপুট একটি ম্যাট্রিক্স, ;সারি বিভাজক হিসাবে ব্যবহার করে ।

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

ব্যাখ্যা

16:HZ^!  % Cartesian power of [1 2 ... 16] with exponent 2, transpose. Gives a 
         % 2-row matrix with 1st column [1; 1], 2nd [1; 2], ..., last [16; 16] 
"        % For each column, say [k; j]
  2      %   Push 2
  G@m    %   Push input matrix, then current column [k; j], then check membership.
         %   This gives a 4×4 matrix that contains 1 for entries of the input that
         %   contain k or j 
  1ZI    %   Connected components (based on 8-neighbourhood) of nonzero entries.
         %   This gives a 4×4 matrix with each connected component labeled with
         %   values 1, 2, ... respectively
  m~     %   True if 2 is not present in this matrix. That means there is only
         %   one connected component; that is, k and j are neighbours in the
         %   input matrix, or k=j
]        % End
v16e     % The stack now has 256 values. Concatenate them into a vector and
         % reshape as a 16×16 matrix. This matrix describes neighbourhood: entry 
         % (k,j) is 1 if values k and j are neighbours in the input or if k=j
XK       % Copy into clipboard K
68E      % Push 68 times 2, that is, 136, which is 1+2+...+16
16       % Push 16. This is the initial value eaten by the mouse. New values will
         % be appended to create a vector of eaten values
b        % Bubble up the 16×16 matrix to the top of the stack
"        % For each column. This just executes the loop 16 times
  K      %   Push neighbourhood matrix from clipboard K
  y      %   Copy from below: pushes a copy of the vector of eaten values
  0)     %   Get last value. This is the most recent eaten value
  Y)     %   Get that row of the neighbourhood matrix
  f      %   Indices of nonzeros. This gives a vector of neighbours of the last
         %   eaten value
  y      %   Copy from below: pushes a copy of the vector of eaten values
  X-     %   Set difference (may give an empty result)
  X>     %   Maximum value. This is the new eaten value (maximum neighbour not
         %   already eaten). May be empty, if all neighbours are already eaten
  h      %   Concatenate to vector of eaten values
]        % End
s        % Sum of vector of all eaten values
-        % Subtract from 136. Implicitly display

— লুইস মেন্ডো
সূত্র

ইড্ক ম্যাটল্যাব, তবে আপনি +136 এর পরিবর্তে -136 চাপলে আপনি কি একটু সঞ্চয় করতে পারবেন?

— টাইটাস

@ টিটাস এইচএম আমি কীভাবে তা দেখছি না

— লুইস মেন্ডো

বা অন্য পথে: আমি ভেবেছিলাম 1 এর পরিবর্তে 136 2 চাপুন) প্রতিটি খাওয়া মান 3 চাপুন 3) খাওয়া মানগুলি যোগ করুন 4) 136 থেকে বিয়োগ করুন -> 1) 136 2 চাপুন) খাওয়া মানের নেতিবাচক ধাক্কা 3) যোগফলের স্ট্যাক। তবে এটি স্পষ্টতই প্রতিটি বাইট প্রতিটি; এটা সম্ভবত কোন লাভ।

— টাইটাস

@ টিটাস আহ, হ্যাঁ, আমি মনে করি এটি একই সংখ্যক বাইট ব্যবহার করে। এছাড়াও, সেট পার্থক্যের জন্য আমার প্রতিটি খাওয়া মান (এটির নেতিবাচক নয়) প্রয়োজন; অবহেলা শেষে করতে হবে

— লুইস মেন্ডো

6

পিএইচপি, 177 174 171 বাইট

for($v=16;$v;$u+=$v=max($p%4-1?max($a[$p-5],$a[$p-1],$a[$p+3]):0,$a[$p-4],$a[$p+4],$p%4?max($a[$p-3],$a[$p+1],$a[$p+5]):0))$a[$p=array_search($v,$a=&$argv)]=0;echo 120-$u;

সাথে চালান -nr, আর্গুমেন্ট হিসাবে ম্যাট্রিক্স উপাদান সরবরাহ করুন বা এটি অনলাইনে চেষ্টা করুন ।

— তিতাস
সূত্র

5

জাভাস্ক্রিপ্ট, 122 বাইট

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

a=>(g=n=>n?g([-6,-5,-4,-1,1,4,5,6].map(x=>n=a[x+=i]>n?a[x]:n,a[i=a.indexOf(n)]=n=0)|n)-n:120)(16,a=a.flatMap(x=>[...x,0]))

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

— রোমশ
সূত্র

3

+1 এর জন্য flatMap(): পি

— অ্যারনল্ড

: ডিআই মনে হয় আমি এই প্রথম এটি গল্ফের জন্য ব্যবহার করেছি! আগ্রহের বাইরে (এবং আমি এটিতে ফিরে এসে আমাকে একটি লক্ষ্য দেওয়ার জন্য), আপনি যখন চেষ্টা করেছিলেন তখন আপনার স্কোরটি কী ছিল?

— শেগি

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

— শেগি

আমি আমার সমাধান পোস্ট করেছি।

— আর্নল্ড

5

আর , 128 124 123 112 110 বাইট

function(r){r=rbind(0,cbind(0,r,0),0)
m=r>15
while(r[m]){r[m]=0
m=r==max(r[which(m)+c(7:5,1)%o%-1:1])}
sum(r)}

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

এটি একটি 4x4 ম্যাট্রিক্স তৈরি করে (যা আমাকে জিনিসগুলিকে কল্পনা করতে সহায়তা করেছিল), 0 এর সাথে প্যাড করে, তারপরে 16 থেকে শুরু হয় এবং এর পরের বৃহত্তম "পাইলস" এর আশেপাশে অনুসন্ধান করে এবং আরও অনেক কিছু।

উপসংহারে, এটি একটি সতর্কবার্তা আউটপুট দেয়, তবে এটি কোনও ফলাফলের নয় এবং ফলাফলটি পরিবর্তন করে না।

সম্পাদনা: ম্যাট্রিক্সের সূচনাটি 1 লাইনে সংকুচিত করে -4 বাইটস।

সম্পাদনা: -১ রবার্ট হ্যাকেনকে ধন্যবাদ

সম্পাদনা: -১13 বাইটস জিউসেপ এবং রবিন রাইডারের পরামর্শগুলির সংমিশ্রণে।

— Sumner18
সূত্র

আপনি এক বাইট পরিবর্তন সংরক্ষণ করতে পারবেন r==16জন্য r>15।

— রবার্ট হ্যাকেন

1

117 বাইট - ম্যাট্রিক্স গ্রহণ করে এটি একটি ফাংশনে পরিবর্তন করুন এবং এর সাথে কিছু এলিয়াসিং করুন which।

— জিউসেপ

2

@ জিউসেপের পরামর্শ অনুযায়ী 112 বাইটস উন্নতি করছে: আপনি mএকটি পূর্ণসংখ্যার পরিবর্তে লজিকাল হিসাবে সঞ্চয় করতে পারেন , এবং কেবলমাত্র whichদুবারের পরিবর্তে একবার কল করতে হবে ।

— রবিন রাইডার

১১০ বাইট @ রবিনরাইডারের গল্ফ ব্যবহার করে এবং পার্শ্ববর্তী সংলগ্ন ম্যাট্রিক্সকে সংকুচিত করার সাথে জগাখিচুড়ি।

— জিউসেপ

1

@ Sumner18 X%o%Yএর একটি উপনাম outer(X,Y,'*')। outerএটি চারপাশের অন্যতম হস্তশালী কাজ কারণ এটি অ্যারাব্রাট্রি (ভেক্টরাইজড) অপারেটরগুলির সাথে অক্টোভ / এমএটিএলবি / এমএটিএল এর "সম্প্রচার" বৈশিষ্ট্য হিসাবে কাজ করতে পারে। এখানে দেখুন ; বিরল অনুষ্ঠানগুলিতেও কার্যকর kroneckerযা সেই পৃষ্ঠায় লিঙ্কযুক্ত।

— জিউসেপ

4

কাঠকয়লা , 47 বাইট

ＥＡ⭆ι§αλ≔QθＷ›θA«≔⌕ＫＡθθＪ﹪θ⁴÷θ⁴≔⌈ＫＭθA»≔ΣＥＫＡ⌕αιθ⎚Ｉθ

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

ＥＡ⭆ι§αλ

ইনপুট সংখ্যাগুলিকে বর্ণমালার অক্ষরে রূপান্তর করুন (A = 0 .. Q = 16) এবং তাদের 4x4 গ্রিড হিসাবে মুদ্রণ করুন।

≔Qθ

Q, অর্থাৎ 16 খাওয়ার মাধ্যমে শুরু করুন।

Ｗ›θA«

কিছু খাওয়ার সময় পুনরাবৃত্তি করুন।

≔⌕ＫＡθθ

গাদা কোথায় আছে তা সন্ধান করুন। এটি সারি-প্রধান ক্রমে একটি রৈখিক দর্শন।

Ｊ﹪θ⁴÷θ⁴

কো-অর্ডিনেটে রূপান্তর করুন এবং সেই জায়গায় চলে যান।

≔⌈ＫＭθ

বৃহত্তম সংলগ্ন গাদা খুঁজে নিন।

A»

বর্তমান গাদা খাওয়া।

≔ΣＥＫＡ⌕αιθ

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

⎚Ｉθ

ক্যানভাস সাফ করুন এবং ফলাফলটি আউটপুট করুন।

— নিল
সূত্র

3

পাওয়ারশেল, 143 141 136 130 122 121 বাইট

$a=,0*5+($args|%{$_+0})
for($n=16;$i=$a.IndexOf($n)){$a[$i]=0
$n=(-1,1+-6..-4+4..6|%{$a[$i+$_]}|sort)[-1]}$a|%{$s+=$_}
$s

কম গল্ফ পরীক্ষা স্ক্রিপ্ট:

$f = {

$a=,0*5+($args|%{$_+0})
for($n=16;$i=$a.IndexOf($n)){
    $a[$i]=0
    $n=(-1,1+-6..-4+4..6|%{$a[$i+$_]}|sort)[-1]
}
$a|%{$s+=$_}
$s

}

@(
    ,( 0  , ( 4,  3,  2,  1), ( 5,  6,  7,  8), (12, 11, 10,  9), (13, 14, 15, 16) )
    ,( 0  , ( 8,  1,  9, 14), (11,  6,  5, 16), (13, 15,  2,  7), (10,  3, 12,  4) )
    ,( 1  , ( 1,  2,  3,  4), ( 5,  6,  7,  8), ( 9, 10, 11, 12), (13, 14, 15, 16) )
    ,( 3  , (10, 15, 14, 11), ( 9,  3,  1,  7), (13,  5, 12,  6), ( 2,  8,  4, 16) )
    ,( 12 , ( 3,  7, 10,  5), ( 6,  8, 12, 13), (15,  9, 11,  4), (14,  1, 16,  2) )
    ,( 34 , ( 8,  9,  3,  6), (13, 11,  7, 15), (12, 10, 16,  2), ( 4, 14,  1,  5) )
    ,( 51 , ( 8, 11, 12,  9), (14,  5, 10, 16), ( 7,  3,  1,  6), (13,  4,  2, 15) )
    ,( 78 , (13, 14,  1,  2), (16, 15,  3,  4), ( 5,  6,  7,  8), ( 9, 10, 11, 12) )
    ,( 102, ( 9, 10, 11, 12), ( 1,  2,  4, 13), ( 7,  8,  5, 14), ( 3, 16,  6, 15) )
    ,( 103, ( 9, 10, 11, 12), ( 1,  2,  7, 13), ( 6, 16,  4, 14), ( 3,  8,  5, 15) )
) | % {
    $expected, $a = $_
    $result = &$f @a
    "$($result-eq$expected): $result"
}

আউটপুট:

True: 0
True: 0
True: 1
True: 3
True: 12
True: 34
True: 51
True: 78
True: 102
True: 103

ব্যাখ্যা:

প্রথমে 0 এর শীর্ষ এবং নীচের সীমানা যুক্ত করুন এবং একটি একক মাত্রিক অ্যারে করুন:

0 0 0 0 0
# # # # 0
# # # # 0
# # # # 0
# # # # 0

     ↓

0 0 0 0 0 # # # # 0 # # # # 0 # # # # 0 # # # # 0

$nullআপনি অ্যারের শেষের পিছনে মান পাওয়ার চেষ্টা করলে পাওয়ারশেল ফিরে আসে ।

দ্বিতীয়ত , লুপটি biggest neighbor pile16 থেকে অ-শূন্য-সর্বাধিক থেকে শুরু হয়েছিল। এবং এটিকে বাতিল করুন (হাংরি মাউস এটি খায়)।

for($n=16;$i=$a.IndexOf($n)){
    $a[$i]=0
    $n=(-1,1+-6..-4+4..6|%{$a[$i+$_]}|sort)[-1]
}

তৃতীয়ত , অবশিষ্ট পাইলগুলির সমষ্টি।

— mazzy
সূত্র

3

এসএএস, 236 219 বাইট

পাঞ্চ কার্ডগুলিতে ইনপুট, গ্রিড প্রতি এক লাইন (স্পেস-বিভাজিত), লগতে মুদ্রিত আউটপুট।

এই চ্যালেঞ্জটি এসএএসের অ্যারেগুলির সীমাবদ্ধতার দ্বারা কিছুটা জটিল:

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

আপডেট:

সরানো infile cards;বিবৃতি (-13)
(-4) এর a:চেয়ে অ্যারে সংজ্ঞায়নের জন্য ওয়াইল্ডকার্ড ব্যবহৃত হয়েছেa1-a16

Golfed:

data;input a1-a16;array a[4,4]a:;p=16;t=136;do while(p);m=whichn(p,of a:);t=t-p;j=mod(m-1,4)+1;i=ceil(m/4);a[i,j]=0;p=0;do k=max(1,i-1)to min(i+1,4);do l=max(1,j-1)to min(j+1,4);p=max(p,a[k,l]);end;end;end;put t;cards;
    <insert punch cards here>
    ;

Ungolfed:

data;                /*Produce a dataset using automatic naming*/
input a1-a16;        /*Read 16 variables*/
array a[4,4] a:;     /*Assign to a 4x4 array*/
p=16;                /*Initial pile to look for*/
t=136;               /*Total cheese to decrement*/
do while(p);         /*Stop if there are no piles available with size > 0*/
  m=whichn(p,of a:); /*Find array element containing current pile size*/
  t=t-p;             /*Decrement total cheese*/
  j=mod(m-1,4)+1;    /*Get column number*/
  i=ceil(m/4);       /*Get row number*/
  a[i,j]=0;          /*Eat the current pile*/
                     /*Find the size of the largest adjacent pile*/
  p=0;
  do k=max(1,i-1)to min(i+1,4);
    do l=max(1,j-1)to min(j+1,4);
      p=max(p,a[k,l]);
    end;
  end;
end;
put t;              /*Print total remaining cheese to log*/
                    /*Start of punch card input*/
cards; 
  4  3  2  1  5  6  7  8 12 11 10  9 13 14 15 16 
  8  1  9 14 11  6  5 16 13 15  2  7 10  3 12  4 
  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 
 10 15 14 11  9  3  1  7 13  5 12  6  2  8  4 16 
  3  7 10  5  6  8 12 13 15  9 11  4 14  1 16  2 
  8  9  3  6 13 11  7 15 12 10 16  2  4 14  1  5 
  8 11 12  9 14  5 10 16  7  3  1  6 13  4  2 15 
 13 14  1  2 16 15  3  4  5  6  7  8  9 10 11 12 
  9 10 11 12  1  2  4 13  7  8  5 14  3 16  6 15 
  9 10 11 12  1  2  7 13  6 16  4 14  3  8  5 15 
;                    /*End of punch card input*/
                     /*Implicit run;*/

— user3490
সূত্র

1

পিপিসিজিতে পাঞ্চ কার্ড ব্যবহারের জন্য +1 :)

— জিএনিক্ল্যাশ

3

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

o f=foldl1 f.concat
r=[0..3]
q n=take(min(n+2)3).drop(n-1)
0#m=m
v#m=[o max$q y$q x<$>n|y<-r,x<-r,m!!y!!x==v]!!0#n where n=map(z<$>)m;z w|w==v=0|0<1=w
f=o(+).(16#)

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

fফাংশন 4 পূর্ণসংখ্যার 4 তালিকার একটি তালিকা হিসাবে ইনপুট নেয়।

খানিকটা উজ্জীবিত

-- helper to fold over the matrix
o f = foldl1 f . concat

-- range of indices
r = [0 .. 3]

-- slice a list (take the neighborhood of a given coordinate)
-- first we drop everything before the neighborhood and then take the neighborhood itself
q n = take (min (n + 2) 3) . drop (n - 1)

-- a step function
0 # m = m -- if the max value of the previous step is zero, return the map
v # m = 
    -- abuse list comprehension to find the current value in the map
    -- convert the found value to its neighborhood,
    -- then calculate the max cell value in it
    -- and finally take the head of the resulting list
    [ o max (q y (q x<$>n)) | y <- r, x <- r, m!!y!!x == v] !! 0 
       # n -- recurse with our new current value and new map
    where 
        -- a new map with the zero put in place of the value the mouse currently sits on 
        n = map (zero <$>) m
        -- this function returns zero if its argument is equal to v
        -- and original argument value otherwise
        zero w 
            | w == v = 0
            | otherwise = w

-- THE function. first apply the step function to incoming map,
-- then compute sum of its cells
f = o (+) . (16 #)

— ম্যাক্স ইয়েখলাভ
সূত্র

3

জাভাস্ক্রিপ্ট (ES7), 97 বাইট

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

f=(a,s=p=136,m,d)=>a.map((v,n)=>v<m|(n%4-p%4)**2+(n-p)**2/9>d||(q=n,m=v))|m?f(a,s-m,a[p=q]=0,4):s

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

f = (                    // f= recursive function taking:
  a,                     // - a[] = flattened input array
  s =                    // - s = sum of cheese piles, initialized to 1 + 2 + .. + 16 = 136
      p = 136,           // - p = position of the mouse, initially outside the board
  m,                     // - m = maximum pile, initially undefined
  d                      // - d = distance threshold, initially undefined
) =>                     // 
  a.map((v, n) =>        // for each pile v at position n in a[]:
    v < m |              //   unless this pile is not better than the current maximum
    (n % 4 - p % 4) ** 2 //   or (n % 4 - p % 4)²
    + (n - p) ** 2 / 9   //      + (n - p)² / 9
    > d ||               //   is greater than the distance threshold:
    (q = n, m = v)       //     update m to v and q to n
  )                      // end of map()
  | m ?                  // if we've found a new pile to eat:
    f(                   //   do a recursive call:
      a,                 //     pass a[] unchanged
      s - m,             //     update s by subtracting the pile we've just eaten
      a[p = q] = 0,      //     clear a[q], update p to q and set m = 0
      4                  //     use d = 4 for all next iterations
    )                    //   end of recursive call
  :                      // else:
    s                    //   stop recursion and return s

— Arnauld
সূত্র

হ্যাঁ, আমি এর কাছাকাছি কোথাও যেতে পারতাম না!

— শেগি

3

এপিএল (ডায়ালগ ইউনিকোড) , 42 41 বাইট ^{এসবিসিএস}

16{×⍺:a∇⍨+/,m×⌈/⌈/⊢⌺3 3⊢a←⍵×~m←⍺=⍵⋄+/,⍵}⊢

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

— ngn
সূত্র

3

জাভা 10, 272 248 বাইট

m->{int r=0,c=0,R=4,C,M=1,x,y,X=0,Y=0;for(;R-->0;)for(C=4;C-->0;)if(m[R][C]>15)m[r=R][c=C]=0;for(;M!=0;m[r=X][c=Y]=0)for(M=-1,C=9;C-->0;)try{if((R=m[x=r+C/3-1][y=c+C%3-1])>M){M=R;X=x;Y=y;}}catch(Exception e){}for(var Z:m)for(int z:Z)M+=z;return M;}

সমস্ত একক আটটি চ্যালেঞ্জের জন্য আমার উত্তর হিসাবে কক্ষগুলি একইভাবে চেক করা হয় । -২২
বাইটস @ অলিভিগ্রগ্রোয়ারকে ধন্যবাদ ।

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

ব্যাখ্যা:

m->{                       // Method with integer-matrix parameter and integer return-type
  int r=0,                 //  Row-coordinate for the largest number, starting at 0
      c=0,                 //  Column-coordinate for the largest number, starting at 0
      R=4,C,               //  Row and column indices (later reused as temp integers)
      M=1,                 //  Largest number the mouse just ate, starting at 1
      x,y,X=0,Y=0;         //  Temp integers
  for(;R-->0;)             //  Loop `R` in the range (4, 0]:
    for(C=4;C-->0;)        //   Inner loop `C` in the range (4, 0]:
      if(m[R][C]>15)       //    If the current cell is 16:
        m[r=R][c=C]        //     Set `r,c` to this coordinate
          =0;              //     And empty this cell
  for(;M!=0;               //  Loop as long as the largest number isn't 0:
      ;                    //    After every iteration:
       m[r=X][c=Y]         //     Change the `r,c` coordinates,
         =0)               //     And empty this cell
    for(M=-1,              //   Reset `M` to -1
        C=9;C-->0;)        //   Inner loop `C` in the range (9, 0]:
          try{if((R=       //    Set `R` to:
            m[x=r+C/3-1]   //     If `C` is 0, 1, or 2: Look at the previous row
                           //     Else-if `C` is 6, 7, or 8: Look at the next row
                           //     Else (`C` is 3, 4, or 5): Look at the current row
             [y=c+C%3-1])  //     If `C` is 0, 3, or 6: Look at the previous column
                           //     Else-if `C` is 2, 5, or 8: Look at the next column
                           //     Else (`C` is 1, 4, or 7): Look at the current column
               >M){        //    And if the number in this cell is larger than `M`
                 M=R;      //     Change `M` to this number
                 X=x;Y=y;} //     And change the `X,Y` coordinate to this cell
          }catch(Exception e){}
                           //    Catch and ignore ArrayIndexOutOfBoundsExceptions
                           //    (try-catch saves bytes in comparison to if-checks)
  for(var Z:m)             //  Then loop over all rows of the matrix:
    for(int z:Z)           //   Inner loop over all columns of the matrix:
      M+=z;                //    And sum them all together in `M` (which was 0)
  return M;}               //  Then return this sum as result

— কেভিন ক্রুইজসেন
সূত্র

আপনি কি r = c = X = Y = 0, R = 4, M = 1, x, y; ?

— সার্ভারফ্রোগ

@ সার্ভারফ্রোগ আমি ভয় করি জাভাতে ভেরিয়েবলগুলি ঘোষণা করার সময় এটি সম্ভব নয় not আপনার পরামর্শ আমাকে ব্যবহার করে একটি বাইট সংরক্ষণ করার জন্য একটি ধারণা দেয় int r,c,R=4,M=1,x,y,X,Y;for(r=c=X=Y=0;, তাই ধন্যবাদ। :)

— কেভিন ক্রুইজসেন

1

জে, 82 বাইট

g=.](]*{:@[~:])]_1}~[:>./]{~((,-)1 5 6 7)+]i.{:
[:+/[:(g^:_)16,~[:,0,~0,0,0,.~0,.]

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

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

— দুর্ভাগ্যআনয়নকারী
সূত্র

আপনি কি সত্যিই বামদিকের প্রয়োজন ]মধ্যে g?

— গ্যালেন ইভানভ

1

ধন্যবাদ গ্যালেন, আপনি ঠিক বলেছেন। এই কোডটি সহ সমস্যাগুলির মধ্যে এটি সর্বনিম্ন :) আমার একটি আরও ভাল সমাধান রয়েছে যা আমি সময় পেলে বাস্তবায়ন করব।

— জোনা

1

লাল , 277 বাইট

func[a][k: 16 until[t:(index? find load form a k)- 1
p: do rejoin[t / 4 + 1"x"t % 4 + 1]a/(p/1)/(p/2): 0
m: 0 foreach d[-1 0x-1 1x-1 -1x0 1x0 -1x1 0x1 1][j: p + d
if all[j/1 > 0 j/1 < 5 j/2 > 0 j/2 < 5 m < t: a/(j/1)/(j/2)][m: t]]0 = k: m]s: 0
foreach n load form a[s: s + n]s]

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

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

আরও পঠনযোগ্য:

f: func [ a ] [
    k: 16
    until [
        t: (index? find load form a n) - 1
        p: do rejoin [ t / 4 + 1 "x" t % 4 + 1 ]
        a/(p/1)/(p/2): 0
        m: 0
        foreach d [ -1 0x-1 1x-1 -1x0 1x0 -1x1 0x1 1 ] [
            j: p + d
            if all[ j/1 > 0
                    j/1 < 5
                    j/2 > 0
                    j/2 < 5 
                    m < t: a/(j/1)/(j/2)
            ] [ m: t ]
        ]
        0 = k: m
    ]
    s: 0
    foreach n load form a [ s: s + n ]
    s
]

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

1

জেলি , 31 30 29 বাইট

³œiⱮZIỊȦ
⁴ṖŒPŒ!€Ẏ⁴;ⱮṢÇƇṪ
FḟÇS

পদ্ধতিটি যেহেতু 60 এর দশকের মধ্যে এটির শুরু দিয়ে মাউসটি শুরু হয় 16তার থেকে চালানো খুব ধীর 9এবং তার ক্ষমতাটি এমনভাবে সীমাবদ্ধ করে যে সে কেবলমাত্র 9এস বা কম খেতে সক্ষম হয় অনলাইনে চেষ্টা করে দেখুন! (এভাবে তিনি এখানে 9, 2, 7, 4, 8, 6, 3চলে যাচ্ছেন 97)।

কিভাবে?

³œiⱮZIỊȦ - Link 1, isSatisfactory?: list of integers, possiblePileChoice
³        - (using a left argument of) program's 3rd command line argument (M)
   Ɱ     - map across (possiblePileChoice) with:
 œi      -   first multi-dimensional index of (the item) in (M)
    Z    - transpose the resulting list of [row, column] values
     I   - get the incremental differences
      Ị  - insignificant? (vectorises an abs(v) <= 1 test)
       Ȧ - any and all? (0 if any 0s are present in the flattened result [or if it's empty])

⁴ṖŒPŒ!€Ẏ⁴;ⱮṢÇƇṪ - Link 2, getChosenPileList: list of lists of integers, M
⁴               - literal 16
 Ṗ              - pop -> [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
  ŒP            - power-set -> [[],[1],[2],...,[1,2],[1,3],...,[2,3,7],...,[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]]
      €         - for each:
    Œ!          -   all permutations
       Ẏ        - tighten (to a single list of all these individual permutations)
        ⁴       - (using a left argument of) literal 16
          Ɱ     - map across it with:
         ;      -   concatenate (put a 16 at the beginning of each one)
           Ṣ    - sort the resulting list of lists
             Ƈ  - filter keep those for which this is truthy:
            Ç   -   call last Link as a monad (i.e. isSatisfactory(possiblePileChoice)
              Ṫ - tail (get the right-most, i.e. the maximal satisfactory one)

FḟÇS - Main Link: list of lists of integers, M
F    - flatten M
  Ç  - call last Link (2) as a monad (i.e. get getChosenPileList(M))
 ḟ   - filter discard (the resulting values) from (the flattened M)
   S - sum

— জোনাথন অ্যালান
সূত্র

হ্যাঁ, পাওয়ার-সেট যথেষ্ট নয়!

— জোনাথন অ্যালান

2

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

— জোনাথন অ্যালান

নিচে ভোটাররা দয়া করে কিছু প্রতিক্রিয়া জানাতে পারেন? এটি কাজ করে, এর একটি সম্পূর্ণ এবং স্পষ্ট ব্যাখ্যা রয়েছে এবং বর্তমান সময়ে সংক্ষিপ্ত প্রবেশও এটি।

— জনাথন অ্যালান

আমি উত্সাহিত করেছি, কিন্তু এই উত্তরটির ও ((এন ^ 2) দিয়েছি! আমি আশা করি চ্যালেঞ্জটির বহুপদী সময় প্রয়োজন হত।

— lirtosiast

1

আমার সেরা কাজ নয়। কিছু নির্দিষ্ট উন্নতি করতে হবে, কিছু সম্ভবত ব্যবহৃত অ্যালগরিদমের মৌলিক - আমি নিশ্চিত যে এটি কেবলমাত্র একটি ব্যবহার করে উন্নত করা যেতে পারে int[], তবে প্রতিবেশীদের কীভাবে সেইভাবে গণনা করা যায় তা আমি বুঝতে পারি না। আমি একটি পাওয়ারশেল সমাধান দেখতে পছন্দ করব যা কেবলমাত্র একক মাত্রিক অ্যারে ব্যবহার করে!

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

Function F($o){$t=120;$a=@{-1=,0*4;4=,0*4};0..3|%{$a[$_]=[int[]](-join$o[(3+18*$_)..(3+18*$_+13)]-split',')+,0};$m=16;while($m-gt0){0..3|%{$i=$_;0..3|%{if($a[$i][$_]-eq$m){$r=$i;$c=$_}}};$m=($a[$r-1][$c-1],$a[$r-1][$c],$a[$r-1][$c+1],$a[$r][$c+1],$a[$r][$c-1],$a[$r+1][$c-1],$a[$r+1][$c],$a[$r+1][$c+1]|Measure -Max).Maximum;$t-=$m;$a[$r][$c]=0}$t}

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

আরও পঠনযোগ্য সংস্করণ:

Function F($o){
    $t=120;
    $a=@{-1=,0*4;4=,0*4};
    0..3|%{$a[$_]=[int[]](-join$o[(3+18*$_)..(3+18*$_+13)]-split',')+,0};
    $m=16;
    while($m-gt0){
        0..3|%{$i=$_;0..3|%{if($a[$i][$_]-eq$m){$r=$i;$c=$_}}};
        $m=($a[$r-1][$c-1],$a[$r-1][$c],$a[$r-1][$c+1],$a[$r][$c+1],$a[$r][$c-1],$a[$r+1][$c-1],$a[$r+1][$c],$a[$r+1][$c+1]|Measure -Max).Maximum;
        $t-=$m;
        $a[$r][$c]=0
    }
    $t
}

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

1

সাধারণ পুনর্গঠনের পরে 334 বাইট

— ভেস্কাহ

ওহ হ্যাঁ, আমি যে আশ্চর্যজনক বিষয়টি লক্ষ্য করেছি তা হ'ল PSv5 এ কাজ করার (array|sort)[-1]পরিবর্তে করার চেষ্টা করা Measure -maxহয়েছে তবে মূলত ভুল ফলাফল পাচ্ছে। কেন জানি না।

— ভেস্কাহ

হ্যাঁ, এটা অদ্ভুত। আমি এটি পরীক্ষা করেছি (0..10|sort)[-1]তবে এটি পিএসভি 5 তে 10 কিন্তু পিএস কোর 9 এ ফিরে আসে। কারণ এটি এটি সংখ্যার পরিবর্তে অভিধানিক ক্রমে আচরণ করে। লজ্জা।

— জেফ ফ্রিম্যান

ক্লাসিক মাইক্রোসফ্ট গুরুত্বপূর্ণ জিনিসগুলি পরিবর্তন করে।

— ভেস্কাহ

আমি এই ক্ষেত্রে একমত। আমি নিশ্চিত নই কেন পিএস কোর সারণি ইন 32 এর অ্যারেটিকে একটি স্ট্রিংয়ের অ্যারেতে ফেলেছে। তবে, এটি একটি বাচ্চা হিসাবে বিপথগামী হয়, তাই আমি খনন করব। পুনর্গঠনের জন্য ধন্যবাদ!

— জেফ ফ্রিম্যান

1

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

x;y;i;b;R;C;
g(int a[][4],int X,int Y){b=a[Y][X]=0;for(x=-1;x<2;++x)for(y=-1;y<2;++y)if(!(x+X&~3||y+Y&~3||a[y+Y][x+X]<b))b=a[C=Y+y][R=X+x];for(i=x=0;i<16;++i)x+=a[0][i];return b?g(a,R,C):x;}
s(int*a){for(i=0;i<16;++i)if(a[i]==16)return g(a,i%4,i/4);}

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

দ্রষ্টব্য: এই জমাটি ইনপুট অ্যারেটিকে সংশোধন করে।

s()একটি পরিবর্তনীয় যুক্তির সাথে কল করার ফাংশন int[16](যা মেমরির হিসাবে একই int[4][4], যা এটি এর g()অর্থ ব্যাখ্যা করে)।

s()16অ্যারেতে অবস্থানটি সন্ধান করে , তারপরে এই তথ্যটি এতে স্থান দেয় gযা একটি পুনরাবৃত্ত ফাংশন যা একটি অবস্থান নেয়, সেই স্থানে নম্বরটি 0 তে সেট করে এবং তারপরে:

যদি এর সাথে সংলগ্ন কোনও ধনাত্মক সংখ্যা থাকে তবে বৃহত্তম সংলগ্ন সংখ্যার অবস্থানের সাথে পুনরাবৃত্তি করুন
অন্যথায় অ্যারের সংখ্যার যোগফলটি ফেরত দিন।

— pizzapants184
সূত্র

s(int*a){for(i=0;a[i]<16;++i);return g(a,i%4,i/4);}

— RiaD

যদি জি খাওয়ার পরিমাণ ফেরত দেয় তবে আপনাকে এতে যোগফল গণনা করার দরকার নেই। এস এর শেষে 16 * 17/2-g ()

— ফিরুন

আপনি কি কিছুটা ব্যবহার করতে পারেন বা পরিবর্তে লজিকাল বা?

— RiaD

211 বাইট

— সিলিংক্যাট

1

ওল্ফ্রাম ভাষা (গণিত) , 149 বাইট

(g@p_:=#&@@Position[s,Max@p];m=g[s=#];While[Tr[b=s[[##]]&@@#&/@Select[#+m&/@Tuples[{-1,0,1},2],Max@#<5&&Min@#>0&]]>0,m=g@b;s[[##&@@m]]=0];Tr[Tr/@s])&

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

— J42161217
সূত্র

1

++ , 281 বাইট যুক্ত করুন

D,f,@@,VBFB]G€=dbLRz€¦*bMd1_4/i1+$4%B]4 4b[$z€¦o
D,g,@@,c2112011022200200BD1€Ω_2$TAVb]8*z€kþbNG€lbM
D,k,@~,z€¦+d4€>¦+$d1€<¦+$@+!*
D,l,@@#,bUV1_$:G1_$:
D,h,@@,{l}A$bUV1_$:$VbU","jG$t0€obU0j","$t€iA$bUpVdbLRG€=€!z€¦*$b]4*$z€¦o
y:?
m:16
t:120
Wm,`x,$f>y>m,`m,$g>x>y,`y,$h>x>y,`t,-m
Ot

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

ওফ, এটি একটি জটিল।

সমস্ত পরীক্ষার কেস যাচাই করুন

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

এই ব্যাখ্যার জন্য, আমরা ইনপুটটি ব্যবহার করব

$M = \left[\begin{matrix} 3 & 7 & 10 & 5 \\ 6 & 8 & 12 & 13 \\ 15 & 9 & 11 & 4 \\ 14 & 1 & 16 & 2 \\ \end{matrix}\right]$

$x$ $1 \le x \le 16$ $M$ $4\text{x}4$

$f(x, M)$ $4\text{x}4$ $x$ $M$ $x = 16$ $M$ $f(x, M) = (4, 3)$
$g(M, y)$ $f(x, M)$ $g(M, f(x, M)) = 11$

এটি দুটি সহায়ক ফাংশন প্রয়োগ করে:

$k(x)$

$l(M, y)$
$h(y, M)$ $0$

$0$ $16$ $120 \: (1 + 2 + \cdots + 14 + 15)$

$0$

$\neq 0$

$f(\textbf{y}, \textbf{m})$ $16$ $M$ $x := (4, 3)$
$g(\textbf{x}, \textbf{y})$ $0$
$h(\textbf{x}, \textbf{y})$ $16$ $0$
$\textbf{t} - \textbf{m}$

অবশেষে, আউটপুট টি , অর্থাত্ অবশিষ্ট, নন সংগ্রহ করা মান।

— কেয়ারড কইনারিংহিং
সূত্র

1

সি # (.নেট কোর) , 258 বাইট

লিনকিউ ছাড়াই। সিস্টেম.কালেকশন.জেনেরিক ব্যবহারটি পরে ফর্ম্যাটের জন্য - ফাংশনটির প্রয়োজন হয় না।

e=>{int a=0,b=0,x=0,y=0,j=0,k;foreach(int p in e){if(p>15){a=x=j/4;b=y=j%4;}j++;}e[x,y]=0;while(1>0){for(j=-1;j<2;j++)for(k=-1;k<2;k++){try{if(e[a+k,b+j]>e[x,y]){x=a+k;y=b+j;}}catch{}}if(e[x,y]<1)break;e[x,y]=0;a=x;b=y;}a=0;foreach(int p in e)a+=p;return a;}

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

— Destroigo
সূত্র

1

পার্ল 6 , 151 136 126 125 119 বাইট

{my@k=$_;my $a=.grep(16,:k)[0];while @k[$a] {@k[$a]=0;$a=^@k .grep({2>$a+>2-$_+>2&$a%4-$_%4>-2}).max({@k[$_]})};[+] @k}

সুপার জঞ্জাল সমাধান। সমতল অ্যারে হিসাবে ইনপুট নেয়।

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

— bb94
সূত্র

1

পার্ল 5 `-MList::Util=sum -p` , 137 বাইট

splice@F,$_,0,0for 12,8,4;map{$k{++$,}=$_;$n=$,if$_&16}@F;map{map{$n=$_+$"if$k{$"+$_}>$k{$n}&&!/2|3/}-6..6;$k{$"=$n}=0}@F;$_=sum values%k

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

— Xcali
সূত্র

1

কে (এনএনজি / কে) , 49 বাইট

{{h[,x]:0;*>(+x+0,'1-!3 3)#h}\*>h::(+!4 4)!x;+/h}

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

ইনপুট ( x) একটি 1 ডি অ্যারে

(+!4 4)!x একটি অভিধান যা মানগুলির জোড় জোড় মানচিত্রের মানচিত্র x

h:: গ্লোবাল ভেরিয়েবলকে বরাদ্দ করুন h

*> সর্বাধিক মানের সাথে সম্পর্কিত কী

{ }\ সংযোগ না হওয়া পর্যন্ত পুনরাবৃত্তি করুন, একটি তালিকার মধ্যবর্তী মান সংগ্রহ করুন

h[,x]:0 বর্তমান অবস্থান শূন্য

+x+0,'1-!3 3 প্রতিবেশী অবস্থান

( )#hhএকটি ছোট অভিধান হিসাবে এগুলি ফিল্টার করুন

*>কোন প্রতিবেশীর সর্বাধিক মূল্য আছে? এটি নতুন পুনরাবৃত্তির বর্তমান অবস্থানে পরিণত হয়

+/hঅবশেষে, hঅবশিষ্ট মানগুলির যোগফল প্রদান করে

— ngn
সূত্র

1

ওল্ফ্রাম ভাষা (গণিত) , 124 115 বাইট

(p=#&@@Position[m=Join@@ArrayPad[#,1],16];Do[m[[p]]=0;p=MaximalBy[#&@@p+{0,-1,1,-5,5,-6,6,-7,7},m[[#]]&],16];Tr@m)&

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

এটি একটি 2 ডি অ্যারে নেয়, এটি প্রতিটি পাশের প্যাডগুলি দেয়, তারপরে তা তাত্ক্ষণিকভাবে এটি সমতল করে তোলে যাতে আমাদের বাইটস সূচীকরণ ব্যয় করতে হবে না। Join@@এটির জন্য একমাত্র ব্যয় চ্যাপ্টা। পরে এটি নীচের দিকে এগিয়ে যায় ce

2D অ্যারের জন্য 124-বাইট সংস্করণ : এটি অনলাইনে চেষ্টা করুন!

বেশিরভাগ আমার নিজের কাজ, J42161217 এর 149-বাইট উত্তর থেকে কিছুটা প্রাপ্ত ।

Ungolfed:

(p = #& @@ Position[m = #~ArrayPad~1,16];     m = input padded with a layer of 0s
                                              p = location of 16
Do[
    m = MapAt[0&,m,p];                        Put a 0 at location p
    p = #& @@ MaximalBy[                      Set p to the member of
        p+#& /@ Tuples[{0,-1,1},2],             {all possible next locations}
        m~Extract~#&],                        that maximizes that element of m,
                                              ties broken by staying at p+{0,0}=p.
16];                                        Do this 16 times.
Tr[Tr/@m]                                   Finally, output the sum of m.
)&

— lirtosiast
সূত্র

হাংরি মাউস

উদাহরণ

চ্যালেঞ্জ

বিধি

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

পাইথন 2 , 133 130 বাইট

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

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

এমএটিএল , 50 49 47 বাইট

ব্যাখ্যা

পিএইচপি, 177 174 171 বাইট

জাভাস্ক্রিপ্ট, 122 বাইট

আর , 128 124 123 112 110 বাইট

কাঠকয়লা , 47 বাইট

পাওয়ারশেল, 143 141 136 130 122 121 বাইট

এসএএস, 236 219 বাইট

আপডেট:

Golfed:

Ungolfed:

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

খানিকটা উজ্জীবিত

জাভাস্ক্রিপ্ট (ES7), 97 বাইট

মন্তব্য

এপিএল (ডায়ালগ ইউনিকোড) , 42 41 বাইট এসবিসিএস

জাভা 10, 272 248 বাইট

জে, 82 বাইট

লাল , 277 বাইট

আরও পঠনযোগ্য:

জেলি , 31 30 29 বাইট

কিভাবে?

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

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

ওল্ফ্রাম ভাষা (গণিত) , 149 বাইট

++ , 281 বাইট যুক্ত করুন

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

সি # (.নেট কোর) , 258 বাইট

পার্ল 6 , 151 136 126 125 119 বাইট

পার্ল 5 -MList::Util=sum -p , 137 বাইট

কে (এনএনজি / কে) , 49 বাইট

ওল্ফ্রাম ভাষা (গণিত) , 124 115 বাইট

পাইথন 2 , ₁₃₃ 130 বাইট

এপিএল (ডায়ালগ ইউনিকোড) , 42 41 বাইট ^{এসবিসিএস}

পার্ল 5 `-MList::Util=sum -p` , 137 বাইট