고층 빌딩 도전 의 짧은 버전

직무

건물 높이의 배열과 양의 정수가 주어지면 k정확하게 k건물이 표시 되도록 높이의 모든 순열 (중복없이)을 찾으십시오 .

모든 건물은 그 뒤에 더 짧거나 같은 높이의 건물을 숨길 것입니다.

입력 및 출력의 모든 형식이 유효합니다.

입력 배열은 절대로 비어 있지 않습니다.

정확히 많은 건물을 볼 수없는 경우에는 대답은 할 수 없지만 오류는없는 것을 출력하십시오.

예 :

(출력 길이는 매우 긴 출력에 대해 표시되지만 출력은 가능한 모든 순열이어야합니다)

input:[1,2,3,4,5],2
output: 50

input:[5,5,5,5,5,5,5,5],2
output: []

input:[1,2,2],2
output:[(1,2,2)]
Seeing from the left, exactly 2 buildings are visible.

input:[1,7,4],2
output:[(4, 7, 1), (1, 7, 4), (4, 1, 7)]

input:[1,2,3,4,5,6,7,8,9],4
output:67284

input:[34,55,11,22],1
output:[(55, 34, 11, 22), (55, 22, 34, 11), (55, 34, 22, 11), (55, 11, 34, 22), (55, 22, 11, 34), (55, 11, 22, 34)]

input:[3,4,1,2,3],2
output:31

이것은 코드 골프이므로 가장 짧은 코드가 승리합니다.

선택 사항 : 가능하면 다음과 같은 것을 추가 할 수 있습니다 if length is greater than 20: print length else print answer. 코드가 아닌 바닥 글에서.

05AB1E , 10 9 바이트

œÙʒη€àÙgQ

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 (거의 테스트 [1,2,3,4,5,6,7,8,9],4시간 초과).
TIO의 바닥 글은 하단에서 OP가 요청한 내용을 수행합니다.

선택 사항 : 가능하면 다음과 같은 것을 추가 할 수 있습니다 if length is greater than 20: print length else print answer. 코드가 아닌 바닥 글에서.

설명:

œ            # Permutations of the (implicit) input-list
             #  i.e. [1,2,2] → [[1,2,2],[1,2,2],[2,1,2],[2,2,1],[2,1,2],[2,2,1]]
 Ù           # Only leave the unique permutations
             #  i.e. [[1,2,2],[1,2,2],[2,1,2],[2,2,1],[2,1,2],[2,2,1]]
             #   → [[1,2,2],[2,1,2],[2,2,1]]
  ʒ          # Filter it by:
   η         #  Push the prefixes of the current permutation
             #   i.e. [1,2,2] → [[1],[1,2],[1,2,2]]
    ۈ       #  Calculate the maximum of each permutation
             #   i.e. [[1],[1,2],[1,2,2]] → [1,2,2]
      Ù      #  Only leave the unique maximums
             #   i.e. [1,2,2] → [1,2]
       g     #  And take the length
             #   i.e. [1,2] → 2
        Q    #  And only leave those equal to the second (implicit) input
             #   i.e. 2 and 2 → 1 (truthy)

하스켈, 73 바이트

import Data.List
f n=filter((n==).length.nub.scanl1 max).nub.permutations

온라인으로 사용해보십시오!

젤리 , 12 10 바이트

Œ!Q»\QL=ʋƇ

온라인으로 사용해보십시오!

@Erik the Outgolfer에 의해 -2 바이트

이것은 건물 높이 k를 그 순서대로 취하는 2 차원 함수 입니다.

Œ!                All permutations of first input
Œ!Q               Unique permutations of first input
   »\              Running maximum
     Q             Unique values
      L            Length of this array
       =           Equals k
        ʋ        Create a monad from these 4 links
   »\QL=ʋ        "Are exactly k buildings visible in arrangement x?"
         Ƈ     Filter if f(x)
Œ!Q»\QL=ʋƇ     All distinct perms of first input with k visible buildings.

Pyth, 18 16 바이트

