Câu hỏi này dựa trên Tháp câu đố số vị trí (còn được gọi là Tòa nhà chọc trời), mà bạn có thể chơi trực tuyến . Mục tiêu của bạn là đưa ra lời giải cho câu đố và xác định manh mối - số lượng tháp có thể nhìn thấy dọc theo mỗi hàng và cột. Đây là mã golf, vì vậy ít byte nhất sẽ thắng.

Tháp hoạt động như thế nào

Giải pháp cho câu đố Tháp là một hình vuông Latin - một n*nlưới trong đó mỗi hàng và cột chứa một hoán vị của các số 1thông qua n. Một ví dụ cho 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 

Mỗi hàng và cột được dán nhãn bằng một đầu mối ở mỗi đầu như:

       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

Mỗi đầu mối là một số từ 1để ncho bạn biết có bao nhiêu tháp bạn "nhìn thấy" tìm kiếm dọc theo hàng / cột từ hướng đó, nếu những con số được coi là tòa tháp với chiều cao đó. Mỗi tháp chặn các tháp ngắn hơn phía sau nó. Nói cách khác, những tòa tháp bạn có thể nhìn thấy là những tòa tháp cao hơn bất kỳ tòa tháp nào trước chúng.

Ví dụ, chúng ta hãy nhìn vào hàng đầu tiên.

 2 >   4 3 5 2 1   < 3

Nó có một đầu mối 2từ bên trái bởi vì bạn có thể thấy 4và 5. Các 4khối 3từ tầm nhìn và các 5khối khác. Từ bên phải, bạn có thể nhìn thấy 3tháp: 1, 2, và 5.

Yêu cầu chương trình

Viết chương trình hoặc hàm lấy trong lưới các số và đầu ra hoặc in các đầu mối, đi theo chiều kim đồng hồ từ trên cùng bên trái.

Đầu vào

Một n*nhình vuông Latin với 2<=n<=9.

Các định dạng là linh hoạt. Bạn có thể sử dụng bất kỳ cấu trúc dữ liệu nào đại diện cho lưới hoặc danh sách chứa số hoặc ký tự chữ số. Bạn có thể yêu cầu một dấu phân cách giữa các hàng hoặc không có dấu phân cách nào cả. Một số khả năng là danh sách, danh sách danh sách, ma trận, chuỗi được phân tách bằng mã thông báo như

43521 54132 15243 21354 32415,

hoặc một chuỗi không có khoảng trắng.

Bạn không được đưa ra nnhư một phần của đầu vào.

Đầu ra

Quay trở lại hoặc in các đầu mối bắt đầu từ trên cùng bên trái và đi theo chiều kim đồng hồ. Vì vậy, đầu tiên các đầu mối phía trên đọc sang phải, sau đó các đầu mối bên phải đọc xuống dưới, sau đó các đầu mối bên dưới đọc bên trái, các đầu mối bên trái đọc lên trên.

Đây sẽ là 23145 34321 12222 33212ví dụ trước

       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

Cũng như đối với đầu vào, bạn có thể sử dụng một danh sách, chuỗi hoặc bất kỳ cấu trúc được sắp xếp nào. Bốn "nhóm" có thể được tách ra hoặc không, trong một cấu trúc lồng nhau hoặc phẳng. Nhưng, định dạng phải giống nhau cho mỗi nhóm.

Các trường hợp thử nghiệm ví dụ:

(Định dạng đầu vào / đầu ra của bạn không nhất thiết phải giống như thế này.)

>> [[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]

Để thuận tiện cho bạn, đây là các trường hợp thử nghiệm tương tự trong một định dạng chuỗi phẳng.

>> 1221

21
12
21
12

>> 312231123

122
221
123
321

>> 4352154132152432135432415

23145
34321
12222
33212

>> 264137589729683145597461823618572934153926478375248691831794256942815367486359712

422333321
133222233
432123322
312433225

APL 19

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

(chơi gôn thêm một chút sau đề nghị của ngn, cảm ơn)

Giải trình:

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

Dùng thử trên tryapl.org

Python 2, 115 byte

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

Có rất nhiều danh sách lộn xộn đang diễn ra ở đó.

Đưa đầu vào dưới dạng danh sách lồng nhau (ví dụ: gọi với 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]])). Đầu ra là một danh sách phẳng duy nhất.

Ung dung:

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

Phương án 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

Tôi không biết tại sao điều này hoạt động với một sự hiểu biết danh sách, nhưng lại NameErrorhiểu được một cách hiểu ...

Một chút quá dài, nhưng nếu bất cứ ai quan tâm - vâng, có thể đưa nó xuống lambda!

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]]

Bình thường , 25 byte

V4=Q_CQ~Yml{meS<dhkUd_Q)Y

Cảng Pyth bắt buộc.

Nhập danh sách qua STDIN, vd [[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]].

