पार्किंग सुपरवाइजर

Question

परिचय

आप एक पार्किंग के पर्यवेक्षक हैं और आपका प्रबंधक आकार को चरम तक सिकोड़ने की तैयारी कर रहा है।

यह पिछले साल के पैट टॉप स्तर में एक समस्या का एक सरलीकृत और अनुकूलित संस्करण है।

चुनौती

आपको यह गणना करने के लिए कहा जाता है कि कितनी कारें एक ही समय में, अधिकांश में हैं ।

मानक नियम लागू होते हैं। और यह एक कोड-गोल्फ है इसलिए सबसे छोटा कोड जीतता है।

पहली पंक्ति प्रविष्टियों की मात्रा है (इससे अधिक नहीं 100,000, यदि आप चाहें तो आपके इनपुट में यह रेखा नहीं हो सकती है, क्योंकि यह केवल इनपुट इनपुट समाप्त होने का निर्धारण करने के लिए एक संक्षिप्त विवरण है )। निम्न पाठ में प्रति पंक्ति एक प्रविष्टि है। और प्रत्येक प्रविष्टि में तीन नंबर शामिल हैं:

<Car plate number> <Time (seconds) since open> <0(In) | 1(Out)>

संशोधन 2: इनपुट के रूप में त्रिक के एक सरणी का उपयोग करना ठीक है।

संशोधन 3: आप एक प्रविष्टि में संख्याओं के क्रम को बदल सकते हैं। और आप चुन सकते हैं कि किसका उपयोग करना है। (टिप्पणी अनुभाग देखें)

इनपुट मान्य होने की गारंटी है, यह मानते हुए:

• Car plate number10000~ की श्रेणी में पूर्णांक है99999
• Time0~ की श्रेणी में पूर्णांक है86400

तथा

• प्रविष्टियां जरूरी नहीं कि कालानुक्रमिक रूप से आदेशित हों।
• पहले सेकंड से पहले कोई कार नहीं है।
• नहीं है जरूरी नहीं कि अंतिम क्षण के बाद कोई कार।
• अंदर जाने से पहले कोई कार नहीं निकलती।
• Car plate numberअनोखा है। (लेकिन एक ही कार एक से अधिक बार यात्रा कर सकती है)
• इसलिए जब यह पहले से ही कार में प्रवेश करने के लिए असंभव है।
• एक ही कार एक ही समय में और बाहर नहीं जाएगी time।
• माना जाता है कि एक कार में / बाहर के समय में बहुत कुछ होता है।

उदाहरण 1

इनपुट

11
97845 36000 1
75487 16500 1
12345 16 0
75486 3300 0
12345 6500 1
97845 32800 0
12345 16400 0
97846 16501 1
97846 16500 0
75486 8800 1
75487 3300 0

उत्पादन

3

व्याख्या

पर 16500, कार 12345और 75487पार्किंग में थे।

उदाहरण 2

मैंने इसे बनाया क्योंकि मुझे कई कोड इस पर विफल लगे।

इनपुट (पहली पंक्ति के साथ छोड़ दिया गया)

12345 16400 0
12345 16500 1
75487 16500 0
75487 16600 1

उत्पादन

2

व्याख्या

पर 16500, कार 12345और 75487पार्किंग में थे।

टिप्पणियों

दरअसल, आउटपुट के लिए तीनों की आवश्यकता नहीं होती है। कम से कम, आपको परिणाम के लिए केवल प्लेट + टाइम या इन / आउट + टाइम चाहिए। लेकिन एल्गोरिथ्म दो परिस्थितियों में थोड़ा अलग है, इसलिए छोटे होने का विकल्प एक निश्चित भाषा में अज्ञात रहता है। और निश्चित रूप से आप सभी तीन संख्याओं का उपयोग कर सकते हैं। इसलिए मैं उन्हें चुनौती देता हूं।

Comments

क्या कार प्लेट नंबर हमेशा 5 अंक लंबे होते हैं?

— टाइटस

@ मुझे लगता है कि 10000 से 99999 तक की संख्या हमेशा 5 अंकों की होती है।

— कीउ गण

जी आज मैं अंधा हूं।

— टाइटस

मुझे लगता है कि पहली बार छोड़ने से पहले एक कार फिर से प्रवेश नहीं कर सकती है? यह स्पष्ट रूप से कहा गया प्रतीत नहीं होता है।

— जॉन ड्वोरक

