मैंने कितने पृष्ठ फाड़े हैं?

Question

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

अब पुस्तकालय जानना चाहता है कि मैंने प्रत्येक पुस्तक के लिए कितने पृष्ठ फाड़े हैं।

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

उदाहरण इनपुट:

7,8,100,101,222,223
2,3,88,89,90,103,177
2,3,6,7,10,11
1
1,2

उदाहरण आउटपुट:

4/5
5/6
3/6
1/1
1/2

4/5इसका मतलब है, कि मैंने ४ या ५ पृष्ठों को फाड़ दिया होगा, जिसके आधार पर पुस्तक का पृष्ठ क्रमांक शुरू होता है। पेज 6/7, पेज 8/9, पेज 100/101 और पेज 222/223 (4 पेज) को फाड़ सकता है। वैकल्पिक रूप से, कोई पृष्ठ 7/8, पृष्ठ 99/100, पृष्ठ 101/102, पृष्ठ 221/222, और पृष्ठ 223/224 (5 पृष्ठ) को फाड़ सकता था।

याद रखें कि पुस्तक पृष्ठ पर हमेशा आगे और पीछे का भाग होता है। इसके अलावा, पेज नंबरिंग किताब से पुस्तक में भिन्न होती है। कुछ पुस्तकों में बाएं पृष्ठ पर भी पृष्ठ संख्याएँ हैं; कुछ सही पृष्ठ पर। सभी किताबें बाएं से दाएं पढ़ी जाती हैं।

बाइट्स में सबसे छोटा कोड जीत जाता है। सख्त I / O प्रारूप की आवश्यकता नहीं है। आपके कार्यक्रमों को इनपुट के रूप में एक या अधिक पुस्तकें लेने में सक्षम होना चाहिए। मज़े करो।

Comments

क्या यह स्वीकार्य होगा यदि आउटपुट मानों को छांटने की गारंटी नहीं है? (जैसे कि 4/5और 5/4)

— अरनौल्ड

यह निर्दिष्ट करने के लिए चुनौतियों का अद्यतन करने के लिए मत भूलना कि आउटपुट ऑर्डर सभी min/maxया सभी के अनुरूप होना चाहिए max/min। (हालांकि, व्यक्तिगत रूप से, मैं पसंद करूंगा कि कल्पना का हिस्सा न बनें!)

— झबरा

programs must be able to take one or more books as inputशासन करने का कारण क्या होगा ? अधिकांश (यदि सभी नहीं) तो एक ही पुस्तक को लूप या किसी चीज़ में सत्यापित करने के लिए कोड को लपेटेंगे। IMHO यह सिर्फ चुनौती के लिए कोई लाभ नहीं के साथ जवाब के लिए एक उपरि जोड़ते हैं। इस प्रश्न के पहले से ही बहुत सारे उत्तर मिल गए हैं, इसलिए इसे रखना बेहतर है, लेकिन भविष्य की चुनौतियों के लिए इसे ध्यान में रखें।

— रॉड

सुझाए गए परीक्षण मामले (@Arnauld के सौजन्य से): 1,3,5,7,9,11,13,15,17,18- उन भाषाओं के लाभ के लिए, जिनकी अंतर्निहित sortविधि डिफ़ॉल्ट रूप से शाब्दिक रूप से होती है (निरंतर क्रमबद्ध आउटपुट की आवश्यकता को कल्पना में जोड़ा जाता है)।

— झबरा

Answer 1

05AB1E , 13 बाइट्स

