आप कितने टॉवर देख सकते हैं?

29

यह सवाल नंबर-प्लेसमेंट पहेली टावर्स (जिसे गगनचुंबी इमारतों के रूप में भी जाना जाता है) पर आधारित है, जिसे आप ऑनलाइन खेल सकते हैं । आपका लक्ष्य पहेली का हल निकालना और सुराग निर्धारित करना है - प्रत्येक पंक्ति और स्तंभ के साथ दिखने वाले टावरों की संख्या। यह कोड गोल्फ है, इसलिए सबसे कम बाइट जीतती है।

टावर्स कैसे काम करता है

टावर्स पहेली का समाधान एक लैटिन वर्ग है - एक n*nग्रिड जिसमें प्रत्येक पंक्ति और स्तंभ के 1माध्यम से संख्याओं का क्रमचय होता है n। इसके लिए एक उदाहरण n=5है:

4 3 5 2 1 
5 4 1 3 2 
1 5 2 4 3 
2 1 3 5 4 
3 2 4 1 5

प्रत्येक पंक्ति और स्तंभ को प्रत्येक छोर पर एक सुराग के साथ लेबल किया जाता है:

       2 3 1 4 5    
       v v v v v

 2 >   4 3 5 2 1   < 3
 1 >   5 4 1 3 2   < 4
 2 >   1 5 2 4 3   < 3
 3 >   2 1 3 5 4   < 2
 3 >   3 2 4 1 5   < 1 

       ^ ^ ^ ^ ^
       2 2 2 2 1

प्रत्येक सुराग एक संख्या 1है nजो आपको बताती है कि आप उस दिशा से पंक्ति / स्तंभ को देखते हुए कितने टॉवर "देख" रहे हैं, यदि संख्या को उस ऊँचाई के साथ टॉवर माना जाता है। प्रत्येक टॉवर इसके पीछे छोटे टॉवरों को अवरुद्ध करता है। दूसरे शब्दों में, जिन टावरों को आप देख सकते हैं, वे पहले के किसी भी टॉवर से लम्बे हैं।

कॉन्सेप्टिस पज़ल्स से इमेज

उदाहरण के लिए, आइए पहली पंक्ति देखें।

 2 >   4 3 5 2 1   < 3

यह 2बाईं ओर से एक सुराग है क्योंकि आप 4और को देख सकते हैं 5। 4ब्लॉक 3दृष्टि और से 5किसी और ब्लॉक सब कुछ। दाईं ओर से, आप देख सकते हैं 3टावरों: 1, 2, और 5।

कार्यक्रम की आवश्यकताएं

एक प्रोग्राम या फ़ंक्शन लिखें जो संख्याओं और आउटपुटों की ग्रिड में लेता है या सुराग को प्रिंट करता है, शीर्ष बाएं से दक्षिणावर्त जा रहा है।

इनपुट

के साथ एक n*nलैटिन-वर्ग 2<=n<=9।

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

43521 54132 15243 21354 32415,

या रिक्त स्थान के बिना एक स्ट्रिंग।

आपको nइनपुट के हिस्से के रूप में नहीं दिया गया है।

उत्पादन

ऊपर बाईं ओर से शुरू होकर और दक्षिणावर्त जाते हुए सुरागों को वापस लौटाएं या प्रिंट करें। इसलिए, पहले ऊपरी सुराग दाईं ओर पढ़ते हैं, फिर दाएं सुराग नीचे की ओर पढ़ते हैं, फिर निचले सुराग बाईं ओर पढ़ते हैं, बाएं सुराग ऊपर की ओर पढ़ते हैं।

यह 23145 34321 12222 33212पिछले उदाहरण के लिए होगा

       2 3 1 4 5    
       v v v v v

 2 >   4 3 5 2 1   < 3
 1 >   5 4 1 3 2   < 4
 2 >   1 5 2 4 3   < 3
 3 >   2 1 3 5 4   < 2
 3 >   3 2 4 1 5   < 1 

       ^ ^ ^ ^ ^
       2 2 2 2 1

बस इनपुट के लिए, आप एक सूची, स्ट्रिंग, या किसी भी आदेशित संरचना का उपयोग कर सकते हैं। चार "समूहों" को एक नेस्टेड या एक फ्लैट संरचना में अलग किया जा सकता है या नहीं। लेकिन, प्रारूप प्रत्येक समूह के लिए समान होना चाहिए।

