इमारतों को छिपाओ

Question

गगनचुंबी इमारतों चैलेंज का छोटा संस्करण

कार्य

बिल्डिंग हाइट्स की एक सरणी और एक सकारात्मक पूर्णांक को देखते हुए, हाइट्स के 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। पाद लेख में, कोड में नहीं।

Comments

क्या आउटपुट को सभी योग्य क्रमपरिवर्तन, या उसके बाद की संख्या होना चाहिए?

— लुइस मेंडो

यह सभी योग्य क्रमपरिवर्तन @LuisMendo

— वेदांत

सुझाए गए परीक्षण का मामला: [1,2,3,4,5],5 -> [(1,2,3,4,5)]। वर्तमान परीक्षण मामलों में से कोई भी यह सुनिश्चित नहीं करता है कि उत्तर सभी इमारतों को दिखाने का समर्थन कर सकते हैं (हालांकि मुझे नहीं पता कि क्या वास्तव में कोई समस्या है)।

— कामिल दकरी

Answer 1

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)

Comments

प्रभावशाली, यहाँ हर एक बाइट फंक्शन ट्री का हिस्सा है!

— lirtosiast

@lirtosiast हाँ, 05AB1E के पास कभी-कभी कुछ बहुत कम निर्माण होते हैं, जो इस चुनौती में परिपूर्ण थे। :) यह वास्तव में आपके पाइथ उत्तर के समान है जो मैं देख रहा हूं। मजेदार बात यह है, यह है कि पाद लेख if length is greater than 20: print length; else print answer;कार्यक्रम की तुलना में बराबर लंबाई के ए ̶b̶y̶t̶e, ̶l̶o̶n̶g̶e̶r̶ है। xD

— केविन क्रूज़सेन

Answer 2

हास्केल, 73 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 3

जेली , 12 10 बाइट्स

Œ!Q»\QL=ʋƇ

इसे ऑनलाइन आज़माएं!

-2 बाइट्स द @ एरिक द आउटगोलर

यह एक रंगाई कार्य है जो इमारत की ऊँचाइयों और 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.

Comments

नई जय हो ʋ! (यह Ƈवास्तव में की तुलना में बहुत पुराना है : पी)

— निकोलग्राफ

Answer 4

पायथ, 18 16 बाइट्स

fqvzl{meSd._T{.p

इसे यहाँ आज़माएँ ।

ध्यान दें कि पायथ दुभाषिया का ऑनलाइन संस्करण सबसे बड़े परीक्षण के मामले में एक मेमोरी त्रुटि फेंकता है।

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)

Comments

वापसी पर स्वागत है! :-)

— लुइस मेंडो

Answer 5

पर्ल 6 , 81 63 बाइट्स

N18nhof के लिए -18 बाइट्स धन्यवाद!

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

Comments

एफडब्ल्यूआईडब्ल्यू , मैंने सिर्फ एक राडोको मुद्दा दायर किया ताकि हम ;अंततः उस कष्ट से छुटकारा पा सकें ;)

— nwellnhof

Answer 6

जाप , 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

Answer 7

जावास्क्रिप्ट (ईएस 6), 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

Answer 8

पायथन 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 बाइट, ओव्स के लिए धन्यवाद}

---

पायथन 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*

इसे ऑनलाइन आज़माएं!

Answer 9

जे, 43 38 बाइट्स

-5 बाइट्स केविन के O5AB13 उत्तर से अनुकूलन शामिल करने के बाद

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

इसे ऑनलाइन आज़माएं!

ungolfed

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

व्याख्या

हम केवल सभी संभावित परमिट को सूचीबद्ध कर रहे हैं i.@!@#@] A. ], इसके साथ uniq आइटम ले रहे हैं ~., फिर उन दृश्यमान बिल्डिंग की संख्या को फ़िल्टर कर रहे हैं, जिन्हें बाएं इनपुट के बराबर होना चाहिए।

प्रमुख तर्क पेरेटेटिकल क्रिया में है जो दृश्यमान इमारतों की संख्या को शांत करता है:

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

यहां हम >./\अब तक देखी गई सबसे ऊंची इमारत की एक टिक रखने के लिए एक अधिकतम स्कैन का उपयोग करते हैं। तब हम अधिकतम स्कैन के अद्वितीय तत्वों को लेते हैं, और यह दृश्यमान इमारतों की संख्या है।