আপনি কত টাওয়ার দেখতে পারেন?

Question

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

টাওয়ারগুলি কীভাবে কাজ করে

একটি - একটি টাওয়ার্স ধাঁধা সমাধান একটি ল্যাটিন বর্গাকার হয় 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।

ফর্ম্যাটটি নমনীয়। আপনি এমন কোনও ডেটা স্ট্রাকচার ব্যবহার করতে পারেন যা কোনও গ্রিড বা সংখ্যা বা অঙ্কের অক্ষরযুক্ত তালিকা উপস্থাপন করে। আপনার সারিগুলির মধ্যে বিভাজক বা কোনও বিভাজক লাগবে না। কিছু সম্ভাবনা হ'ল একটি তালিকা, তালিকার একটি তালিকা, একটি ম্যাট্রিক্স, একটি টোকেন দ্বারা পৃথক স্ট্রিং like

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

Answer 1

এপিএল 19

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

(এনএনজির পরামর্শের পরে আরও কিছুটা গল্ফ করল, ধন্যবাদ)

ব্যাখ্যা:

(⍉⍪⌽⍪⊖∘⌽∘⍉⍪⊖)  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

Comments

আপনি 1:≢¨∪¨↓⌈\(⍉⍪⌽⍪⍉∘⌽∘⊖⍪⊖)

— ngn

@ আপনি ঠিক বলেছেন, ধন্যবাদ! আমি applied / তাই 1 টিরও কম কম আবেদন করেছি :)

— মরিস জুকা

বাহ - এটি এপিএল ছাড়িয়ে যাওয়া চ্যালেঞ্জের ধরণ।

— isaacg

Answer 2

পাইথন 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পরিবর্তে workaround কোড চেষ্টা করুন , এবং একটি সমতল তালিকা হিসাবে ইনপুট [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]।

(@ আইস্যাককে ধন্যবাদ যিনি গল্ফকে কয়েকটি বাইট আউট করতে সহায়তা করেছিলেন)

Comments

পাইথ গল্ফগুলির একটি দম্পতি: <এবং >এটি একতরফা স্লাইস অপারেটর, তাই :d0hkরূপান্তরিত হতে পারে <dhk। Uসংগ্রহের ইনপুটগুলি একই Ul, তাই Uldরূপান্তরিত হতে পারে Ud।

— isaacg

@ আইসাক ধন্যবাদ - দেখে মনে হচ্ছে আমার পাইথ আপডেট হওয়ার দরকার আছে। আমার যে ডকটি আছে তা পুরানো।

— Sp3000

Answer 3

সিজেম, 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.";

Answer 4

এপিএল, 44

{{+/~0∊¨↓(∘.>⍨⍵)≥∘.<⍨⍳⍴⍵}¨↓(⌽∘⍉⍪⊢⍪⊖∘⍉⍪⊖∘⌽)⍵}

এখানে পরীক্ষিত।

Answer 5

জে, 35 অক্ষর

(+/@((>./={:)\)"2@(|.@|:^:(<4)@|:))

উদাহরণ:

   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
   (+/@((>./={:)\)"2@(|.@|:^:(<4)@|:)) t
2 3 1 4 5
3 4 3 2 1
1 2 2 2 2
3 3 2 1 2

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

Answer 6

হাস্কেল, ১১৩

import Data.List
f(x:s)=1+f[r|r<-s,r>x]
f _=0
r=reverse
t=transpose
(?)=map
l s=[f?t s,(f.r)?s,r$(f.r)?t s,r$f?s]

Answer 7

গণিত, 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}}

Comments

a[[y]][[x]]হয় a[[y,x]]। এবং ব্যবহারের Arrayচেয়ে কম হতে পারে Table।

— মার্টিন এন্ডার

Answer 8

জাভাস্ক্রিপ্ট, 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 ব্যবহার করেছি, ক্রোম 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, [], [])
}

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

আমি আশা করছি এটির উন্নতি করার প্রচুর উপায় রয়েছে, সম্ভবত অফসেটগুলি প্রাক্কলক করা নয়, বরং 1 ডি ইনপুট অ্যারেতে একরকম ওভারফ্লো / মডুলো ব্যবহার করবেন? এবং সম্ভবত আমার লুপগুলি একত্রিত করুন, আরও কার্যকরী করুন, নকল করুন।

কোন পরামর্শ প্রশংসা হবে!

আপডেট # 1 : অগ্রগতি, আমাদের প্রযুক্তি আছে! আমি পূর্বনির্ধারিত অফসেটগুলি থেকে মুক্তি পেতে এবং টের্নারি অপারেটরগুলির সাথে একসাথে প্রবেশের সাথে সেগুলি ইনলাইন করতে সক্ষম হয়েছি। এছাড়াও আমার ইফ স্টেটমেন্ট থেকে মুক্তি পেতে এবং লুপের জন্য লুপগুলিকে রূপান্তর করতে সক্ষম হয়েছিল।