उदाहरण के परीक्षण के मामले:

(आपका इनपुट / आउटपुट फॉर्मेट इन जैसा नहीं होना चाहिए।)

>> [[1 2] [2 1]]

[2 1]
[1 2]
[2 1]
[1 2]

>> [[3 1 2] [2 3 1] [1 2 3]]

[1 2 2]
[2 2 1]
[1 2 3]
[3 2 1]

>> [[4 3 5 2 1] [5 4 1 3 2] [1 5 2 4 3] [2 1 3 5 4] [3 2 4 1 5]]

[2 3 1 4 5]
[3 4 3 2 1]
[1 2 2 2 2]
[3 3 2 1 2]

>> [[2 6 4 1 3 7 5 8 9] [7 2 9 6 8 3 1 4 5] [5 9 7 4 6 1 8 2 3] [6 1 8 5 7 2 9 3 4] [1 5 3 9 2 6 4 7 8] [3 7 5 2 4 8 6 9 1] [8 3 1 7 9 4 2 5 6] [9 4 2 8 1 5 3 6 7] [4 8 6 3 5 9 7 1 2]]

[4 2 2 3 3 3 3 2 1]
[1 3 3 2 2 2 2 3 3]
[4 3 2 1 2 3 3 2 2]
[3 1 2 4 3 3 2 2 5]

आपकी सुविधा के लिए, यहां फ्लैट स्ट्रिंग प्रारूप में समान परीक्षण मामले हैं।

>> 1221

21
12
21
12

>> 312231123

122
221
123
321

>> 4352154132152432135432415

23145
34321
12222
33212

>> 264137589729683145597461823618572934153926478375248691831794256942815367486359712

422333321
133222233
432123322
312433225
code-golf  grid 
— XNOR
स्रोत

जवाबों:

22

एपीएल 19

≢¨∪/⌈\(⍉⍪⌽⍪⊖∘⌽∘⍉⍪⊖)

(ngn के सुझाव के बाद थोड़ा और गोल्फ, धन्यवाद)

स्पष्टीकरण:

(⍉⍪⌽⍪⊖∘⌽∘⍉⍪⊖)  rotates matrix 4 times appending results
⌈\ gets maximums for each row up to current column (example: 4 2 3 5 1 gives 4 4 4 5 5)
≢¨∪/ counts unique elements for each row

इसे tryapl.org पर आज़माएं

— मोरिस ज़ुक्का
स्रोत
1
आप 1:≢¨∪¨↓⌈\(⍉⍪⌽⍪⍉∘⌽∘⊖⍪⊖)
— ngn
@ आप सही हैं, धन्यवाद! मैंने is / तो 1 चार्ट कम लागू किया
— मोरिस ज़ुक्का
वाह - यह एपीएल एक्सेल में चुनौती का एक प्रकार है।
— isaacg
12

पायथन 2, 115 बाइट्स

def T(m):o=[];exec'm=zip(*m)[::-1]\nfor r in m[::-1]:\n n=k=0\n for x in r:k+=x>n;n=max(x,n)\n o+=[k]\n'*4;return o

वहाँ सूची का एक बहुत कुछ चल रहा है वहाँ चल रहा है।

एक नेस्टेड सूची (उदाहरण के साथ कॉल T([[4,3,5,2,1],[5,4,1,3,2],[1,5,2,4,3],[2,1,3,5,4],[3,2,4,1,5]])) के रूप में इनपुट लेता है । आउटपुट एकल फ्लैट सूची है।

Ungolfed:

def T(m):
 o=[]
 for _ in [0]*4:
  m=zip(*m)[::-1]
  for r in m[::-1]:
   n=k=0
   for x in r:k+=x>n;n=max(x,n)
   o+=[k]
 return o

वैकल्पिक 115:

def T(m):o=[];exec'm=zip(*m)[::-1];o+=[len(set([max(r[:i+1])for i in range(len(r))]))for r in m[::-1]];'*4;return o

मुझे नहीं पता कि यह एक सूची समझ के साथ क्यों काम करता है, लेकिन NameErrorएक सेट समझ के साथ चक देता है ...

थोड़ा बहुत लंबा है, लेकिन अगर किसी की दिलचस्पी है - हाँ, यह एक भेड़ के बच्चे के लिए नीचे लाने के लिए संभव है!

