Versi lebih pendek dari Skyscrapers Challenge

Tugas

Diberikan array ketinggian bangunan dan bilangan bulat positif k, temukan semua permutasi (tanpa duplikat) dari ketinggian sedemikian rupa sehingga kbangunan benar-benar terlihat.

Setiap bangunan akan menyembunyikan semua bangunan dengan ketinggian lebih pendek atau sama di belakangnya.

Semua format untuk input dan output adalah valid.

Array input tidak akan pernah kosong.

Dalam hal ini tidak mungkin untuk melihat persis seperti banyak bangunan, mengeluarkan apa pun yang tidak bisa menjadi jawaban tetapi tidak ada kesalahan.

Contoh:

(Panjang output ditampilkan untuk output yang sangat panjang, tetapi output Anda harus semua permutasi yang mungkin)

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

Ini adalah kode-golf sehingga kode terpendek menang

Opsional: Jika memungkinkan, dapatkah Anda menambahkan sesuatu seperti if length is greater than 20: print length else print answer. Di bagian footer, bukan di kode.

05AB1E , 10 9 byte

œÙʒη€àÙgQ

Cobalah secara online atau verifikasi (hampir) semua test case (waktu test case [1,2,3,4,5,6,7,8,9],4habis).
Footer TIO melakukan apa yang diminta OP di bagian bawah:

Opsional: Jika memungkinkan, dapatkah Anda menambahkan sesuatu seperti if length is greater than 20: print length else print answer. Di bagian footer, bukan di kode.

Penjelasan:

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

Cobalah online!

Jelly , 12 10 byte

Œ!Q»\QL=ʋƇ

Cobalah online!

-2 bytes oleh @Erik the Outgolfer

Ini adalah fungsi diadik yang mengambil ketinggian bangunan dan kdalam urutan itu.

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

fqvzl{meSd._T{.p

Coba di sini .

Perhatikan bahwa versi online interpreter Pyth melempar kesalahan memori pada case uji terbesar.

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 terima kasih kepada nwellnhof!

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

Cobalah online!

Blok kode anonim yang mengambil input kari, mis f(n)(list). Itu .unique(:with(*eqv*))sangat panjang:(

Penjelasan:

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

Cobalah online!

Untuk hasil yang lebih panjang, tambahkan } l ke ujung akan menghasilkan panjang sebagai gantinya. Juru bahasa online kehabisan waktu untuk [1,2,3,4,5,6,7,8,9],4uji kasus, terlepas dari menghasilkan panjang atau daftar.

Penjelasan:

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

Mengambil input sebagai (k)(array). Mencetak hasilnya dengan 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)

Cobalah online!

Berkomentar

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*

Cobalah online!

_{-1 byte, terima kasih atas ovs}

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*

Cobalah online!

J, 43 38 byte

-5 byte setelah memasukkan optimasi dari jawaban O5AB13 Kevin

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

Cobalah online!

ungolfed

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

penjelasan

kami hanya mencantumkan semua izin yang mungkin i.@!@#@] A. ], dengan mengambil item unik darinya~. , lalu memfilternya berdasarkan jumlah bangunan yang terlihat, yang harus sama dengan input kiri.

kuncinya adalah dalam kata kerja kurung yang menghitung jumlah bangunan yang terlihat:

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

Di sini kami menggunakan pemindaian maks >./\untuk menjaga penghitungan bangunan tertinggi yang terlihat sejauh ini. Kemudian kita hanya mengambil elemen unik dari pemindaian maks, dan itulah jumlah bangunan yang terlihat.