पनीर के सोलह ढेर 4x4 वर्ग पर लगाए जाते हैं। उन्हें $1$ से $16$ तक लेबल किया गया है । सबसे छोटा ढेर $1$ और सबसे बड़ा $16$ ।

हंग्री माउस इतना भूखा है कि यह हमेशा सबसे बड़े ढेर (यानी $16$ ) तक जाता है और इसे तुरंत खाता है।

उसके बाद, यह सबसे बड़े पड़ोसी ढेर में जाता है और जल्दी से उस एक को भी खा जाता है। (हाँ ... यह वास्तव में भूख लगी है।) और तब तक जब तक कि कोई पड़ोसी ढेर न हो।

ढेर में 8 पड़ोसी (क्षैतिज, लंबवत और तिरछे) हो सकते हैं। कोई रैप-अराउंड नहीं है।

उदाहरण

हम पनीर के निम्नलिखित ढेर के साथ शुरू करते हैं:

\begin{matrix} 3 & 7 & 10 & 5 \\ 6 & 8 & 12 & 13 \\ 15 & 9 & 1 1 & 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$ ।

नियम

क्योंकि इनपुट मैट्रिक्स का आकार तय है, आप इसे 2 डी सरणी या एक-आयामी सरणी के रूप में ले सकते हैं।
$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

यह चुनौती txo कंप्यूटर के लिए भूलभुलैया कार्यक्रम में माउस की याद दिलाती है। इस खेल को 1950 के दशक में वापस लिखा गया था, और किंवदंती के अनुसार, टीएक्सओ दुनिया का पहला ट्रांजिस्टरकृत कंप्यूटर था। हां, मानो या न मानो, कोई आपके दादाजी के दिन में वीडियो गेम लिख रहा था।

— वाल्टर मिती

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 अभी भी समग्र रूप से बेहतर हो सकता है।

— एक्सनोर

1

यद्यपि आपका शून्य पैडिंग लूप चतुर है, यह ऐसा लगता है कि यह 2 डी सूची लेने के लिए छोटा है a=[0]*5 for r in input():a=r+[0]+a:। शायद वहाँ अभी तक एक छोटी स्ट्रिंग टुकड़ा करने की क्रिया समाधान है कि पुनरावृत्ति की आवश्यकता नहीं है।

— एक्सनोर

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 पर एक फ्लैट सूची लेता है।

कोड यह जाँचता है कि क्या दो फ्लैट सूचकांक iऔर jस्पर्श कोशिकाओं का प्रतिनिधित्व करते हुए जाँच करते हैं कि दोनों पंक्ति भिन्न हैं i/4-j/4और स्तंभ अंतर i%4-j%4-2 और 2 के बीच कड़ाई से है। इसके बजाय पहला पास स्वचालित रूप से सफल होता है जिससे कि सबसे बड़ी प्रविष्टि आसन्नता की अवहेलना करते हुए पाई जाती है।

— XNOR
स्रोत

8

MATL , 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

— लुइस मेंडो
स्रोत

Idk MatLab, लेकिन क्या आप थोड़ा बचा सकते हैं यदि आप +136 के बजाय -136 को धक्का देते हैं?

— टाइटस

@ टिट्स एचएम मैं नहीं देखता कि कैसे

— लुइस

या दूसरे तरीके से राउंड: मैंने सोचा कि 1 के बजाय) 136 2 पुश करें) प्रत्येक खाए गए मूल्य को 3) पुश करें, खाए गए मूल्यों को 4) 136 से घटाएं -> 1) पुश 136 के 2) खाने के मूल्य के नकारात्मक को धक्का दें 3) ढेर को ढेर करें। लेकिन जैसा कि यह स्पष्ट रूप से केवल एक बाइट है; यह शायद कोई लाभ नहीं है।

— टाइटस

@Titus आह, हाँ, मुझे लगता है कि बाइट्स की एक ही संख्या का उपयोग करता है। इसके अलावा, सेट अंतर के लिए मुझे प्रत्येक खाने के मूल्य (इसके नकारात्मक नहीं) की आवश्यकता है; नकारना अंत में करना होगा