T=lambda m:[len({max(r[:i+1])for i in range(len(r))})for k in[1,2,3,4]for r in eval("zip(*"*k+"m"+")[::-1]"*k)[::-1]]

पायथ , 25 बाइट्स

V4=Q_CQ~Yml{meS<dhkUd_Q)Y

अप्रचलित पाइथ बंदरगाह।

सूची को STDIN के माध्यम से इनपुट करें, जैसे [[4, 3, 5, 2, 1], [5, 4, 1, 3, 2], [1, 5, 2, 4, 3], [2, 1, 3, 5, 4], [3, 2, 4, 1, 5]]।

इसे ऑनलाइन आज़माएं ... जो मैं कहूंगा लेकिन दुर्भाग्य से, सुरक्षा कारणों से, ऑनलाइन दुभाषिया नेस्टेड कोष्ठक पर निकासी के उपयोग को अस्वीकार करता है। JcQ5V4=J_CJ~Yml{meS<dhkUd_J)Yइसके बजाय वर्कअराउंड कोड आज़माएं , और एक चपटा सूची जैसे इनपुट करें [4, 3, 5, 2, 1, 5, 4, 1, 3, 2, 1, 5, 2, 4, 3, 2, 1, 3, 5, 4, 3, 2, 4, 1, 5]।

(@ बसाक का धन्यवाद जिन्होंने कुछ बाइट्स में गोल्फ की मदद की)

— Sp3000
स्रोत
अजगर गोल्फ के एक जोड़े: <और >एक तरफा टुकड़ा ऑपरेटरों रहे हैं, तो :d0hkमें बदल दिया जा सकता है <dhk। Uसंग्रह इनपुट के रूप में ही है Ul, इसलिए Uldमें बदल दिया जा सकता है Ud।
— isaacg
@isaacg धन्यवाद - लगता है जैसे मेरे पाइथ को अपडेट करने की आवश्यकता है। मेरे पास जो डॉक है वह पुराना है।
— Sp3000
11

सीजेएम, 29 27 बाइट्स

q~{z_{[{1$e>}*]_&,}%pW%}4*;

इनपुट की तरह

[[4 3 5 2 1] [5 4 1 3 2] [1 5 2 4 3] [2 1 3 5 4] [3 2 4 1 5]]

जैसे आउटपुट

[2 3 1 4 5]
[3 4 3 2 1]
[1 2 2 2 2]
[3 3 2 1 2]

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

मूल विचार पंक्तियों के साथ कोड का काम करना और ग्रिड काउंटर-क्लॉकवाइज को 4 बार घुमाना है। टावरों की गिनती करने के लिए, मैं प्रत्येक टॉवर को ऊपर उठा रहा हूं, जहां तक ​​यह "दृश्य अंतर" नहीं बनाता है (यानी, यदि यह दिखाई दे रहा है तो इसे न बदलें, या टॉवर के सामने की ऊँचाई तक खींच लें यह), और फिर मैं अलग ऊंचाइयों की गिनती कर रहा हूं।

q~                          "Read and evaluate the input.";
  {                    }4*  "Four times...";
   z                        "Transpose the grid.";
    _                       "Duplicate.";
     {            }%        "Map this block onto each row.";
      [       ]             "Collect into an array.";
       {    }*              "Fold this block onto the row.";
        1$                  "Copy the second-to-topmost element.":
          e>                "Take the maximum of the top two stack elements.";
                            "This fold replaces each element in the row by the
                             maximum of the numbers up to that element. So e.g.
                             [2 1 3 5 4] becomes [2 2 3 5 5].";
               _&,          "Count unique elements. This is how many towers you see.";
                    p       "Print array of results.";
                     W%     "Reverse the rows for the next run. Together with the transpose at
                             the start this rotates the grid counter-clockwise.";
                          ; "Get rid of the grid so that it isn't printed at the end.";
— मार्टिन एंडर
स्रोत
4

गणितज्ञ, 230,120,116,113 110 बाइट्स

