Укороченная версия Skyscrapers Challenge

задача

Учитывая массив высот зданий и положительное целое число 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 делает то, что ОП спросил внизу:

Необязательно: Если возможно, вы можете добавить что-то вроде 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)

Haskell, 73 байта

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

Попробуйте онлайн!

Желе , 12 10 байт

Œ!Q»\QL=ʋƇ

Попробуйте онлайн!

-2 байта @ Эрик Outgolfer

Это диадическая функция, принимающая высоту здания и kв таком порядке.

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

Perl 6 , 81 63 байта

-18 байт благодаря nwellnhof!

{;*.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

JavaScript (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

Python 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*

Попробуйте онлайн!

_{-1 байт, спасибо ovs}

Python 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 байт

-5 байт после включения оптимизации из ответа Кевина O5AB13

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

Попробуйте онлайн!

ungolfed

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

объяснение

мы просто перечисляем все возможные варианты i.@!@#@] A. ], выбираем их уникальные элементы ~., затем фильтруем их по количеству видимых зданий, которое должно равняться левому входу.

ключевая логика заключена в глагол в скобках, который подсчитывает количество видимых зданий:

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

Здесь мы используем максимальное сканирование >./\для подсчета самого высокого здания, которое мы видели до сих пор. Затем мы просто берем уникальные элементы максимального сканирования, и это количество видимых зданий.