— लुइस मेंडो

6

PHP, 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 बाइट्स

मैंने इस पर एक दो से अधिक गलत मोड़ ले लिए और अब मैं आगे की गोल्फ के लिए समय से बाहर चला गया लेकिन कम से कम यह काम कर रहा है। कल (या, मुझे जानते हुए, आज शाम को ट्रेन घर पर!), अगर मैं एक मिनट मिल सकता है, फिर से आना होगा।

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 112 बाइट्स

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 से शुरू होता है और अगले सबसे बड़े और इतने आगे के लिए इसे "बवासीर" के आसपास खोजता है।

निष्कर्ष पर, यह आउटपुट को एक चेतावनी देता है, लेकिन यह बिना किसी परिणाम के होता है और परिणाम को नहीं बदलता है।

EDIT: -4 बाइट्स मैट्रिक्स की आरंभीकरण को 1 पंक्ति में संपीड़ित करके।

EDIT: -1 रॉबर्ट हैकेन को धन्यवाद

EDIT: -13 बाइट्स में ग्यूसेप और रॉबिन राइडर के सुझावों का संयोजन।

— Sumner18
स्रोत

आप एक बाइट को बदलने के r==16लिए बचा सकते हैं r>15।

— राबर्ट हैकेन

1

117 बाइट्स - इसे मैट्रिक्स में लेने वाले फ़ंक्शन में बदलें और इसके साथ कुछ अलियासिंग करें which।

— Giuseppe

2

112 बाइट्स में सुधार @Giuseppe के सुझाव: आप mएक पूर्णांक के बजाय एक तार्किक के रूप में संग्रहीत कर सकते हैं , और इस प्रकार केवल whichदो बार के बजाय एक बार कॉल करने की आवश्यकता है ।

— रॉबिन राइडर

110 बाइट्स @RobinRyder के गोल्फ का उपयोग करके और पड़ोस आसन्न मैट्रिक्स को संपीड़ित करने के साथ खिलवाड़ करना।

— ग्यूसेप

1

@ Sumner18 के X%o%Yलिए एक उपनाम है outer(X,Y,'*')। outerयह आसपास के सबसे अच्छे कार्यों में से एक है क्योंकि यह ऑक्टेव / MATLAB / MATL के "ब्रॉडकास्ट" फीचर के रूप में कार्य कर सकता है, जिसमें एट्रिब्यूट (वेक्टरकृत) ऑपरेटर होते हैं। यहाँ देखें ; यह भी दुर्लभ अवसरों पर काम है kroneckerजो उस पृष्ठ में जुड़ा हुआ है।

— ग्यूसेप

4

चारकोल , 47 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

ＥＡ⭆ι§αλ

इनपुट नंबर्स को अल्फाबेटिक कैरेक्टर्स (A = 0 .. Q = 16) में कन्वर्ट करें और उन्हें 4x4 ग्रिड के रूप में प्रिंट करें।

≔Qθ

क्यू, यानी 16 खाने से शुरू करो।

Ｗ›θA«

खाने के लिए कुछ होने पर दोहराएं।

≔⌕ＫＡθθ

पता करें कि ढेर कहाँ है। यह पंक्ति-प्रमुख क्रम में एक रैखिक दृश्य है।

Ｊ﹪θ⁴÷θ⁴

निर्देशांक में कनवर्ट करें और उस स्थान पर जाएं।

≔⌈ＫＭθ

सबसे बड़ा आसन्न ढेर खोजें।

A»

वर्तमान ढेर खाओ।

≔ΣＥＫＡ⌕αιθ

बवासीर को पूर्णांक में बदलें और योग लें।

⎚Ｉθ

कैनवास को साफ़ करें और परिणाम का उत्पादन करें।

— नील
स्रोत

3

पॉवरशेल, 143 141 136 130 130 122 बाइट्स