@JDDvorak एह माफ करना। नहीं ये नहीं हो सकता। यह कार प्लेट नंबर द्वारा निहित है, क्योंकि यह वास्तव में एक ही कार के लिए बहुत मुश्किल है जब वह पहले से ही उसमें है।

— कीउ गण

Answer 1

गणितज्ञ, 33 बाइट्स

-Min@Accumulate[2#2-1&@@@Sort@#]&

मुझे यह समझने के लिए समस्या कथन को बेहतर ढंग से पढ़ना था कि बहुत सरल एल्गोरिथम है जिसे लाइसेंस प्लेट की जानकारी की आवश्यकता नहीं है।

एक पूर्णांक लौट रहा है; इनपुट फॉर्मेट में ऑर्डर किए गए ट्रिपल्स की सूची है {time, 0|1, license plate}। हम Sortआईएनजी से शुरू करते हैं, जो सूची को कालानुक्रमिक बनाता है और 0एस से पहले सॉर्ट करके समय-संबंध भी तोड़ता है 1; तब 2#2-1&@@@आगमन / प्रस्थान की जानकारी रखता है और बाकी को भूल जाता है, और 0एस को -1एस में परिवर्तित करता है ।

Accumulateउस सूची के चल रहे योगों की गणना करता है; परिणाम हर आगमन / प्रस्थान के बाद पार्किंग में कारों की संख्या के नकारात्मक की एक सूची है । फिर Minइनमें से सबसे छोटा (सबसे नकारात्मक) उठाता है और नकारात्मक चिह्न छीन लिया जाता है।

मैथेमेटिका, 56 बाइट्स

Max[<|#|>~Count~0&/@FoldList[List,{},#3->#2&@@@Sort@#]]&

मूल सबमिशन (पहले कई टिप्पणियां इस सबमिशन को संदर्भित करती हैं)। एक पूर्णांक लौट रहा है; इनपुट फॉर्मेट में ऑर्डर किए गए ट्रिपल्स की सूची है {time, 0|1, license plate}।

जिस कारण से हम समय प्रविष्टि को पहले और अंदर / बाहर दूसरी प्रविष्टि के लिए चुनते हैं, वह इस Sort@#प्रकार है कि सूची कालानुक्रमिक है, और रिकॉर्ड प्रस्थान से पहले आ जाता है यदि वे एक साथ हैं। उसके बाद, #3->#2&@@@प्रपत्र के "नियमों" की एक सूची देता है license plate -> 0|1, फिर भी कालानुक्रमिक रूप से छांटा जाता है।

फिर, FoldList[List,{},...]नियमों की उस सूची के सभी प्रारंभिक खंडों की एक सूची बनाता है। वास्तव में, यह वास्तव में उन प्रारंभिक खंडों को गड़बड़ करता है; kऊपर गहराई 2 में एक नियम है, गहराई 3 में एक नियम है, ..., और गहराई में एक नियम के साथ एक सूची से किया जा रहा वें प्रारंभिक खंड समाप्त होता k+1। ( FoldList[Append,{},...]अधिक प्राकृतिक परिणाम प्राप्त होगा।) हालांकि, <|#|>इनमें से प्रत्येक प्रारंभिक खंड को एक "संघ" में बदल दिया जाता है, जिसके दो वांछनीय प्रभाव हैं: पहला, यह पूरी तरह से नेस्टेड-लिस्ट संरचना को पूरी तरह से समतल करता है जिसे हमने अभी बनाया है; और दूसरा, यह बाद में नियमों को पहले के नियमों को ओवरराइड करने के लिए मजबूर करता है, जो कि यहां हमें ठीक उसी तरह की जरूरत है-किसी भी कार के लिए, जिसने पार्किंग को छोड़ दिया है, इसकी प्रारंभिक प्रविष्टि का रिकॉर्ड अब पूरी तरह से चला गया है (और इसी तरह कारों के लिए जो फिर से प्रवेश करते हैं) ।

इतना सब करने के लिए छोड़ दिया है कि इनमें से प्रत्येक संघ में Countकितने 0एस हैं, और ले लो Max।

Comments

क्या यह हमेशा सही काम करेगा यदि कारें एक ही समय पर आती हैं और जाती हैं?

— क्रिश्चियन सेवर्स

आपका उत्तर गलत हो सकता है। अधिकतम जरूरी नहीं है कि जब कोई कार एक बार फिर से प्रवेश करती है तो यह एसोसिएशन का उपयोग करके प्रविष्टियों को मिटाने के लिए असुरक्षित है। इस तस्वीर को देखें: i.imgur.com/D5xUl3z.png स्पष्ट रूप से 16500 पर 3 कारें हैं।

— गण

@KeyuGan: मैंने दावा नहीं किया कि कार के दोबारा प्रवेश करने पर अधिकतम होता है। ध्यान दें कि मेरा समाधान प्रत्येक एकल प्रविष्टि / प्रस्थान के समय पार्किंग में कारों की संख्या को गिनाता है, और उन लोगों की अधिकतम लेता है।

— ग्रेग मार्टिन

शायद आप उदाहरण 2 की कोशिश कर सकते हैं

— कीयू गण

व्यक्तिगत रूप से मैं आपसे सहमत हूं। :) मैंने जो किया है वह मूल समस्या से परिभाषा की नकल करना है। मुख्य अंतर यह है कि मूल वाले को कार प्लेटों को छवियों से पहचाना जाना चाहिए और अंतिम परिणाम के रूप में मुद्रित किया जाना चाहिए।

— कीउ गण

Answer 2

हास्केल, 76 63 61 बाइट्स

@ नीमी के सुझाव की भिन्नता से 2 बाइट्स बचाए गए।

f l=maximum$scanl1(+)[(-1)^c|i<-[0..8^6],(_,b,c)<-l,i==2*b+c]

समस्या कथन द्वारा दिए गए क्रम में तिकड़ी की सूची के रूप में तर्क की अपेक्षा करता है।

प्रत्येक संभावित समय (और कुछ और) के लिए, हम पहले आने के लिए खोज करते हैं और फिर कार की घटनाओं को छोड़ने के लिए और उन्हें प्लस या माइनर्स की सूची में बदल देते हैं। हम इस सूची के आंशिक रकम लेते हैं और फिर इन आंशिक रकमों की अधिकतम सीमा।

Comments

ड्रॉप importऔर उपयोग करें [(-1)^c|i<-[1..86400],(_,b,c)<-l,i==b]।

— nimi

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

— क्रिश्चियन सिवर्स

Answer 3

PHP 7.1, 126 117 बाइट्स

for(;$s=file(i)[++$i];)$d[+substr($s,6)][$s[-2]]++;ksort($d);foreach($d as$a){$r=max($r,$n+=$a[0]);$n-=$a[1];}echo$r;

फ़ाइल से इनपुट लेता है i, पहली पंक्ति को अनदेखा करता है। के साथ चला -r।
इनपुट में एक अनुगामी न्यूलाइन की आवश्यकता है। विंडोज के -2साथ बदलें -3।

टूट - फूट

# generate 2-dim array; first index=time, second index=0/1 (in/out);
# values=number of cars arriving/leaging; ignore plate number
for(;$s=file(i)[++$i];) # read file line by line (includes trailing newline)
    $d[+substr($s,6)][$s[-2]]++;    # substring to int=>time, last but one character=>1/0
ksort($d);                      # sort array by 1st index (time)
foreach($d as$a)    # loop through array; ignore time
{
    $r=max($r,                      # 2. update maximum count
        $n+=$a[0]                   # 1. add arriving cars to `$n` (current no. of cars)
    );
    $n-=$a[1];                      # 3. remove leaving cars from `$n`
}
echo$r;                         # print result

Comments

क्षमा करें, यदि आप कोई फ़ंक्शन लिख रहे हैं, तो आप इनपुट के रूप में तीनों प्रकार के सरणी का उपयोग कर सकते हैं। मेरे दोस्तों और मेरा मानना ​​है कि गैर-गोल्फिंग भाषा को अधिक प्रतिस्पर्धी बनाने का यह एक अच्छा तरीका है अगर हम जटिल इनपुट के बिना किसी समस्या के बारे में बात कर रहे हैं।

— कीउ गण Key ’

@ कीयुगन: संकेत के लिए धन्यवाद; लेकिन इनपुट के रूप में एक सरणी के साथ, I'd को एक फ़ंक्शन की आवश्यकता होती है, और जिसमें दो बाइट्स खर्च होंगे, दोनों ट्रिप की एक सरणी के साथ और सरणियों के एक ट्रिपल के साथ। कार्य, सरणी मानचित्रण और कस्टम प्रकार PHP में भारी हैं। केवल जिस तरह से मैं कुछ भी बचा सकता था वह मेरे द्वारा तैयार किए $dगए इनपुट या सॉर्ट किए गए इनपुट के रूप में होगा (समय से और अंदर से)। और चुनौती से बहुत अधिक लेना होगा। संरेखित इनपुट ttttt i plateप्लेट संख्या के साथ संरेखित गणना के साथ 17 बाइट्स, 19 और बचाएगी।

— टाइटस

Answer 4

सी, 147 बाइट्स

एक पूरा कार्यक्रम, से इनपुट पढ़ता है stdin।

int r[86402]={},u,i,n,t;g(s,o){for(;s<86401;n<r[s]?n=r[s]:0,++s)r[s+o]+=o?-1:1;}main(){for(n=0;scanf("%d%d%d",&u,&t,&i)==3;g(t,i));printf("%d",n);}

इसे आइडोन पर आज़माएं ।

Comments

मेरा मानना है कि यह बीच रिक्त स्थान निकालने के लिए सुरक्षित है%d

— Keyu गण

उफ़, धन्यवाद। मैं scanfपर्याप्त उपयोग नहीं करता, मुझे लगता है।

— २०:५० पर ओवैकोडर ow ’

मुझे प्यार है cin। LOL

— कीउ गण

118 बाइट्स

— सीलिंगकैट

Answer 5

ऑक्टेव, 50 , 64 38 बाइट्स

@(A)-min(cumsum(sortrows(A)(:,2)*2-1))

@Greg मार्टिन के गणितज्ञ उत्तर के समान

फ़ंक्शन को 3 कॉलम के साथ एक सरणी मिलती है [time, i/o,plateN]

पिछला उत्तर:

@(A){[t,O]=A{:};max(cumsum(sparse({++t(!O),t}{2},1,!O*2-1)))}{2}

फ़ंक्शन को केवल दो इनपुट मिलते हैं t: समय और O: सेल सरणी के पहले दो तत्व से I / O Aजिसमें ट्रिपल इनपुट होते हैं!

मौजूदा कारों की प्रत्येक दर्ज समय संख्या के लिए गणना करने के लिए एक विरल मैट्रिक्स बनाया गया है। इसके लिए कार से बाहर निकलने का समय + 1 माना जाता है और इसी 1 को -1 में बदल दिया जाता है और 0 को बदलकर 1.
यहाँ पर स्पार्स का उपयोग बहुत महत्वपूर्ण है क्योंकि एक ही समय में कई कारें आ सकती हैं या निकल सकती हैं।
तब संचयी योग वर्तमान लॉट में वर्तमान कारों की संख्या का प्रतिनिधित्व करता है और इसकी अधिकतम संख्या पाई जाती है।

Comments

मुझे याद है कि ऑक्टेव सपोर्ट सेल ऐरे, जिसका अर्थ है कि आप इनपुट के रूप में केवल तीन एरे का उपयोग कर सकते हैं। प्रतिबंध M5 से पहले के संस्करण के अनुसार है और इसमें according ट्रिपल्स की एक सरणी ’कहा गया है। मैंने इसे M5

— कीउ गण

@KeyuGan मुझे लगता है कि आपके नए आविष्कार प्रतिबंध अनावश्यक है मेरे कोड के 14 बाइट्स में वृद्धि हुई है। इसलिए आप इस साइट के लिए नए हैं और अधिक योगदानकर्ताओं को आकर्षित करने के लिए कम से कम प्रतिबंधों के साथ सवाल करना बेहतर है।

— rahnema1

Answer 6

जावास्क्रिप्ट (ईएस 6), 63 73 71 बाइट्स

d=>Math.max(...d.sort((a,[b,c])=>a[s=0]-b||a[1]-c).map(e=>s+=1-e[1]*2))

यह प्रविष्टियों के एक सरणी के रूप में इनपुट का आदेश दिया [time, inout, plate]। दुर्भाग्य से इस तथ्य के कारण कि समान इन-टाइम का मतलब है कि दोनों कारों को समय में बहुत माना जाता है, सॉर्टिंग एल्गोरिदम को 0पहले ऑर्डर करना होगा 1, जिसकी लागत 11 बाइट्स थी।

क्रेडिट

• मैंने मानचित्र फ़ंक्शन के अंदर शिफ्ट और गुणा को स्थानांतरित करके 1 बाइट को बचाया (धन्यवाद नील)।
• मैंने सॉर्ट फ़ंक्शन में एक विनाशकारी तर्क का उपयोग करके एक और दो बाइट्स को बचाया (धन्यवाद edc65)।

डेमो

// test the two examples
console.log([[[36000,1],[16500,1],[16,0],[3300,0],[6500,1],[32800,0],[16400,0],[16501,1],[16500,0],[8800,1],[3300,0]],[[16400,0],[16500,1],[16500,0],[16600,1]]].map(
// answer submission
d=>Math.max(...d.sort((a,[b,c])=>a[s=0]-b||a[1]-c).map(e=>s+=1-e[1]*2))
));

Comments

ऐसा लगता है कि आपका कोड अच्छी तरह से काम नहीं करता है, d=[[16400,75487,0],[16500,75487,1],[16500,99999,0],[16600,99999,1]];मुझे लगता है कि इसे 2 प्रिंट करना चाहिए?

— कीउ गण

वैसे 4-एंट्री टेस्ट के मामले में, केवल 2 कारें हैं। मैंने इसे आपके इनपुट आदेश को पूरा करने के लिए स्वरूपित किया है।

— कीउ गण Key ’

@KeyuGan गलतफहमी के लिए खेद है, मुझे नहीं पता था कि आप दूसरे उदाहरण का उल्लेख कर रहे हैं। यह अब तय हो गया है।

— पैट्रिक रॉबर्ट्स

मुझे पता है कि आपका एल्गोरिथ्म प्लेट नंबर पर निर्भर नहीं करता है। हालाँकि, मेरा सुझाव है कि इसे इनपुट ऑर्डर की परिभाषा में शामिल किया जाना चाहिए, बस इसे अंतिम पर छोड़ देना चाहिए;)

