이 질문은 온라인으로 플레이 할 수있는 숫자 배치 퍼즐 타워 (스카이 스크래퍼라고도 함)를 기반으로합니다 . 목표는 퍼즐을 풀고 각 행과 열을 따라 보이는 타워의 수를 알아내는 것입니다. 이것은 코드 골프이므로 가장 적은 바이트가 이깁니다.

타워 작동 방식

A - 타워 퍼즐에 대한 해결책은 라틴 정사각형 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

APL 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에서

파이썬 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]]) ). 출력은 단일 플랫 목록입니다.

언 골프 드 :

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

필수 Pyth 포트.

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

온라인으로 시도해보십시오 ...하지만 불행히도 보안상의 이유로 온라인 통역사는 중첩 된 괄호에 eval을 사용할 수 없습니다. 해결 방법 코드를 사용해보십시오.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].

(몇 바이트를 골프를 도운 @isaacg에게 감사드립니다)

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

APL, 44

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

여기서 테스트했습니다.

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

여기에서 시도하십시오.

하스켈, 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]

Mathematica, 230,120,116,113110 바이트

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

자바 스크립트, 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,[],[])

브라우저의 JavaScript 콘솔에서 평가하십시오 (Firefox 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]]));

ungolfed 코드의 현재 화신은 다음과 같습니다. 따르기가 점점 어려워지고 있습니다.

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 차원 배열로 평평하게하고 4 방향에서 모두 행으로 오프셋을 미리 계산하는 것이 었습니다. 그런 다음 Shift 키를 사용하여 다음 타워가 허위인지 테스트하고, 그렇다면 타워마다 카운터를 증가시킵니다.

오프셋을 미리 계산하지 않고 1D 입력 배열에서 일종의 오버플로 / 모듈로를 사용하여이를 향상시킬 수있는 많은 방법이 있기를 바랍니다. 그리고 아마도 내 루프를 결합하고 더 기능적이고 중복되지 않습니다.

모든 제안을 부탁드립니다!

업데이트 # 1 : 진보, 우리는 기술을 가지고 있습니다! 미리 계산 된 오프셋을 제거하고 함께 삼항 연산자와 인라인으로 처리 할 수있었습니다. 또한 내 if 문을 제거하고 for 루프를 while으로 변환 할 수있었습니다.

업데이트 # 2 : 이것은 매우 실망 스럽습니다. 나를위한 피자 파티가 없습니다. 나는 기능을 수행하고 재귀를 사용하면 많은 바이트를 줄일 수 있다고 생각했지만 처음 몇 번의 시도는 100 자까지 커졌습니다. 필사적으로 필자는 ES6 팻 화살표 기능을 사용하여 실제로 그것을 파싱했습니다. 그런 다음 부울 연산자를 산술 연산자로 바꾸고 가능하면 파렌, 세미콜론 및 공백을 제거했습니다. 나는 심지어 var 선언을 끝내고 로컬 네임 스페이스를 로컬 심볼로 오염시켰다. 더럽고 더럽습니다. 이 모든 노력을 마친 후, 나는 8 번째 문자로 256 번으로 Update # 1 점수를 beat습니다. Blargh!

업데이트 # 1 기능에 동일한 무자비한 최적화 및 ES6 트릭을 적용하면이 점수를 1 마일 더 많이 얻었습니다. 나는 그것이 어떻게 보일지 알기 위해 업데이트 # 3을 할 수 있습니다.

업데이트 # 3 : 뚱뚱한 화살표 재귀 접근법에 더 많은 수명이 있음이 밝혀졌습니다 .2 차원 입력을 평평하게하는 대신 직접 작업하고 클로저 범위를 활용하는 것이 더 좋았습니다. 내부 배열 오프셋 계산을 두 번 다시 작성하고 같은 점수를 얻었 으므로이 접근법은 거의 다 사라질 수 있습니다!

자바 만 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;
        }
    }
}

어떤 팁이라도 대단히 감사하겠습니다!

파이썬 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

이것은 아마도 정말 가난한 골프 일 것입니다. 문제가 흥미 로웠다고 생각했기 때문에 다른 사람의 해결책을 보지 않고 문제를 해결하기로 결정했습니다. 이 문장을 입력 할 때이 질문에 대한 답을 아직 보지 못했습니다. 다른 사람이 이미 더 짧은 Python 프로그램을 수행했다면 놀라지 않을 것입니다.)

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)원래 재귀가 작동하기 전에 계산이 완료되었을 때 중단 된 무한 루프로 구현 된 것입니다. 생각하는 첫 번째 솔루션이 항상 최고는 아니라는 것을 보여줍니다. :)

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

이처럼 사용 :

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