Versione più breve di Skyscrapers Challenge

Compito

Data una serie di altezze degli edifici e un numero intero positivo k, trova tutte le permutazioni (senza duplicati) delle altezze in modo tale che siano esattamente kvisibili gli edifici.

Qualsiasi edificio nasconderà dietro di sé tutti gli edifici più corti o di uguale altezza.

Qualsiasi formato per input e output è valido.

L'array di input non sarà mai vuoto.

Nel caso in cui non sia possibile vedere esattamente altrettanti edifici, emettere tutto ciò che non può essere una risposta ma nessun errore.

Esempi:

(La lunghezza dell'output viene visualizzata per output molto lunghi, ma l'output dovrebbe essere tutte le possibili permutazioni)

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

Questo è code-golf, quindi vince il codice più corto

Opzionale: se possibile, puoi aggiungere qualcosa di simile if length is greater than 20: print length else print answer. Nel piè di pagina, non nel codice.

05AB1E , 10 9 byte

œÙʒη€àÙgQ

Provalo online o verifica (quasi) tutti i casi di test ( [1,2,3,4,5,6,7,8,9],4timeout del test case ).
Il piè di pagina del TIO fa ciò che OP ha chiesto in fondo:

Opzionale: se possibile, puoi aggiungere qualcosa di simile if length is greater than 20: print length else print answer. Nel piè di pagina, non nel codice.

Spiegazione:

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

Provalo online!

Gelatina , 12 10 byte

Œ!Q»\QL=ʋƇ

Provalo online!

-2 byte di @Erik the Outgolfer

Questa è una funzione diadica che prende le altezze dell'edificio e kin quell'ordine.

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

Provalo qui .

Si noti che la versione online dell'interprete Pyth genera un errore di memoria nel caso di test più grande.

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 grazie a nwellnhof!

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

Provalo online!

Blocco di codice anonimo che accetta input al curry, ad es f(n)(list). Questo .unique(:with(*eqv*))è fastidiosamente lungo però:(

Spiegazione:

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

Provalo online!

Per gli output più lunghi, l'aggiunta } lalla fine genererà invece la lunghezza. L'interprete online scade per il[1,2,3,4,5,6,7,8,9],4 caso di test, indipendentemente dall'output della lunghezza o dell'elenco.

Spiegazione:

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

Accetta input come (k)(array). Stampa i risultati con 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)

Provalo online!

Commentate

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*

Provalo online!

_{-1 byte, grazie a 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*

Provalo online!

J, 43 38 byte

-5 byte dopo aver incorporato un'ottimizzazione dalla risposta O5AB13 di Kevin

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

Provalo online!

ungolfed

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

spiegazione

stiamo semplicemente elencando tutti i possibili permanenti i.@!@#@] A. ], prendendo gli elementi uniq con~. , quindi filtrandoli per il numero di edifici visibili, che devono essere uguali all'input sinistro.

la logica chiave è nel verbo tra parentesi che calcola il numero di edifici visibili:

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

Qui usiamo una scansione massima >./\per tenere un conto dell'edificio più alto visto finora. Quindi prendiamo solo gli elementi unici della scansione massima, e questo è il numero di edifici visibili.