Phiên bản ngắn hơn của Thử thách nhà chọc trời

Bài tập

Cho một mảng các chiều cao của tòa nhà và một số nguyên dương k, tìm tất cả các hoán vị (không trùng lặp) của các độ cao sao cho chính xác các ktòa nhà có thể nhìn thấy được.

Bất kỳ tòa nhà nào cũng sẽ ẩn tất cả các tòa nhà có chiều cao ngắn hơn hoặc bằng nhau phía sau nó.

Bất kỳ định dạng cho đầu vào và đầu ra là hợp lệ.

Mảng đầu vào sẽ không bao giờ trống

Trong trường hợp không thể thấy chính xác như nhiều tòa nhà, hãy xuất bất cứ thứ gì không thể là câu trả lời nhưng không có lỗi.

Ví dụ:

(Độ dài của đầu ra được hiển thị cho các đầu ra rất dài, nhưng đầu ra của bạn phải là tất cả các hoán vị có thể)

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

Đây là môn đánh gôn nên mã ngắn nhất sẽ thắng

Tùy chọn: Nếu có thể, bạn có thể thêm một cái gì đó như if length is greater than 20: print length else print answer. Trong phần chân trang, không phải trong mã.

05AB1E , 10 9 byte

œÙʒη€àÙgQ

Dùng thử trực tuyến hoặc xác minh (gần như) tất cả các trường hợp thử nghiệm (trường hợp thử nghiệm[1,2,3,4,5,6,7,8,9],4 hết thời gian ).
Footer của TIO thực hiện những gì OP yêu cầu ở phía dưới:

Tùy chọn: Nếu có thể, bạn có thể thêm một cái gì đó như if length is greater than 20: print length else print answer. Trong phần chân trang, không phải trong mã.

Giải trình:

œ            # 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)

Haskell, 73 byte

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

Hãy thử trực tuyến!

Thạch , 12 10 byte

Œ!Q»\QL=ʋƇ

Hãy thử trực tuyến!

-2 byte bởi @Erik the Outgolfer

Đây là một chức năng dyadic lấy chiều cao của tòa nhà và ktheo thứ tự đó.

Œ!                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.

Bình thường, 18 16 byte

fqvzl{meSd._T{.p

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

Lưu ý rằng phiên bản trực tuyến của trình thông dịch Pyth đưa ra lỗi bộ nhớ trong trường hợp thử nghiệm lớn nhất.

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)

Perl 6 , 81 63 byte

-18 byte nhờ nwellnhof!

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

Hãy thử trực tuyến!

Khối mã ẩn danh lấy đầu vào bị khóa, vd f(n)(list). Điều đó .unique(:with(*eqv*))thật khó chịu:(

Giải trình:

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

Japt , 11 byte

á f_åÔâ Ê¥V

Hãy thử trực tuyến!

Đối với các đầu ra dài hơn, thêm } lvào cuối sẽ xuất ra độ dài thay thế. Trình thông dịch trực tuyến hết thời gian cho [1,2,3,4,5,6,7,8,9],4trường hợp thử nghiệm, bất kể xuất ra độ dài hoặc danh sách.

Giải trình:

á              :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

JavaScript (ES6), 108 107 byte

Đưa đầu vào là (k)(array). In kết quả với 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)

Hãy thử trực tuyến!

Đã bình luận

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

Python 2 , 114 113 byte

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*

Hãy thử trực tuyến!

_{-1 byte, nhờ có lò nướng}

Python 3 , 113 byte

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*

Hãy thử trực tuyến!

J, 43 38 byte

-5 byte sau khi kết hợp tối ưu hóa từ câu trả lời O5AB13 của Kevin

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

Hãy thử trực tuyến!

vô dụng

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

giải trình

chúng tôi chỉ liệt kê tất cả các perm có thể i.@!@#@] A. ], lấy các mục uniq của chúng với~. , sau đó lọc chúng theo số lượng tòa nhà có thể nhìn thấy, phải bằng đầu vào bên trái.

logic chính là trong động từ ngoặc đơn làm dịu số lượng tòa nhà có thể nhìn thấy:

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

Ở đây chúng tôi sử dụng quét tối đa >./\để theo dõi tòa nhà cao nhất từng thấy cho đến nay. Sau đó, chúng tôi chỉ lấy các yếu tố duy nhất của quét tối đa và đó là số lượng tòa nhà có thể nhìn thấy.