$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 से गैर-शून्य-अधिकतम से शुरू हुआ। और इसे nullify करें (The Hungry Mouse इसे खाता है)।

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 बाइट्स

पंच कार्ड पर इनपुट, ग्रिड के लिए एक लाइन (अंतरिक्ष-पृथक), लॉग में मुद्रित आउटपुट।

SAS में सरणियों की कुछ सीमाओं से यह चुनौती थोड़ी जटिल है:

बहुआयामी डेटा-चरण सरणी से एक मेल खाने वाले तत्व की पंक्ति और स्तंभ अनुक्रमित को वापस करने का कोई तरीका नहीं है - आपको सरणी को 1-डी के रूप में मानना होगा और फिर उन्हें अपने लिए काम करना होगा।
यदि आप सीमा से बाहर जाते हैं, तो एसएएस एक त्रुटि फेंकता है और अशक्त / शून्य लौटने के बजाय प्रसंस्करण को रोक देता है।

अपडेट:

निकाला गया infile cards;कथन (-13)
इस्तेमाल किया वाइल्डकार्ड a:सरणी परिभाषा के बजाय a1-a16(-4)

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

जावास्क्रिप्ट (ईएस 7), 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;}

सभी एकल आठ चुनौती के लिए मेरे जवाब के रूप में कोशिकाओं की जाँच की जाती है ।
-24 बाइट्स @ OlivierGrégoire को धन्यवाद ।

इसे ऑनलाइन आज़माएं।

स्पष्टीकरण:

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; ?

— सर्वरफोग

@Serverfrog मुझे डर है कि जावा में चर घोषित करते समय यह संभव नहीं है। आपके सुझाव ने मुझे एक बाइट बचाने का विचार दिया, हालांकि, उपयोग करके 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

@ अरनल्ड - अंत में थोड़ा समय गोल्फ को मिला: डी यह काम करना चाहिए, लेकिन (जिस तरह से आप पहले इस्तेमाल किए गए परीक्षण मामले के साथ टीआईओ पर चलने के लिए बहुत धीमी गति से होगा)।

— जोनाथन एलन

क्या नीचे का मतदाता कुछ प्रतिक्रिया दे सकता है? यह काम करता है, एक पूर्ण और स्पष्ट व्याख्या है, और वर्तमान समय में सबसे छोटी प्रविष्टि भी है।

— जोनाथन एलन

मैंने उत्थान किया, लेकिन इस उत्तर के O ((n ^ 2)!) को देखते हुए मुझे लगता है कि चुनौती को बहुपद समय की आवश्यकता थी।

— lirtosiast

1

मेरा सबसे अच्छा काम नहीं है। किए जाने वाले कुछ निश्चित सुधार हैं, कुछ शायद इस्तेमाल किए गए एल्गोरिदम के लिए मौलिक हैं - मुझे यकीन है कि इसे केवल एक का उपयोग करके सुधार किया जा सकता हैint[] , लेकिन मैं समझ नहीं पा रहा था कि कैसे कुशलतापूर्वक पड़ोसियों की गणना की जाए। मैं PowerShell समाधान देखना पसंद करूंगा जो केवल एक ही आयामी सरणी का उपयोग करता है!

पॉवरशेल कोर , 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 बाइट्स साधारण पुनर्गठन के बाद

— Veskah

ओह, हाँ, अजीब बात मैंने देखा कि PSv5 में काम करने के (array|sort)[-1]बजाय कोशिश कर रहा Measure -maxथा लेकिन कोर में गलत परिणाम मिल रहे थे। पता नहीं क्यों।

— विस्कह

हाँ, यह अजीब है। मैंने इसका परीक्षण किया (0..10|sort)[-1]लेकिन यह PSv5 पर 10 लेकिन पीएस कोर पर 9 रिटर्न करता है। ऐसा इसलिए है क्योंकि यह इसे सांख्यिक के बजाय शाब्दिक क्रम में मानता है। उसे शर्मिंदा करो।

— जेफ फ्रीमैन