Dùng thử trực tuyến ... là những gì tôi muốn nói nhưng thật không may, vì lý do bảo mật, trình thông dịch trực tuyến không cho phép sử dụng eval trên dấu ngoặc lồng. JcQ5V4=J_CJ~Yml{meS<dhkUd_J)YThay vào đó, hãy thử mã giải pháp thay thế và nhập dưới dạng danh sách làm phẳng như thế nào [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].

(Cảm ơn @isaacg, người đã giúp chơi golf vài byte)

CJam, 29 27 byte

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

Nhập như

[[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]]

Đầu ra như

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

Làm thế nào nó hoạt động

Ý tưởng cơ bản là để mã làm việc dọc theo các hàng và xoay lưới ngược chiều kim đồng hồ 4 lần. Để đếm các tòa tháp, tôi đang nâng từng tháp cho đến khi nó không tạo ra "sự khác biệt về thị giác" (nghĩa là đừng thay đổi nó nếu nó hiển thị hoặc kéo nó lên cùng một độ cao của tháp trước mặt nó), và sau đó tôi đang đếm độ cao khác biệt.

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.";

APL, 44

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

Đã thử nghiệm ở đây.

J, 35 ký tự

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

Thí dụ:

   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

Hãy thử nó ở đây.

Haskell, 113

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]

Toán học, 230.120.116.113 110 byte

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}])&

Sử dụng:

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}}

JavaScript, 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,[],[])

Đánh giá trong bảng điều khiển JavaScript của trình duyệt (Tôi đã sử dụng Firefox 34.0, dường như không hoạt động trong Chrome 39 ??) Thử nghiệm với:

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]]));

Đây là sự hiện thân của mã không được mã hóa - việc theo dõi trở nên khó khăn hơn:

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, [], [])
}

Tôi cố tình không nhìn vào bất kỳ câu trả lời nào khác, tôi muốn xem liệu tôi có thể tự mình làm được điều gì đó không. Cách tiếp cận của tôi là làm phẳng các mảng đầu vào thành một mảng một chiều và tính toán trước cho các hàng từ cả bốn hướng. Sau đó, tôi đã sử dụng shift phải để kiểm tra xem tòa tháp tiếp theo có bị làm sai hay không và nếu có thì hãy tăng bộ đếm cho mỗi hàng.

Tôi hy vọng có rất nhiều cách để cải thiện điều này, có lẽ không tính toán được các độ lệch, mà là sử dụng một số loại tràn / modulo trên mảng đầu vào 1D? Và có lẽ kết hợp các vòng lặp của tôi, có được nhiều chức năng hơn, lặp lại.

Mọi lơi đê nghị đêu nên được đanh gia cao!

Cập nhật # 1 : Tiến độ, chúng tôi có công nghệ! Tôi đã có thể thoát khỏi các bù trừ được tính toán trước và thực hiện chúng theo dòng với các toán tử ternary nối với nhau. Cũng có thể loại bỏ câu lệnh if của tôi và chuyển đổi các vòng lặp thành các khoảng trống.

Cập nhật # 2 : Điều này khá bực bội; không có bữa tiệc pizza cho tôi. Tôi đã tìm ra chức năng và sử dụng đệ quy sẽ loại bỏ nhiều byte, nhưng vài lần thử đầu tiên của tôi cuối cùng đã lớn hơn tới 100 ký tự! Trong tuyệt vọng, tôi đã sử dụng các chức năng mũi tên béo ES6 để thực sự giảm bớt nó. Sau đó, tôi đã thay thế các toán tử boolean bằng các toán tử số học và loại bỏ các phép liệt kê, dấu chấm phẩy và khoảng trắng bất cứ nơi nào tôi có thể. Tôi thậm chí đã bỏ việc khai báo các vars của mình và làm ô nhiễm không gian tên toàn cầu với các biểu tượng địa phương của tôi. Bẩn, bẩn. Sau tất cả nỗ lực đó, tôi đã đánh bại số điểm Cập nhật số 1 của mình bằng 8 ký tự, giảm xuống còn 256. Blargh!

Nếu tôi áp dụng các tối ưu hóa tàn nhẫn và thủ thuật ES6 tương tự cho chức năng Cập nhật số 1 của mình, tôi sẽ đánh bại số điểm này một dặm. Tôi có thể thực hiện Cập nhật # 3 chỉ để xem nó sẽ như thế nào.

Cập nhật # 3 : Hóa ra cách tiếp cận đệ quy chất béo có nhiều sức sống hơn, tôi chỉ cần làm việc trực tiếp với đầu vào 2 chiều thay vì làm phẳng nó và hiểu rõ hơn về việc tận dụng phạm vi đóng. Tôi đã viết lại các phép tính bù mảng bên trong hai lần và có cùng số điểm, vì vậy cách tiếp cận này có thể gần với khai thác!