εD>)ÅÈε€θγg}{

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

विशेष परिवर्तनों पर शीर्ष-अप के लिए एमिग्ना का धन्यवाद ।

व्याख्या

εD>)ÅÈε€θγg}{ – Full program.
ε             – For each book...
 D            – Push two copies of it.
  >           – Increment all the elements of the second copy.
   )          – Wrap the whole stack into a list.
    ÅÈ        – Produces the lists of even natural numbers lower or equal to each element.
      ε       – For each (the modified copies of the book):
       €θ     – Get the last item of each.
         γg   – And split into chunks of equal adjacent elements.
           }  – Close the loop.
            { – Sort the resulting list.

Comments

अच्छा प्रस्तुत किया। मैंने 2 अतिरिक्त इनपुट / आउटपुट लाइनों के साथ चुनौती को अद्यतन किया। इसके अलावा सख्त I / O की आवश्यकता नहीं है।

— आर्मिनब

Btw, आपका प्रोग्राम इनपुट के रूप में कई पुस्तकों को नहीं लेता है।

— arminb

@Emigna हेड-अप के लिए धन्यवाद। मेरे हिसाब से जवाब दिया।

— श्री Xcoder

@arminb इसे अब ठीक किया जाना चाहिए।

— श्री एक्सकोडर

Answer 2

पायथन 2 , 72 56 68 67 बाइट्स

lambda b:[map(len,map(set,zip(*[[p/2,-p/2]for p in t])))for t in b]

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

Comments

आपका प्रोग्राम कई लाइन इनपुट (एकाधिक पुस्तकें) को स्वीकार नहीं करता है। मैंने 2 अतिरिक्त इनपुट / आउटपुट लाइनों के साथ चुनौती को अद्यतन किया। इसके अलावा सख्त I / O की आवश्यकता नहीं है।

— आर्मिनब

क्या प्रति रन कई इनपुट्स I / O सख्त नहीं होंगे?

— रॉड

कोई बहस कर सकता है।

— अरमिनब

कैसे के रूप में इनपुट आई / ओ कल्पना से आच्छादित है आप किताबें और उनके पृष्ठों ले। आवश्यकता है कि आप करते हैं एक से अधिक पुस्तकें ले इनपुट के रूप में चुनौती कल्पना का हिस्सा है।

— शैगी

Answer 3

जावास्क्रिप्ट, 104 93 92 85 80 79 74 बाइट्स

होगा 57 बाइट्स यदि अनावश्यक (मेरी राय में) की आवश्यकता के लिए नहीं है कि उत्पादन में संख्या के प्रत्येक जोड़ी लगातार हल हो, या 47 बाइट्स अगर हम केवल इनपुट के रूप में एक पुस्तक लेने के लिए की जरूरत है।

इनपुट और आउटपुट दोनों ऐरे के एक सरणी हैं।

a=>a.map(x=>[0,1].map(n=>new Set(x.map(y=>y+n>>1)).size).sort((x,y)=>x-y))

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

---

परीक्षण के मामलों

अंतिम मामलों के साथ बेहतर पठनीयता के लिए टेस्ट मामलों को अलग-अलग पुस्तकों में विभाजित किया गया है (जिसमें [1,2]किनारे का मामला भी शामिल है ) यह बताने के लिए कि यह समाधान इनपुट में कई पुस्तकों का समर्थन करता है।

f=
a=>a.map(x=>[0,1].map(n=>new Set(x.map(y=>y+n>>1)).size).sort((x,y)=>x-y))
o.innerText=` Input                         | Output\n${`-`.repeat(31)}|${`-`.repeat(21)}\n`+[[[7,8,100,101,222,223]],[[2,3,88,89,90,103,177]],[[2,3,6,7,10,11]],[[1,3,5,7,9,11,13,15,17,18]],[[1],[1,2],[8,10]]].map(b=>` `+JSON.stringify(b).padEnd(30)+"| "+JSON.stringify(f(b))).join`\n`

<pre id=o></pre>

---

इतिहास

//104
a=>a.map(x=>x.map(y=>b.add(y/2|0)&c.add(++y/2|0),b=new Set,c=new Set)&&[b.size,c.size].sort((x,y)=>x-y)))
// 93
a=>a.map(x=>[new Set(x.map(y=>y/2|0)).size,new Set(x.map(y=>++y/2|0)).size].sort((x,y)=>x-y)))
// 92
a=>a.map(x=>[(g=z=>new Set(z).size)(x.map(y=>y/2|0)),g(x.map(y=>++y/2|0))].sort((x,y)=>x-y))
// 85
a=>a.map(x=>[(g=h=>new Set(x.map(h)).size)(y=>y/2|0),g(y=>++y/2|0)].sort((x,y)=>x-y))
// 80
a=>a.map(x=>[(g=n=>new Set(x.map(y=>(y+n)/2|0)).size)(0),g(1)].sort((x,y)=>x-y))
// 79
a=>a.map(x=>[(g=n=>new Set(x.map(y=>y/2+n|0)).size)(0),g(.5)].sort((x,y)=>x-y))
// 76
a=>a.map(x=>[0,.5].map(n=>new Set(x.map(y=>y/2+n|0)).size).sort((x,y)=>x-y))

