Gökdelenler Yarışması'nın daha kısa versiyonu

Görev

Bir dizi bina yüksekliği ve pozitif bir tamsayı göz önüne alındığında, yüksekliklerin ktüm permütasyonlarını (kopyalar olmadan) bulun, böylece kbinalar tam olarak görülebilir.

Herhangi bir bina, arkasındaki tüm kısa veya eşit yükseklikte binaları gizleyecektir.

Giriş ve çıkış biçimleri geçerlidir.

Giriş dizisi asla boş olmayacak.

Pek çok binayı tam olarak görmek mümkün değilse, cevap olamayacak, ancak hata olmayacak her şeyi çıktılayın.

Örnekler:

(Çok uzun çıkışlar için çıkış uzunluğu gösterilir, ancak çıktınızın tüm olası permütasyonlar olması gerekir)

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

Bu kod golf, bu yüzden en kısa kod kazanır

İsteğe bağlı: Mümkünse, benzer bir şey ekleyebilirsiniz if length is greater than 20: print length else print answer. Altbilgide, kodda değil.

05AB1E , 10 9 bayt

œÙʒη€àÙgQ

Çevrimiçi deneyin veya tüm test senaryolarını doğrulayın (neredeyse) (test vakası [1,2,3,4,5,6,7,8,9],4zaman aşımına uğradı).
TIO'nun altbilgisi OP'nin altta sorduğu şeyi yapar:

İsteğe bağlı: Mümkünse, benzer bir şey ekleyebilirsiniz if length is greater than 20: print length else print answer. Altbilgide, kodda değil.

Açıklama:

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

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

Çevrimiçi deneyin!

Jöle , 12 10 bayt

Œ!Q»\QL=ʋƇ

Çevrimiçi deneyin!

@Erik the Outgolfer tarafından -2 bayt

Bu, bina yüksekliklerini ve kbu sırayla alan ikili bir fonksiyondur .

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

fqvzl{meSd._T{.p

Burada deneyin .

Pyth yorumlayıcısının çevrimiçi sürümünün en büyük test senaryosuna bir bellek hatası verdiğini unutmayın.

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 bayt

Nwellnhof sayesinde -18 bayt!

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

Çevrimiçi deneyin!

Girdi köri alan anonim kod bloğu, ör f(n)(list). Yani .unique(:with(*eqv*))uzun olsa rahatsız edici olduğu:(

Açıklama:

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

Japt , 11 bayt

á f_åÔâ Ê¥V

Çevrimiçi deneyin!

Daha uzun çıktılar için } l için, sonuna uzunluğun çıktısını verecektir. Çevrimiçi tercüman,[1,2,3,4,5,6,7,8,9],4 , uzunluk veya listenin çıktısına bakılmaksızın test senaryosu uğrar.

Açıklama:

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

Girişi alır (k)(array). Sonuçları ile yazdırır 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)

Çevrimiçi deneyin!

Yorumlananlar

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 , 114113 bayt

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*

Çevrimiçi deneyin!

_{-1 bayt, ovs sayesinde}

Python 3 , 113 bayt

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*

Çevrimiçi deneyin!

J, 43 38 bayt

Kevin'in O5AB13 yanıtından bir optimizasyon ekledikten sonra -5 bayt

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

Çevrimiçi deneyin!

ungolfed

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

açıklama

sadece olası tüm izinleri listeliyoruz i.@!@#@] A. ],~. , ardından bunları, sol girişe eşit olması gereken görünür bina sayısına göre filtreleriz.

anahtar mantık, görünür binaların sayısını hesaplayan parantez içinde bulunur:

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

Burada >./\şimdiye kadar görülen en yüksek binanın bir çetelesini tutmak için maksimum bir tarama kullanıyoruz . Sonra sadece maksimum taramanın benzersiz öğelerini alıyoruz ve bu görünür binaların sayısı.