fqvzl{meSd._T{.p

여기서 사용해보십시오 .

Pyth 인터프리터의 온라인 버전은 가장 큰 테스트 사례에서 메모리 오류를 발생시킵니다.

f                       Filter lambda T:
  q                       Are second input and # visible buildings equal?
    v z                     The second input value
    l {                     The number of unique elements in
        m                   the maximums
          e S d             ...
          ._ T              of prefixes of T
    { .p                  over unique permutations of (implicit first input)

펄 6 , 81 63 바이트

nwellnhof 덕분에 -18 바이트!

{;*.permutations.unique(:with(*eqv*)).grep:{$_==set [\max] @_}}

온라인으로 사용해보십시오!

입력 커리를 취하는 익명 코드 블록 f(n)(list). 예 : . 그것은 .unique(:with(*eqv*))짜증나게 길지만:(

설명:

{;                                                            }  # Anonymous code block
  *.permutations.unique(:with(*eqv*))  # From all distinct permutations
                                     .grep:{                 }  # Filter where
                                                set [\max] @_   # Visible buildings
                                            $_==      # Equals num

Japt , 11 바이트

á f_åÔâ Ê¥V

온라인으로 사용해보십시오!

더 긴 출력의 } l경우 끝에 추가 하면 길이가 대신 출력됩니다. 온라인 통역사 [1,2,3,4,5,6,7,8,9],4는 길이 또는 목록 출력에 관계없이 테스트 케이스에 대해 시간 종료됩니다 .

설명:

á              :Get all permutations
  f_           :Keep only ones where:
    åÔ         : Get the cumulative maximums (i.e. the visible buildings)
      â Ê      : Count the number of unique items
         ¥V    : True if it's the requested number

자바 스크립트 (ES6) 108 107 바이트

로 입력을 (k)(array)받습니다. 로 결과를 인쇄합니다 alert().

k=>P=(a,p=[],n=k,h=0)=>a.map((v,i)=>P(a.filter(_=>i--),[...p,v],n-(v>h),v>h?v:h))+a||n||P[p]||alert(P[p]=p)

온라인으로 사용해보십시오!

댓글

k =>                        // k = target number of visible buildings
  P = (                     // P = recursive function taking:
    a,                      //   a[] = list of building heights
    p = [],                 //   p[] = current permutation
    n = k,                  //   n = counter initialized to k
    h = 0                   //   h = height of the highest building so far
  ) =>                      //
    a.map((v, i) =>         // for each value v at position i in a[]:
      P(                    //   do a recursive call:
        a.filter(_ => i--), //     using a copy of a[] without the i-th element
        [...p, v],          //     append v to p[]
        n - (v > h),        //     decrement n if v is greater than h
        v > h ? v : h       //     update h to max(h, v)
      )                     //   end of recursive call
    )                       // end of map()
    + a ||                  // unless a[] was not empty,
    n ||                    // or n is not equal to 0,
    P[p] ||                 // or p[] was already printed,
    alert(P[p] = p)         // print p[] and store it in P

파이썬 2 , 114 113 바이트

lambda a,n:{p for p in permutations(a)if-~sum(p[i]>max(p[:i])for i in range(1,len(p)))==n}
from itertools import*

온라인으로 사용해보십시오!

_{ovs 덕분에 -1 바이트}

파이썬 3 , 113 바이트

lambda a,n:{p for p in permutations(a)if sum(v>max(p[:p.index(v)]+(v-1,))for v in{*p})==n}
from itertools import*

온라인으로 사용해보십시오!

J, 43 38 바이트

Kevin의 O5AB13 답변에서 최적화를 통합 한 후 -5 바이트

(]#~[=([:#@~.>./\)"1@])[:~.i.@!@#@]A.]

온라인으로 사용해보십시오!

언 골프

(] #~ [ = ([: #@~. >./\)"1@]) ([: ~. i.@!@#@] A. ])

설명

우리는 가능한 모든 perm을 나열하고 i.@!@#@] A. ]그것으로 uniq 항목을 취한 ~.다음 보이는 건물 수로 필터링합니다. 왼쪽 입력과 같아야합니다.

핵심 논리는 괄호 동사에 있으며 보이는 건물 수를 계산합니다.

([: #@~. >./\)

여기서 우리는 최대 스캔 >./\을 사용하여 지금까지 가장 높은 건물의 집계를 유지합니다. 그런 다음 최대 스캔의 고유 한 요소 만 사용하면 보이는 건물의 수입니다.