f=(t=Table;a=#;s=Length@a;t[v=t[c=m=0;t[h=a[[y,x]];If[h>m,c++;m=h],{y,s}];c,{x,s}];a=Thread@Reverse@a;v,{4}])&

उपयोग:

f[{
  {4, 3, 5, 2, 1},
  {5, 4, 1, 3, 2},
  {1, 5, 2, 4, 3},
  {2, 1, 3, 5, 4},
  {3, 2, 4, 1, 5}
}]

{{2, 3, 1, 4, 5}, {3, 4, 3, 2, 1}, {1, 2, 2, 2, 2}, {3, 3, 2, 1, 2}}
— kukac67
स्रोत
a[[y]][[x]]है a[[y,x]]। और उपयोग करने Arrayसे कम हो सकता है Table।
— मार्टिन एंडर
4

जावास्क्रिप्ट, 335 264 256 213

T=I=>((n,O)=>(S=i=>i--&&O.push([])+S(i)+(R=(j,a,x)=>j--&&R(j,0,0)+(C=k=>k--&&((!(a>>(b=I[(F=[f=>n-k-1,f=>j,f=>k,f=>n-j-1])[i]()][F[i+1&3]()])))&&++x+(a=1<<b))+C(k))(n)+O[i].push(x))(n,0,0))(4)&&O)(I.length,[],[])

ब्राउज़र के जावास्क्रिप्ट कंसोल में मूल्यांकन करें (मैंने फ़ायरफ़ॉक्स 34.0 का उपयोग किया था, Chrome 39 में काम नहीं करता है?) इसके साथ टेस्ट करें: ??

JSON.stringify(T([[4, 3, 5, 2, 1], [5, 4, 1, 3, 2], [1, 5, 2, 4, 3], [2, 1, 3, 5, 4], [3, 2, 4, 1, 5]]));

यहाँ असंगठित कोड का वर्तमान अवतार है - इसका पालन करना कठिन हो रहा है:

function countVisibleTowers(input) {
  return ((n, out) =>
      (sideRecurse = i =>
          i-- &&
          out.push([]) +
          sideRecurse(i) +
          (rowRecurse = (j, a, x) =>
              j-- &&
              rowRecurse(j, 0, 0) +
              (columnRecurse = k =>
                  k-- &&
                  ((!(a >> (b = input[
                                        (offsetFtn = [
                                            f => n - k - 1,   // col negative
                                            f => j,           // row positive
                                            f => k,           // col positive
                                            f => n - j - 1    // row negative
                                        ])[i]()
                                     ]
                                     [
                                        offsetFtn[i + 1 & 3]()
                                     ]))) &&
                  ++x +
                  (a = 1 << b)) +
                  columnRecurse(k)
              )(n) +
              out[i].push(x)
          )(n, 0, 0)
      )(4) && out
  )(input.length, [], [])
}

मैं जानबूझकर किसी अन्य उत्तर को नहीं देखता था, मैं यह देखना चाहता था कि क्या मैं खुद कुछ काम कर सकता हूं। मेरा दृष्टिकोण इनपुट सरणियों को एक-आयामी सरणी में समतल करना था और सभी चारों दिशाओं से पंक्तियों के लिए ऑफ़सेट को प्री-कंपोज़ करना था। फिर मैंने परीक्षण के लिए शिफ्ट राइट का उपयोग किया कि क्या अगला टॉवर गलत था और यदि ऐसा था, तो प्रत्येक पंक्ति के लिए काउंटर बढ़ाएँ।

मैं उम्मीद कर रहा हूँ कि इसे सुधारने के बहुत से तरीके हैं, शायद ऑफ़सेट्स का पूर्वगामी नहीं, बल्कि 1 डी इनपुट ऐरे पर किसी प्रकार के अतिप्रवाह / मोडुलो का उपयोग करें? और शायद मेरे छोरों को मिलाएं, अधिक कार्यात्मक, समर्पण प्राप्त करें।

किसी भी सुझाव की सराहना की जाएगी!

अपडेट # 1 : प्रगति, हमारे पास तकनीक है! मैं पूर्वगामी ऑफसेट से छुटकारा पाने में सक्षम था और उन्हें टर्नरी ऑपरेटरों के साथ मिलकर इनलाइन करता था। भी अगर मेरे बयान से छुटकारा पाने में सक्षम था और छोरों के लिए व्हिल में परिवर्तित कर दिया।

अपडेट # 2 : यह बहुत निराशाजनक है; मेरे लिए कोई पिज्जा पार्टी नहीं। मुझे लगा कि कार्यात्मक हो रहा है और पुनरावृत्ति का उपयोग करके कई बाइट्स से दाढ़ी हो जाएगी, लेकिन मेरे पहले कुछ प्रयासों ने 100 वर्णों तक बड़ा होने का अंत कर दिया! हताशा में, मैं ES6 वसा तीर कार्यों का उपयोग करने के लिए पूरे-हॉग पर चला गया ताकि वास्तव में इसे कम कर सकें। तब मैंने बूलियन ऑपरेटरों को अंकगणित वाले और पार्न्स, अर्ध-कॉलोन और रिक्त स्थान को हटाने के लिए लिया, जहां भी मैं कर सकता था। मैंने अपने संस्करणों की घोषणा करना भी छोड़ दिया और अपने स्थानीय प्रतीकों के साथ वैश्विक नाम स्थान को प्रदूषित किया। गंदी गंदी। उस पूरे प्रयास के बाद, मैंने अपने अद्यतन # 1 स्कोर को 8 कैरेक्टरों से नीचे गिरा कर 256 तक हरा दिया।

यदि मैंने अपने अपडेट # 1 फ़ंक्शन में समान निर्दयी अनुकूलन और ES6 ट्रिक्स लागू किए, तो मैं इस स्कोर को एक मील से हरा दूंगा। मैं सिर्फ एक # 3 अद्यतन कर सकता हूं यह देखने के लिए कि वह कैसा दिखेगा।

अपडेट # 3 : पता चलता है कि वसा तीर पुनरावर्ती दृष्टिकोण में बहुत अधिक जीवन था, मुझे बस इसे समतल करने के बजाय सीधे 2 आयामी इनपुट के साथ काम करने और क्लोजर स्कोप का लाभ उठाने के बारे में बेहतर होना चाहिए। मैंने दो बार आंतरिक सरणी ऑफसेट गणनाओं को फिर से लिखा और एक ही स्कोर प्राप्त किया, इसलिए यह दृष्टिकोण खनन करने के करीब हो सकता है!

— DWoldrich
स्रोत
3

जावा, केवल 352 350 325 बाइट्स ...

class S{public static void main(String[]a){int n=a.length,i=0,j,k,b,c;int[][]d=new int[n][n];for(;i<n;i++)for(j=0;j<n;)d[i][j]=a[i].charAt(j++);for(i=0;i<4;i++){int[][]e=new int[n][n];for(k=0;k<n;k++)for(j=0;j<n;)e[n-j-1][k]=d[k][j++];d=e;for(j=n;j-->(k=c=b=0);System.out.print(c))for(;k<n;k++)b=d[j][k]>b?d[j][k]+0*c++:b;}}}

इनपुट की तरह 43521 54132 15243 21354 32415

जैसे आउटपुट: 23145343211222233212

इंडेंट:

class S{
    public static void main(String[]a){
        int n=a.length,i=0,j,k,b,c;
        int[][]d=new int[n][n];
        for(;i<n;i++)
            for(j=0;j<n;)d[i][j]=a[i].charAt(j++);
        for(i=0;i<4;i++){
            int[][]e=new int[n][n];
            for(k=0;k<n;k++)
                for(j=0;j<n;)e[n-j-1][k]=d[k][j++];
            d=e;
            for(j=n;j-->(k=c=b=0);System.out.print(c))
                for(;k<n;k++)b=d[j][k]>b?d[j][k]+0*c++:b;
        }
    }
}

कोई भी युक्ति सराहनीय होगी!

— नंबर एक
स्रोत
आपके पास forछोरों के बीच कुछ अतिरिक्त
— व्हाट्सएप हैं
@proud haskeller धन्यवाद!
— TheNumberOne
आप को बदल सकता है for(;i<n;i++)करने के लिए for(;++i<n;)और प्रारंभ iकरने के लिए -1। फिर सामान करने के लिए इनका उपयोग करें। आप दूसरे लूप के साथ भी ऐसा कर सकते हैं।
— गर्व हैस्केलर
आप a[i].charAt(j)-'0'स्पष्ट पार्सिंग के बजाय उपयोग कर सकते हैं । यह भी इनपुट में सीमांकक की आवश्यकता नहीं है (इनपुट प्रारूप को आउटपुट स्वरूप की तरह अधिक बनाता है)।
— अनातोली
इसके अलावा, for-लूप में, आप हमेशा "लूप इन्क्रीमेंट" भाग में उपयोगी कुछ सामान कर सकते हैं। यह कोड को अधिक अस्पष्ट बनाता है और एक अर्धविराम को निकालता है। उदाहरण के लिए for(j=n;j-->0;System.out.print(c)):।
— अनातोलीग डेस
1

पायथन 2 - 204 बाइट्स

def f(l):n=len(l);k=[l[c]for c in range(n)if l[c]>([0]+list(l))[c]];return f(k)if k!=l else n
r=lambda m:(l[::-1]for l in m)
m=input();z=zip(*m);n=0
for t in z,r(m),r(z),m:print map(f,t)[::1-(n>1)*2];n+=1

यह शायद एक बहुत गरीब गोल्फ है। मुझे लगा कि समस्या दिलचस्प थी, इसलिए मैंने किसी और के समाधान को देखे बिना इसे निपटाने का फैसला किया। जैसा कि मैंने इस वाक्य को टाइप किया है, मुझे इस प्रश्न के उत्तर को देखना बाकी है। मुझे आश्चर्य नहीं होगा अगर किसी और ने पहले से ही एक छोटा अजगर कार्यक्रम किया है;)