Comments

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

— ओलिवियर ग्रेगोइरे

@ OlivierGrégoire; जबकि सच है कि उत्पादन की लगातार छंटाई वर्तमान में कल्पना में शामिल नहीं है, arminb करते हुए कहा कि यह समाधान के एक जोड़े पर टिप्पणी की है है वास्तव में एक आवश्यकता। मैंने पहले ही चुनौती के बारे में टिप्पणी कर दी है कि इसे शामिल करने के लिए और इसके खिलाफ अपनी पसंद को बताते हुए - आखिरकार, मेरे लिए, यह सख्त I / O के तहत होगा।

— झबरा

मुझे लगता है कि यह 64 बाइट्स के लिए काम करना चाहिए । हालाँकि, बिना किसी कॉलबैक के आपकी वर्तमान सॉर्ट पद्धति त्रुटिपूर्ण है। यह उदाहरण पर विफल होगा [1,3,5,7,9,11,13,15,17,18]।

— अरनुलद

धन्यवाद, @ अरनौल। जब मैंने आपकी टिप्पणी को देखा तो [0,.5]उपयोग करने के बजाय मानचित्र पर अपडेट लिखना अभी समाप्त किया था g। पता नहीं क्यों मेरे पास बिटकॉइन ऑपरेटरों के साथ ऐसा मानसिक ब्लॉक है! मैं उम्मीद कर रहा था कि आउटपुट छँटाई एक आवश्यकता नहीं बनेगी और sort()इस बीच में कोई भी मेरे टूटे होने की सूचना नहीं देगा ;) कुछ काम करवाने की आवश्यकता है ताकि अपडेट होने में थोड़ी देर हो जाए।

— झबरा

@ शैगी मूल इरादे क्या है y/2? इस एल्गोरिथ्म के लिए पृष्ठ संख्या को आधे में विभाजित करने का क्या कारण है?

— MicFin

Answer 4

रेटिना 0.8.2 , 60 बाइट्स

\d+
$*
.+
$&,/$&,
,(?=.*/)
1,
((11)+,)1\1|1+,
1
%O`1+
1+
$.&

इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

\d+
$*

पृष्ठ संख्याओं को एकरूपता में बदलें।

.+
$&,/$&,

सूची को डुप्लिकेट करें, इंटरपोज़िंग ए /।

,(?=.*/)
1,

सूची की एक प्रति में पृष्ठ संख्या में वृद्धि।

((11)+,)1\1|1+,
1

पृष्ठों की संख्या की गणना करें, लेकिन लगातार और विषम संख्याओं को केवल एक पृष्ठ के रूप में गिना जाता है।

%O`1+

क्रम में मायने रखता है।

1+
$.&

दशमलव में वापस मायने रखता है।

Comments

अच्छा प्रस्तुत! मैंने 2 अतिरिक्त इनपुट / आउटपुट लाइनों के साथ चुनौती को अद्यतन किया। इसके अलावा सख्त I / O की आवश्यकता नहीं है। ऐसा लगता है कि आपका कार्यक्रम अब तक केवल एक ही है जो सभी परीक्षण मामलों को पारित करता है।

— आर्मिनब

इसके बजाय ,(?=.*/)¶1,कुछ नहीं हो सकता ,.*/¶1$&?

— शुक्र

@ नहीं, यह केवल एक संख्या में वृद्धि होगी, लेकिन मुझे उन सभी को वेतन वृद्धि की आवश्यकता है।

— नील

ठीक है, और अतिव्यापी का उपयोग कर इसे वापस उसी बाइट गिनती के लिए लगता है, इसलिए निष्पक्ष nuff

— Ven

Answer 5

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

import Data.List
p t=sort[length$nub[div(p+o)2|p<-t]|o<-[0,1]]

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

Comments

मुझे नहीं लगता कि यह तकनीकी रूप से मान्य है, क्योंकि प्रश्न के लिए एक पूर्ण कार्यक्रम ( Your goal is to write a program, which takes a sorted, comma-delimmited list of numbers as input ) की आवश्यकता है

— 6urous

@ सही है कि 'सही है। इसके अलावा मैंने 2 अतिरिक्त इनपुट / आउटपुट लाइनों के साथ चुनौती को अद्यतन किया। इसके अलावा सख्त I / O की आवश्यकता नहीं है।