Java, chỉ 352 350 325 byte ...

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

Nhập như 43521 54132 15243 21354 32415

Đầu ra như: 23145343211222233212

Thụt lề:

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

Bất kỳ lời khuyên sẽ được đánh giá rất cao!

Python 2 - 204 byte

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

Đây có lẽ là một golf thực sự nghèo. Tôi nghĩ vấn đề này rất thú vị, vì vậy tôi quyết định giải quyết nó mà không cần xem xét giải pháp của ai khác. Khi tôi gõ câu này, tôi vẫn chưa xem câu trả lời cho câu hỏi này. Tôi sẽ không ngạc nhiên nếu ai đó đã thực hiện một chương trình Python ngắn hơn;)

Ví dụ 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]

Bạn có thể tùy ý bao gồm khoảng trắng trong đầu vào. Khá nhiều ở bất cứ đâu, trung thực. Miễn là bạn có thể eval(), nó sẽ hoạt động.

Giải trình

Phần thú vị duy nhất của chương trình này là dòng đầu tiên. Nó xác định một chức năng f(l)cho bạn biết có bao nhiêu tòa tháp có thể được nhìn thấy trong một hàng và phần còn lại của chương trình chỉ áp dụng chức năng đó cho mọi vị trí có thể.

Khi được gọi, nó tìm thấy độ dài lvà lưu nó trong một biến n. Sau đó, nó tạo ra một biến mới kvới sự hiểu biết danh sách khá quái dị này:

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

Nó không quá tệ khi bạn phá vỡ nó. Kể từ khi n==len(l), tất cả mọi thứ trước khi ifchỉ đại diện l. Tuy nhiên, bằng cách sử dụng ifchúng tôi có thể loại bỏ một số yếu tố khỏi danh sách. Chúng tôi xây dựng một danh sách ([0]+list(l)), chỉ là " lcó 0thêm từ đầu" (bỏ qua lệnh gọi đến list(), chỉ có ở đó vì đôi khi llà một trình tạo và chúng tôi cần đảm bảo rằng đó thực sự là một danh sách ở đây). l[c]chỉ được đưa vào danh sách cuối cùng nếu nó lớn hơn ([0]+list(l))[c]. Điều này có hai điều:

• Vì có một yếu tố mới ở đầu danh sách, chỉ mục của mỗi loại l[c]trở thành c+1. Chúng tôi đang so sánh hiệu quả từng yếu tố với yếu tố bên trái của nó. Nếu nó lớn hơn, nó có thể nhìn thấy. Nếu không, nó bị ẩn và xóa khỏi danh sách.
• Tòa tháp đầu tiên luôn có thể nhìn thấy vì không có gì có thể chặn nó. Bởi vì chúng ta đặt 0 ở đầu, tháp đầu tiên luôn lớn hơn. (Nếu chúng tôi không làm được điều này [0]+vô nghĩa và chỉ so l[c]với l[c-1], Python sẽ so sánh tháp đầu tiên đến người cuối cùng (bạn có thể chỉ mục vào một danh sách từ cuối với -1, -2vv), vì vậy nếu tháp cuối cùng là cao hơn so với Đầu tiên chúng ta sẽ nhận được kết quả sai.

Khi tất cả được nói và thực hiện, lchứa một số tháp và kchứa mỗi tháp không ngắn hơn hàng xóm ngay bên trái. Nếu không ai trong số họ là (ví dụ cho f([1,2,3,4,5])), thì l == k. Chúng tôi biết không còn gì để làm và trả lại n(độ dài của danh sách). Nếu l != k, điều đó có nghĩa là ít nhất một trong số các tòa tháp đã bị gỡ bỏ trong khoảng thời gian này và có thể còn nhiều việc phải làm. Vì vậy, chúng tôi trở lại f(k). Chúa ơi, tôi yêu đệ quy. Thật thú vị, fluôn luôn đệ quy một cấp độ sâu hơn là "cần thiết". Khi danh sách sẽ được trả về được tạo, hàm không có cách nào để biết điều đó lúc đầu.

Khi tôi bắt đầu viết lời giải thích này, chương trình này dài 223 byte. Trong khi giải thích những điều tôi nhận ra rằng có nhiều cách để cứu nhân vật, vì vậy tôi rất vui vì đã gõ nó lên! Ví dụ lớn nhất là f(l)ban đầu được triển khai như một vòng lặp vô hạn đã bị phá vỡ khi tính toán được thực hiện, trước khi tôi nhận ra đệ quy sẽ hoạt động. Nó chỉ cho thấy rằng giải pháp đầu tiên bạn nghĩ sẽ không luôn là tốt nhất. :)

Matlab, (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

được sử dụng như thế này:

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 #, xuống tới 354 ...

Cách tiếp cận khác với TheBestOne được sử dụng.

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);
        }
    }
}