I / O उदाहरण

$ ./towers.py <<< '[[4,3,5,2,1],[5,4,1,3,2],[1,5,2,4,3],[2,1,3,5,4],[3,2,4,1,5]]'
[2, 3, 1, 4, 5]
[3, 4, 3, 2, 1]
[1, 2, 2, 2, 2]
[3, 3, 2, 1, 2]

आप इनपुट में व्हॉट्सएप को वैकल्पिक रूप से शामिल कर सकते हैं। बहुत कहीं भी, ईमानदारी से। जब तक आप eval()यह कर सकते हैं, यह काम करेगा।

व्याख्या

इस कार्यक्रम का एकमात्र दिलचस्प हिस्सा पहली पंक्ति है। यह एक फ़ंक्शन को परिभाषित करता है f(l)जो आपको बताता है कि एक पंक्ति में कितने टावरों को देखा जा सकता है, और बाकी कार्यक्रम बस उस फ़ंक्शन को हर संभव स्थिति में लागू कर रहा है।

जब बुलाया जाता है, तो यह लंबाई को पाता है lऔर इसे एक चर में बचाता है n। फिर यह kइस सुंदर राक्षसी सूची समझ के साथ एक नया चर बनाता है :

[l[c]for c in range(n)if l[c]>([0]+list(l))[c]]

