एक शेल्फ पर किताबें

Question

मेरे पास कुछ किताबें और एक बुकशेल्फ़ है। मैं यथासंभव अधिक से अधिक पुस्तकों को शेल्फ पर रखना चाहूंगा लेकिन मेरे पास एक नियम है। पुस्तकों के सभी आयाम (ऊंचाई, चौड़ाई और गहराई) को शेल्फ पर एक गैर-बढ़ते क्रम बनाना चाहिए।

इसका मतलब यह है कि प्रत्येक पुस्तकों को कम से कम उतना ही उच्च होना चाहिए जितना स्वयं के बाद। वही चौड़ाई और गहराई के लिए जाता है। आप उनकी ऊँचाई, चौड़ाई और गहराई को स्वैप करने के लिए किताबों को नहीं घुमा सकते।

आपको एक प्रोग्राम या फ़ंक्शन लिखना चाहिए जो इनपुट आउटपुट के रूप में सभी पुस्तकों के आयाम देता है या उन पुस्तकों की अधिकतम संख्या लौटाता है जिन्हें मैं शेल्फ पर रख सकता हूं।

इनपुट

• सकारात्मक पूर्णांकों के त्रिगुणों की एक सूची जहां प्रत्येक त्रिपाठी पुस्तक की ऊंचाई, चौड़ाई और गहराई को परिभाषित करता है।
• इनपुट सूची में कम से कम एक ट्रिपल होगा।
• किसी भी संख्या के आयामों के साथ दो पुस्तकों की लंबाई समान हो सकती है।

उत्पादन

• एक एकल सकारात्मक पूर्णांक, पुस्तकों की अधिकतम संख्या जो नियम का पालन करते हुए शेल्फ पर फिट होती है।

समय की जटिलता

आपके एल्गोरिथ्म में पुस्तकों की संख्या में सबसे खराब स्थिति वाला समय बहुपद होना चाहिए । इसका मतलब यह है कि उदाहरण के लिए निम्नलिखित समय जटिलताएँ सभी मान्य हैं: O (N ^ 3), O (लॉग (N) * N ^ 2), O (N) और निम्नलिखित निम्नलिखित अमान्य हैं: O (2 ^ N), ओ (एन!), ओ (एन ^ एन)।

उदाहरण

इनपुट => आउटपुट

(1, 1, 1) =>  1

(5, 2, 5), (1, 3, 5) =>  1

(5, 2, 5), (1, 2, 5) =>  2

(2, 2, 2), (2, 2, 2), (2, 2, 2), (1, 3, 6) =>  3

(1, 2, 5), (1, 3, 5), (1, 2, 8), (1, 2, 5), (7, 7, 7) =>  4

(5, 19, 3), (9, 4, 16), (15, 16, 13), (7, 4, 16), (1, 13, 14), (20, 1, 15), (9, 8, 19), (4, 11, 1) =>  3

(1, 1, 18), (1, 13, 7), (14, 1, 17), (8, 15, 16), (18, 8, 12), (8, 8, 15), (10, 1, 14), (18, 4, 6), (10, 4, 11), (17, 14, 17), (7, 10, 10), (19, 16, 17), (13, 19, 2), (16, 8, 13), (14, 6, 12), (18, 12, 3) =>  5

यह कोड गोल्फ है इसलिए सबसे छोटी प्रविष्टि जीतती है।

एक संबंधित दिलचस्प पुस्तक छँटाई चुनौती: बुक स्टैक सॉर्ट ।

Comments

क्या आपका मतलब है कि इसे घटते क्रम का रूप देना चाहिए ? यही कारण है कि यदि प्रत्येक पुस्तक कम से कम उतनी ही ऊँची हो, जब तक कि प्रत्येक पुस्तक समान ऊँचाई की न हो।

— mbomb007

@ mbomb007 सही, "गैर-घटने" को "गैर-बढ़ती" में बदल दिया।

— यादृच्छिक

Answer 1

पायथन 3: 436 बाइट्स

सबसे पहले मैंने इसे एनपी- चक्र के साथ एक निर्देशित ग्राफ में सबसे लंबे सरल पथ को खोजने की पूरी समस्या के रूप में देखा । हालांकि, ग्राफ में हर चक्र (वास्तव में एक पूर्ण उपसमूह) को एकल शीर्ष के रूप में दर्शाया जा सकता है। दूसरे शब्दों में, एक किताब के रूप में समान पुस्तकों को एक इकाई के रूप में शेल्फ पर रखा जाना चाहिए। इसके बाद हम एक निर्देशित चक्रीय ग्राफ का निर्माण कर सकते हैं जहां a-> b का अर्थ है कि बी शेल्फ पर चल सकता है। अंत में, हम एक पुनरावर्ती पद्धति का उपयोग करके आउट ट्री (एस) की अधिकतम ऊंचाई पाते हैं।

import sys
b=[]
n={}
r=[]
for L in sys.stdin.readlines():z=[int(x)for x in L.split()];r+=[z];z in b or b+=[z]
def l(a,b):return a[0]<=b[0]and a[1]<=b[1]and a[2]<=b[2]
R=range(len(b))
for i in R: 
    n[i]=[]
    for j in R:i!=j and l(b[i],b[j])and n[i]+=[j]
def L(t):
    global v;best=0
    if t in v:
            return v[t]
    for s in n[t]:best=max(best,L(s)+1)
    v[t]=best+r.count(b[t])-1;return best
m=0
for i in R:v={};m=max(L(i)+1,m)
print(m)

Comments

यह एक अच्छा समाधान है, लेकिन यह वास्तव में अभी तक गोल्फ नहीं है। मैं एक बार इसे बढ़ा दूंगा।

— इसहाक

Answer 2

अजगर, 40 बाइट्स

KYleolNe.eaK+e+]])olNf.A.eg@YbZeT<Kk]YSQ

तेज नहीं है, लेकिन यह बहुपद है।

पायथन 3 समकक्ष:

def num_books(l):
    l = sorted(l)
    s = []
    for i, Y in enumerate(l):
        s.append(max([T for T in s[:i]
                      if all(Y[e] >= t for e, t in enumerate(T[-1]))] + [[]],
                     key=len) + [Y])
    return max(len(u) for u in s)

Comments

पायथन 3 संस्करण स्पष्ट गोल्फ के साथ 177 बाइट्स है। बस एक फी।

— mbomb007

Answer 3

पायथन 2, 231 बाइट्स

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

मेरे कार्यक्रम को वर्तमान में पिछले दो उदाहरण गलत मिले। क्या कोई मुझे इसे ठीक करने में मदद कर सकता है, कृपया? धन्यवाद।

मैं 3 आयामों के 6 संभावित क्रमबद्ध क्रम के सभी सूची को सॉर्ट करता हूं, फिर देखें कि सूची में सबसे लंबे समय तक निरंतर आदेश देने वाला संबंध क्या है, फिर उन अधिकतम खोजें।

इसके अलावा, मुझे पता है कि अगर बहुत अधिक गोल्फ हो सकता है, लेकिन मैं यह पता नहीं लगा सकता कि क्या मैं ऐसा करने के reduceलिए उपयोग कर सकता हूं । सीधे शब्दों में कहें, यह तरीका मेरे दिमाग में विस्फोट के बिना उचित समय में बनाने के लिए सबसे आसान था।

from operator import*
from itertools import*
def f(t):
    m=1
    for l in(sorted(t,key=itemgetter(*o))for o in permutations(range(3))):
        c=1
        for k in range(len(l)-1):
            c+=all(i<=j for i,j in zip(l[k],l[k+1]))
        m=max(m,c)
    print m