— arminb

Answer 6

जावा (ओपनजेडके 9) , 163 बाइट्स

import java.util.*;
n->{for(int i=n.length;i-->0;){Set s=new HashSet(),t=new HashSet();for(int p:n[i]){s.add(p/2);t.add(++p/2);}n[i]=new int[]{s.size(),t.size()};}}

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

स्पष्टीकरण

n->{                                   // Input-output of int[][]
 for(int i=n.length;i-->0;){           // Iterate on books
  Set s=new HashSet(),t=new HashSet(); // Create two hashsets
  for (int p:n[i]) {                   // Iterate over each page
   s.add(p/2);                         // Add the sheet-of-page of books [ even | odd ] to one set.
   t.add(++p/2);                       // Add the sheet-of-page of books [ odd | even ] to the other set.
  }
  n[i]=new int[] {                     // change the input to the number of sheets used.
   s.size(),
   t.size()
  };
 }
}

नोट: चूंकि इसके बारे में कोई आवश्यकता नहीं है, इसलिए पृष्ठों की न्यूनतम और अधिकतम संख्या का आदेश नहीं दिया गया है।

Comments

आप श्रृंखला कर सकते हैं sizeके साथ addहो सकता है कुछ बाइट्स को बचाने के लिए जावा में? जैसे, s.add(p/2).size।

— झबरा

@Shaggy नहीं, मैं धाराओं के साथ श्रृंखला सामान सकता है, लेकिन वह चाहते हैं जोड़ने के एक <s> कुछ </ s> बाइट्स की बहुत, नहीं बचाने ;-)

— ओलिवर Grégoire

Answer 7

एपीएल (डायलॉग यूनिकोड) , 37 बाइट्स

{(≢⍵)≤2:⌽≢∘∪¨⌊⍵(1+⍵)÷2⋄≢∘∪¨⌊⍵(1+⍵)÷2}

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

यह आधे से कम बाइट की गिनती के लिए किया जा सकता है यदि पृष्ठों का आउटपुट ऑर्डर मायने नहीं रखता है:

{≢∘∪¨⌊⍵(1+⍵)÷2}

कैसे?

{(≢⍵)≤2:⌽≢∘∪¨⌊⍵(1+⍵)÷2⋄≢∘∪¨⌊⍵(1+⍵)÷2}⍝ Prefix dfn
{(≢⍵)≤2:                               ⍝ If argument length ≤2 
                    ÷2                 ⍝ Divide by 2
              ⍵(1+⍵)                   ⍝ Both the argument and 1+argument
             ⌊                         ⍝ Round down to the nearest integer
           ∪¨                          ⍝ Get the unique values of each
          ∘                            ⍝ And then
         ≢                             ⍝ Get the tally of elements of each
        ⌽                              ⍝ And reverse the result
                      ⋄                ⍝ Else
                       ≢∘∪¨⌊⍵(1+⍵)÷2} ⍝ Same as above, without reverting the result.

Comments

21 बाइट्स

— द्विजिमा

Answer 8

पर्ल 5 , 95 + 1 ( -a) = 96 बाइट्स

@0=@1=0;map{$i=-1;$F[$i]+1==$F[$i+1]&&$F[$i]%2==$_&&$i++while++$i<@F&&++@{$_}[0]}0,1;say"@0/@1"

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

Comments

आपके कार्यक्रम ठीक से निष्पादित नहीं होने के कुछ मामले हैं। मैंने 2 अतिरिक्त इनपुट / आउटपुट लाइनों के साथ चुनौती को अद्यतन किया। इसके अलावा सख्त I / O की आवश्यकता नहीं है।

— आर्मिनब

मैं नहीं देखता कि आपके किसी भी परीक्षण के मामले कहाँ विफल हो रहे हैं। केवल एक चीज जो काम नहीं कर रही है, वह कई मामले हैं, जिन्हें आपने मेरे समाधान पोस्ट करने के लंबे समय बाद जोड़ा है। किसी भी मामले में, मैंने कई परीक्षणों को संभालने के लिए समाधान को अपडेट किया है।

— Xcali

Answer 9

वोल्फ्राम भाषा (गणितज्ञ) , 37 बाइट्स

^{धन्यवाद @MartinEnder 8 बाइट्स के लिए!}