जब आप इसे तोड़ते हैं तो यह बहुत बुरा नहीं है। चूंकि n==len(l), ifबस का प्रतिनिधित्व करने से पहले सब कुछ l। हालाँकि, ifहम उपयोग करके कुछ तत्वों को सूची से हटा सकते हैं। हम साथ सूची का निर्माण ([0]+list(l)), जो सिर्फ कि " lएक साथ 0शुरुआत करने के लिए जोड़ा" (करने के लिए कॉल को अनदेखा कर list(), केवल यह है कि क्योंकि कभी-कभी lएक जनरेटर है और हम यह वास्तव में एक सूची यहाँ है सुनिश्चित करने की आवश्यकता)। l[c]यदि यह इससे बड़ा है तो केवल अंतिम सूची में डाला जाता है ([0]+list(l))[c]। यह दो काम करता है:

  • चूंकि सूची की शुरुआत में एक नया तत्व है, प्रत्येक का सूचकांक l[c]बन जाता है c+1। हम प्रभावी रूप से प्रत्येक तत्व को तत्व के बाईं ओर तुलना कर रहे हैं। यदि यह अधिक है, तो यह दिखाई दे रहा है। अन्यथा यह सूची से छिपा और हटा दिया गया है।
  • पहला टॉवर हमेशा दिखाई देता है क्योंकि ऐसा कुछ भी नहीं है जो इसे ब्लॉक कर सके। क्योंकि हम शुरुआत में 0 डालते हैं, पहला टॉवर हमेशा अधिक होता है। (हम ऐसा नहीं किया, तो [0]+बकवास और बस की तुलना l[c]करने के लिए l[c-1], अजगर पहले टॉवर पिछले एक के सूचकांक एक सूची में अंत से तुलना होगा (आप कर सकते हैं के साथ -1, -2आदि), इसलिए यदि पिछले टावर से अधिक लंबी थी पहले हम गलत परिणाम प्राप्त करेंगे।

जब सभी को कहा और किया जाता है, तो lकुछ संख्या में टॉवर kहोते हैं और उनमें से प्रत्येक में वह होता है जो बाईं ओर अपने निकटतम पड़ोसी से छोटा नहीं होता है। यदि उनमें से कोई भी नहीं था (उदाहरण के लिए f([1,2,3,4,5])), तो l == k। हम जानते हैं कि कुछ भी नहीं करना है और वापस करना है n(सूची की लंबाई)। यदि l != k, इसका मतलब है कि इस समय कम से कम एक टावरों को हटा दिया गया था और ऐसा करने के लिए और भी कुछ हो सकता है। तो, हम लौटते हैं f(k)। भगवान, मैं पुनरावृत्ति प्यार करता हूँ। दिलचस्प बात यह है कि, fहमेशा एक स्तर की गहराई से पुनरावृत्ति होती है, कड़ाई से "आवश्यक"। जब जो सूची वापस की जाएगी, वह जेनरेट की जाती है, तो फ़ंक्शन के पास यह जानने का कोई तरीका नहीं है।

जब मैंने यह स्पष्टीकरण लिखना शुरू किया, तो यह कार्यक्रम 223 बाइट्स लंबा था। चीजों की व्याख्या करते हुए मैंने महसूस किया कि पात्रों को बचाने के तरीके थे, इसलिए मुझे खुशी है कि मैंने इसे टाइप किया! सबसे बड़ा उदाहरण यह है कि f(l)मूल रूप से एक अनंत लूप के रूप में लागू किया गया था जो कि गणना करने के बाद टूट गया था, इससे पहले कि मुझे एहसास हुआ कि पुनरावर्तन काम करेगा। यह सिर्फ यह दिखाने के लिए जाता है कि आपके द्वारा सोचा गया पहला समाधान हमेशा सबसे अच्छा नहीं होगा। :)