— कीउ गण

@ edc65 वास्तव में, केवल 2 बाइट्स, न कि 4. यह भी 71 बाइट्स है:d=>Math.max(...d.sort(([a,b],[c,d])=>a-b||c-d).map(e=>s+=1-e[1]*2,s=0))

— पैट्रिक रॉबर्ट्स

Answer 7

जावास्क्रिप्ट (ईएस 6), 83 … 68 70 बाइट्स

संपादित करें: 2 उदाहरण का समर्थन करने के लिए तय किया गया

सरणी के एक सरणी के रूप में इनपुट लेता है [in_out, time, plate]। लेकिन plateस्तंभ को वास्तव में अनदेखा किया गया है।

a=>a.sort(([a,b],[c,d])=>b-d||a-c).map(v=>a=(n+=1-v[0]*2)<a?a:n,n=0)|a

परीक्षा

let f =

a=>a.sort(([a,b],[c,d])=>b-d||a-c).map(v=>a=(n+=1-v[0]*2)<a?a:n,n=0)|a

console.log(f([
  [1, 36000, 97845],
  [1, 16500, 75487],
  [0, 16,    12345],
  [0, 3300,  75486],
  [1, 6500,  12345],
  [0, 32800, 97845],
  [0, 16400, 12345],
  [1, 16501, 97846],
  [0, 16500, 97846],
  [1, 8800,  75486],
  [0, 3300,  75487]
]));

console.log(f([
  [0, 16400, 12345],
  [1, 16500, 12345],
  [0, 16500, 75487],
  [1, 16600, 75487]
]));

Comments

in_outस्तंभ के बजाय स्तंभ को पढ़ने से plateआपको छह बाइट बचानी चाहिए v=>n+=1-v[2]*2:।

— नील '’

यह दूसरे उदाहरण के लिए गलत है, इसलिए यदि आप इसे फिर से संपादित करते हैं, तो आपको इसे ध्यान में रखना होगा। (चूंकि इस पर अंतिम संपादन दूसरे उदाहरण को जोड़ने से पहले किया गया था, यह तकनीकी रूप से इसका अनुपालन करने से मुक्त है, और मैं बिल्कुल भी ईर्ष्या नहीं कर रहा हूं!)

— पैट्रिक रॉबर्ट्स

@PatrickRoberts तय करने की कोशिश करेंगे कि जब मैं कंप्यूटर के सामने वापस आऊंगा ^ ^

— Arnauld

@ नील अच्छी पकड़! मुझे वैसे भी इसे फिर से लिखने के लिए 2 उदाहरण का समर्थन करना था, लेकिन मैंने आपकी सलाह का पालन किया।

— Arnauld