Sort[Length@*Split/@{#,#+1}~Floor~2]&

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

व्याख्या

में: {3, 4, 5}

{#,#+1}

(इनपुट) और (इनपुट + 1) लें। {{3, 4, 5}, {4, 5, 6}}

... ~Floor~2

ऊपर से प्रत्येक संख्या के लिए, सबसे बड़ी सम संख्या को कम लें। {{2, 4, 4}, {4, 4, 6}}

Length@*Split/@

ऊपर से प्रत्येक सूची के लिए, समान तत्वों द्वारा सूची को विभाजित करें {{{2}, {4, 4}}, {{4, 4}, {6}}}

और प्रत्येक की लंबाई लें: {2, 2}

Sort[ ... ]

आउटपुट को क्रमबद्ध करें।

Comments

आप की जरूरत नहीं है SplitBy: Length@Split@⌊#/2⌋&/@{#,#+1}&काम करता है। लेकिन तब यह नक्शे से पहले फर्श करने के लिए भी छोटा होता है Length@*Split/@⌊{#,#+1}/2⌋&:। और यदि आप चाहें, तो आप यूनिकोड के बिना एक ही बाइट की गिनती प्राप्त कर सकते हैं:Length@*Split/@{#,#+1}~Floor~2&

— मार्टिन एंडर

उह, मुझे लगता है कि चुनौती के लिए एक सख्त I / O प्रारूप की आवश्यकता है।

— 17

Answer 10

क्लीन , 222 210 204 196 बाइट्स

import StdEnv,ArgEnv,Data.Maybe,qualified GenLib as G
Start=tl[let(Just l)='G'.parseString i;?s=sum[1\\n<-[s,s+2..last(sort l)]|isAnyMember[n,n+1]l]in zip2(sort[?0,?1])['/\n']\\i<-:getCommandLine]

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

पूर्ण-कार्यक्रम की आवश्यकताएं बिल्कुल हत्याएं स्वच्छ प्रतिस्पर्धा करने की क्षमता।

उन लोगों के लिए जो क्लीन में मेरे उत्तरों पर ध्यान दे रहे हैं, आप नोटिस करेंगे import qualified, जो कि मॉड्यूल का उपयोग करने के लिए एक बदसूरत हैक है जो एक साथ उपयोग नहीं किया जाना चाहिए, एक साथ - जो केवल एक और बदसूरत हैक करने के लिए यहां आवश्यक है। के बजाय GenLibपर निर्भर करता Data.Maybeहै StdMaybe, जो हास्केल से अनुवादित पुस्तकालयों में अभी तक एक और बदसूरत हैक का परिणाम हैData क्लीन की खुद की लाइब्रेरी से पहले कार्यक्षमता प्राप्त करने के लिए समान रूप से पूर्ण हैं।

कमांड-लाइन तर्कों के माध्यम से इनपुट लेता है।

Comments

अच्छा प्रस्तुत किया। मैंने 2 अतिरिक्त इनपुट / आउटपुट लाइनों के साथ चुनौती को अद्यतन किया। इसके अलावा सख्त I / O की आवश्यकता नहीं है।

— अरमिनब

@arminb धन्यवाद! मैं उस मामले में कल इसे छोटा कर सकूंगा।

— Οवसंत

@arminb मैंने इसे अपडेट किया है इसलिए इसे नए मामलों के साथ मान्य होना चाहिए। यदि I / O मैंने उपयोग किया है तो स्वीकार्य नहीं है, मैं इसे सुबह फिर से संशोधित करूँगा।

— Οपूर्ण

Answer 11

पर्ल, 40 बाइट्स

inludes +1के लिएa

perl -aE 'say/$/*grep${$.}{$_*$`|1}^=1,@F for-1,1' <<< "7 8 100 101 222 223"

आउटपुट का आदेश नहीं दिया गया है।

सकारात्मक पृष्ठ संख्याएँ मानती हैं (विशेषकर कोई पृष्ठ नहीं 0 ) । अनुपलब्ध पृष्ठ केवल एक बार उल्लिखित हैं। इनपुट का आदेश दिया है या नहीं, इसकी परवाह नहीं करता।

प्रति रन केवल एक पुस्तक संसाधित करना इसके 3लिए बाइट्स बचाता है 37:

perl -aE 'say/$/*grep$z{$_*$`|1}^=1,@F for-1,1' <<< "7 8 100 101 222 223"