क्लासिक Microsoft महत्वपूर्ण चीजें बदल रहा है।

— विस्कह

मैं इस मामले में सहमत हूं। मुझे यकीन नहीं है कि पीएस कोर सॉर्टिंग इंट 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);}

— रियाद

अगर जी वापस खाया गया राशि आपको इसमें योग की गणना करने की आवश्यकता नहीं है। बस 16 * 17/2-जी () एस के अंत में

— रियाद

क्या आप बिटवाइज़ का उपयोग कर सकते हैं या इसके बजाय तार्किक या?

— रियाद

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$

इन कार्यों को परिभाषित करने के बाद, हम कार्यक्रम के मुख्य निकाय में आते हैं। पहला चरण चार चर, x , y , m और t को निर्दिष्ट करना है । x को सेट किया गया है $0$ $16$ $120 \: (1 + 2 + \cdots + 14 + 15)$

$0$

$\neq 0$

से x पर सेट करें $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

सी # (.NET कोर) , 258 बाइट्स

LINQ के बिना। System.Collections.Generic का उपयोग करने के बाद स्वरूपण के लिए है - फ़ंक्शन को इसकी आवश्यकता नहीं है।

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

K (ngn / k) , 49 बाइट्स

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

इसे ऑनलाइन आज़माएं!

इनपुट (x ) एक 1d सरणी है

(+!4 4)!x एक ऐसा शब्दकोष जो कोर्ड्स के जोड़े को मानों के लिए मैप करता है x

h:: एक वैश्विक चर को असाइन करें h

*> अधिकतम मूल्य के अनुरूप कुंजी

{ }\ अभिसरण तक दोहराएं, एक सूची में मध्यवर्ती मूल्यों को इकट्ठा करना

h[,x]:0 वर्तमान स्थिति को शून्य करें

+x+0,'1-!3 3 पड़ोसी की स्थिति

( )#h उनसे छान लें hएक छोटे से शब्दकोश के रूप में

*>किस पड़ोसी का अधिकतम मूल्य है? यह नए पुनरावृत्ति के लिए वर्तमान स्थिति बन जाती है

+/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@@समतल करना है। बाद में यह नीचे के रूप में आगे बढ़ता है।

एक 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 बाइट्स

MATL , 50 49 47 बाइट्स

व्याख्या

PHP, 177 174 171 बाइट्स

जावास्क्रिप्ट, 122 बाइट्स

आर , 128 124 123 112 112 बाइट्स

चारकोल , 47 बाइट्स

पॉवरशेल, 143 141 136 130 130 122 बाइट्स

एसएएस, 236 219 बाइट्स

अपडेट:

golfed:

Ungolfed:

हास्केल , 163 बाइट्स

थोड़ा अनगढ़

जावास्क्रिप्ट (ईएस 7), 97 बाइट्स

टिप्पणी की गई

एपीएल (डायलॉग यूनिकोड) , 42 41 बाइट्स एसबीसीएस

जावा 10, 272 248 बाइट्स

जे, 82 बाइट्स

लाल , 277 बाइट्स

अधिक पठनीय:

जेली , 31 30 29 बाइट्स

कैसे?

पॉवरशेल कोर , 348 बाइट्स

सी (जीसीसी), 250 बाइट्स

वोल्फ्राम भाषा (गणितज्ञ) , 149 बाइट्स

++ , 281 बाइट्स जोड़ें

यह काम किस प्रकार करता है

सी # (.NET कोर) , 258 बाइट्स

पर्ल 6 , 151 136 126 125 119 बाइट्स

पर्ल 5 -MList::Util=sum -p , 137 बाइट्स

K (ngn / k) , 49 बाइट्स

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 124 115 बाइट्स

पायथन 2 , ₁₃₃ 130 बाइट्स

एपीएल (डायलॉग यूनिकोड) , 42 41 बाइट्स ^{एसबीसीएस}

पर्ल 5 `-MList::Util=sum -p` , 137 बाइट्स