— undergroundmonorail
स्रोत
0

मतलाब, (123) (119)

function r=m(h);p=[h rot90(h) rot90(h,2) rot90(h,3)];for i=2:size(p) p(i,:)=max(p(i,:),p(i-1,:));end;r=sum(diff(p)>0)+1

इस तरह इस्तेमाल किया:

m([
 4     3     5     2     1;
 5     4     1     3     2;
 1     5     2     4     3;
 2     1     3     5     4;
 3     2     4     1     5])

 [2 3 1 4 5 3 4 3 2 1 1 2 2 2 2 3 3 2 1 2]

C #, 354 से नीचे ...

TheBestOne की तुलना में अलग दृष्टिकोण।

using System;
using System.Linq;

class A
{
    static void Main(string[] h)
    {
        int m = (int)Math.Sqrt(h[0].Length),k=0;
        var x = h[0].Select(c => c - 48);
        var s = Enumerable.Range(0, m);
        for (; k < 4; k++)
        {
            (k%2 == 0 ? s : s.Reverse())
                .Select(j =>
                        (k > 0 && k < 3 ? x.Reverse() : x).Where((c, i) => (k % 2 == 0 ? i % m : i / m) == j)
                                                          .Aggregate(0, (p, c) =>
                                                                        c > p%10
                                                                            ? c + 10 + p/10*10
                                                                            : p, c => c/10))
                .ToList()
                .ForEach(Console.Write);
        }
    }
}
— zabalajka
स्रोत
ऐसा लगता है कि आप \nनई खबरों के बजाय कंप्यूटर का पेस्ट कर रहे हैं , मैंने उन्हें केवल रिक्त स्थान द्वारा प्रतिस्थापित किया है, इसलिए कोड तुरंत भाग जाता है जब कोई इसे कॉपी कर रहा होता है। और मैंने अपने आप को अंतिम end(जो कि आवश्यक नहीं है, फ़ंक्शन को बंद कर देता है) को हटाने की अनुमति दी , जो अतिरिक्त 4 वर्णों को बचाता है, मुझे आशा है कि ठीक था =)
— दोष डिस्क्
ऐसा लगता है कि मैटलैब रिक्त स्थान से खुश नहीं थे इसलिए मैंने उन्हें अर्धविराम में बदल दिया। endहालांकि ट्रेलिंग के बारे में अच्छी बात है , thx :)
— zabalajka
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.