เดือนที่แล้วฉันยืมหนังสือมากมายจากห้องสมุด พวกเขาทั้งหมดเป็นหนังสือที่ดีเต็มไปด้วยอารมณ์และพล็อตเรื่องบิด น่าเสียดายที่ในบางจุดฉันโกรธ / เศร้า / ผิดหวังมาก

ตอนนี้ห้องสมุดอยากรู้ว่าฉันฉีกหนังสือแต่ละเล่มออกไปกี่หน้า

เป้าหมายของคุณคือการเขียนโปรแกรมซึ่งใช้การเรียงลำดับรายการที่คั่นด้วยเครื่องหมายจุลภาคเป็นอินพุตและพิมพ์จำนวนหน้าต่ำสุดและสูงสุดที่เป็นไปได้ที่ฉันสามารถฉีกออกได้ แต่ละบรรทัดแสดงถึงหนังสือแต่ละหมายเลขแสดงถึงหน้าที่หายไปจากหนังสือ

อินพุตตัวอย่าง:

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หมายความว่าฉันอาจฉีกออกเป็น 4 หรือ 5 หน้าขึ้นอยู่กับว่าหมายเลขหน้าของหนังสือเริ่มต้นที่ด้านใด อาจมีการฉีกขาดหน้า 6/7 หน้า 8/9 หน้า 100/101 และหน้า 222/223 (4 หน้า) อีกวิธีหนึ่งอาจมีการฉีกขาดหน้า 7/8, หน้า 99/100, หน้า 101/102, หน้า 221/222 และหน้า 223/224 (5 หน้า)

จำไว้ว่าหน้าหนังสือมีด้านหน้าและด้านหลังเสมอ นอกจากนี้หมายเลขหน้าแตกต่างจากหนังสือเล่มหนึ่งไปยังหนังสือ หนังสือบางเล่มมีเลขหน้าอยู่ทางซ้าย บางอันอยู่ที่หน้าขวา หนังสือทั้งหมดถูกอ่านจากซ้ายไปขวา

โค้ดที่สั้นที่สุดในหน่วยไบต์ชนะ ไม่จำเป็นต้องใช้รูปแบบ I / O ที่เข้มงวด โปรแกรมของคุณจะต้องสามารถนำหนังสือหนึ่งเล่มขึ้นไปเป็นอินพุตได้ มีความสุข.

05AB1E , 13 ไบต์

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

ลองออนไลน์!

ขอบคุณEmignaสำหรับการเปลี่ยนแปลงข้อมูลจำเพาะ

คำอธิบาย

ε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.

Python 2 , 72 56 68 67 ไบต์

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

ลองออนไลน์!

JavaScript, 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))

• เริ่มแรกได้รับแรงบันดาลใจจากโซลูชัน Java ของ Olivierและโซลูชัน Japt ของฉัน (ปัจจุบันถูกลบ)
• ขอบคุณ 2 ไบต์ที่บันทึกไว้โดยArnauld (บวกอีก 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))

เรติน่า 0.8.2 , 60 ไบต์

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

ลองออนไลน์! คำอธิบาย:

\d+
$*

แปลงหมายเลขหน้าเป็น unary

.+
$&,/$&,

ซ้ำรายการ interposing/

,(?=.*/)
1,

เพิ่มหมายเลขหน้าในหนึ่งสำเนาของรายการ

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

นับจำนวนหน้า แต่จำนวนต่อเนื่องและเลขคี่จะนับเป็นหน้าเดียวเท่านั้น

%O`1+

เรียงลำดับตามลำดับ

1+
$.&

แปลงจำนวนกลับเป็นทศนิยม

Haskell , 62 ไบต์

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

ลองออนไลน์!

Java (OpenJDK 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()
  };
 }
}

หมายเหตุ: เนื่องจากไม่มีข้อกำหนดเกี่ยวกับหน้านี้จำนวนหน้าขั้นต่ำและสูงสุดจึงไม่ได้รับคำสั่ง

APL (Dyalog Unicode) , 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.

Perl 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"

ลองออนไลน์!

ภาษา Wolfram (Mathematica) , 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[ ... ]

เรียงลำดับผลลัพธ์

ทำความสะอาด , 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]

ลองออนไลน์!

ข้อกำหนดของโปรแกรมเต็มรูปแบบสังหารความสามารถของคลีนอย่างเต็มที่ในการแข่งขัน

สำหรับผู้ที่ให้ความสนใจกับคำตอบของฉันใน Clean คุณจะสังเกตเห็นimport qualifiedว่าเป็นแฮ็คที่น่าเกลียดที่จะใช้โมดูลที่ไม่ควรใช้ร่วมกันด้วยกันซึ่งจำเป็นสำหรับที่นี่เพราะแฮ็คที่น่าเกลียดอีกตัวหนึ่งที่ต้องทำ ที่มีGenLibขึ้นอยู่กับData.MaybeแทนStdMaybeซึ่งเป็นผลมาจากอีกสับน่าเกลียดในห้องสมุดแปลจาก Haskell ของDataที่จะได้รับการทำงานก่อนที่ห้องสมุดของที่สะอาดมีความสมบูรณ์อย่างเท่าเทียมกัน

รับอินพุตผ่านอาร์กิวเมนต์บรรทัดรับคำสั่ง

Perl, 40 ไบต์

ไม่รวม+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"