আপডেট # 2 : এটি বেশ হতাশার; আমার জন্য পিজ্জা পার্টি নেই আমি ফাংশনাল গিয়েছিলাম এবং পুনরাবৃত্তি ব্যবহার করে অনেকগুলি বাইট ছাঁটাই করে দেবে, তবে আমার প্রথম কয়েকটি চেষ্টা 100 টি চরিত্রের চেয়ে বড় হয়ে শেষ হয়েছে! হতাশায়, আমি সত্যিই এটি বন্ধ করার জন্য ES6 ফ্যাট অ্যারো ফাংশনগুলি ব্যবহার করে পুরো-হোগে গিয়েছিলাম। তারপরে আমি বুলিয়ান অপারেটরগুলিকে পাটিগণিতগুলির সাথে প্রতিস্থাপন করতে এবং পেরেন, আধা-কলোন এবং স্পেস যেখানেই পারতাম সরিয়ে ফেললাম। এমনকি আমি আমার যুদ্ধ ঘোষণা করা ছেড়ে দিয়েছি এবং আমার স্থানীয় প্রতীক সহ বিশ্বব্যাপী নেমস্পেসকে দূষিত করেছি। নোংরা, নোংরা। এত চেষ্টা করার পরেও, আমি আমার আপডেট # 1 স্কোরকে মোট 8 টি অক্ষর দ্বারা হারিয়ে 256-এ নামিয়ে আছি B

যদি আমি আমার আপডেট # 1 ফাংশনে একই নির্মম অপ্টিমাইজেশান এবং ES6 কৌশলগুলি প্রয়োগ করি, তবে আমি এই স্কোরটি এক মাইল পরাস্ত করব। আমি দেখতে চাই একটি আপডেট # 3 ঠিক কি দেখতে হবে তা দেখতে।

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

Answer 9

জাভা, কেবল 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;
        }
    }
}

যেকোনো ধরণের উপদেশ গ্রহণযোগ্য হবে!

Comments

forলুপগুলির মধ্যে আপনার কয়েকটি অতিরিক্ত

— শ্বেত

@ গর্বিত হাসেলেলার আপনাকে ধন্যবাদ!

— 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))।

— অ্যানাটলিগ

Answer 10

পাইথন 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

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

আই / ও উদাহরণ

$ ./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]

আপনি ইনপুটটিতে optionচ্ছিকভাবে হোয়াইটস্পেস অন্তর্ভুক্ত করতে পারেন। খুব কোথাও, সত্যি বলতে। যতক্ষণ আপনি 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ধারণ করে এবং এর প্রত্যেকটি বামে তার নিকটবর্তী প্রতিবেশীর চেয়ে সংক্ষিপ্ত নয় contains যদি তাদের কেউ ছিল (যেমন f([1,2,3,4,5])), তারপর l == k। আমরা জানি এবং ফিরে আসার মতো কিছুই নেই n(তালিকার দৈর্ঘ্য)। যদি l != k, তার মানে এইবারের মতো কমপক্ষে একটি টাওয়ার সরিয়ে নেওয়া হয়েছিল এবং আরও অনেক কিছু করা হতে পারে। সুতরাং, আমরা ফিরে f(k)। Godশ্বর, আমি পুনরাবৃত্তি পছন্দ করি। মজার বিষয় হল, fসর্বদা কঠোরভাবে "প্রয়োজনীয়" এর চেয়ে গভীরতর একটি স্তর পুনরাবৃত্তি করে। ফিরে আসা তালিকাটি তৈরি করা হলে ফাংশনটির প্রথমে এটি জানার কোনও উপায় নেই।

যখন আমি এই ব্যাখ্যাটি লেখা শুরু করি, তখন এই প্রোগ্রামটি 223 বাইট দীর্ঘ। জিনিসগুলি ব্যাখ্যা করার সময় আমি বুঝতে পারি যে চরিত্রগুলি সংরক্ষণ করার উপায় রয়েছে, তাই আমি এটি টাইপ করে খুশি! সবচেয়ে বড় উদাহরণটি হ'ল f(l)মূলত একটি অসীম লুপ হিসাবে প্রয়োগ করা হয়েছিল যা গণনাটি শেষ হওয়ার পরে ভেঙে গিয়েছিল, আমি বুঝতে পেরেছিলাম পুনরাবৃত্তি কাজ করবে। এটি কেবল এটি দেখায় যে আপনি যে প্রথম সমাধানটি মনে করেন তা সর্বদা সেরা হবে না। :)

Answer 11

মতলব, (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]

সি #, নীচে 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);
        }
    }
}

Comments

দেখে মনে হচ্ছে আপনি \nনতুন লাইনের পরিবর্তে কম্পিউটারের পেস্ট করেছেন , আমি কেবল তাদের স্পেস দ্বারা প্রতিস্থাপন করেছি, সুতরাং যখন কেউ এটি অনুলিপি করছেন তখন ঠিক তখনই চলে। এবং আমি নিজেকে সর্বশেষটি মুছতে দিয়েছি end(এটি ফাংশনটি বন্ধ করে দেয়, যা প্রয়োজনীয় নয়) যা অতিরিক্ত 4 টি অক্ষর সংরক্ষণ করে, আমি আশা করি যে ঠিক ছিল =)

— flawr

দেখে মনে হচ্ছে মাতলাব স্থানগুলি নিয়ে খুশি ছিল না তাই আমি সেগুলি সেমিকোলনে পরিবর্তন করেছিলাম। পিছনের দিকটি সম্পর্কে ভাল বক্তব্য end, যদিও

— থেক্স