Tháng trước tôi đã mượn rất nhiều sách từ thư viện. Tất cả đều là những cuốn sách hay, chứa đầy cảm xúc và cốt truyện xoắn. Thật không may, tại một số điểm tôi đã rất tức giận / buồn / thất vọng, vì vậy tôi đã xé một số trang.

Bây giờ thư viện muốn biết tôi đã xé bao nhiêu trang cho mỗi cuốn sách.

Mục tiêu của bạn là viết một chương trình, trong đó lấy một danh sách các số được phân tách bằng dấu phẩy làm đầu vào và in số trang tối thiểu và tối đa có thể mà tôi có thể đã xé ra. Mỗi dòng đại diện cho một cuốn sách, mỗi số đại diện cho một trang bị thiếu trong cuốn sách.

Ví dụ đầu vào:

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

Ví dụ đầu ra:

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

4/5có nghĩa là tôi có thể đã xé ra 4 hoặc 5 trang, tùy thuộc vào việc bắt đầu đánh số trang của bên nào. Người ta có thể xé ra trang 6/7, trang 8/9, trang 100/101 và trang 222/223 (4 trang). Ngoài ra, người ta có thể xé ra trang 7/8, trang 99/100, trang 101/102, trang 221/222 và trang 223/224 (5 trang).

Hãy nhớ rằng một trang sách luôn có mặt trước và mặt sau. Ngoài ra việc đánh số trang khác nhau từ sách này sang sách khác. Một số sách có số trang chẵn ở trang bên trái; một số trên trang bên phải. Tất cả các cuốn sách được đọc từ trái sang phải.

Mã ngắn nhất trong byte thắng. Định dạng I / O nghiêm ngặt là không bắt buộc. Các chương trình của bạn phải có thể lấy một hoặc nhiều cuốn sách làm đầu vào. Chúc vui vẻ.

05AB1E , 13 byte

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

Hãy thử trực tuyến!

Cảm ơn Emigna vì đã thay đổi thông số kỹ thuật.

Giải trình

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

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

Hãy thử trực tuyến!

JavaScript, 104 93 92 85 80 79 74 byte

Sẽ là 57 byte nếu không phải là yêu cầu không cần thiết (theo ý kiến ​​của tôi) rằng mỗi cặp số trong đầu ra phải được sắp xếp một cách nhất quán hoặc 47 byte nếu chúng ta chỉ cần lấy một cuốn sách làm đầu vào.

Đầu vào và đầu ra đều là một mảng của mảng.

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

• Ban đầu lấy cảm hứng từ giải pháp Java của Olivier và giải pháp Japt của riêng tôi (hiện đã bị xóa).
• 2 byte được lưu nhờ Arnauld (cộng thêm 3 byte cả hai chúng tôi đã phát hiện cùng một lúc) và 10 byte được thêm vào nhờ anh ấy phát hiện ra sự sắp xếp bị hỏng mà tôi hy vọng không ai sẽ nhận thấy trong khi yêu cầu đó vẫn đang được thảo luận!

Các trường hợp thử nghiệm

Các trường hợp thử nghiệm được chia thành các sách riêng lẻ để dễ đọc hơn với trường hợp cuối cùng (bao gồm cả [1,2]trường hợp cạnh) phục vụ để minh họa rằng giải pháp này hỗ trợ nhiều sách trong đầu vào.

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>

Lịch sử

//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))

Võng mạc 0.8.2 , 60 byte

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

Hãy thử trực tuyến! Giải trình:

\d+
$*

Chuyển đổi số trang thành unary.

.+
$&,/$&,

Sao chép danh sách, xen kẽ a /.

,(?=.*/)
1,

Tăng số trang trong một bản sao của danh sách.

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

Đếm số lượng trang, nhưng số chẵn và số lẻ liên tiếp chỉ được tính là một trang.

%O`1+

Sắp xếp số lượng theo thứ tự.

1+
$.&

Chuyển đổi số đếm trở lại thập phân.

Haskell , 62 byte

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

Hãy thử trực tuyến!

Java (OpenJDK 9) , 163 byte

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

Hãy thử trực tuyến!

Giải thích

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

Lưu ý: vì không có yêu cầu nào về nó, nên số lượng trang tối thiểu và tối đa không được đặt hàng.

APL (Dyalog Unicode) , 37 byte

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

Hãy thử trực tuyến!

Điều này có thể được thực hiện với ít hơn một nửa số byte nếu thứ tự đầu ra của các trang không thành vấn đề:

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

Làm sao?

{(≢⍵)≤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 byte

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

Hãy thử trực tuyến!

Ngôn ngữ Wolfram (Mathicala) , 37 byte

^{Cảm ơn @MartinEnder cho 8 byte!}

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

Hãy thử trực tuyến!

Giải trình

Trong: {3, 4, 5}

{#,#+1}

Lấy (đầu vào) và (đầu vào + 1). {{3, 4, 5}, {4, 5, 6}}

... ~Floor~2

Đối với mỗi số từ trên, lấy số chẵn lớn nhất ít hơn nó. {{2, 4, 4}, {4, 4, 6}}

Length@*Split/@

Đối với mỗi danh sách từ trên, hãy chia danh sách theo các yếu tố giống nhau {{{2}, {4, 4}}, {{4, 4}, {6}}}

và lấy chiều dài của mỗi: {2, 2}

Sort[ ... ]

Sắp xếp đầu ra.

Sạch , 222 210 204 196 byte

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]

Hãy thử trực tuyến!

Yêu cầu toàn chương trình hoàn toàn giết chết khả năng cạnh tranh của Clean.

Đối với những người đã chú ý đến câu trả lời của tôi trong Clean, bạn sẽ nhận thấy import qualifiedđây là một hack xấu xí để sử dụng các mô-đun không nên sử dụng cùng nhau - điều này chỉ cần ở đây vì một hack xấu xí khác phải làm với GenLibtùy thuộc vào Data.Maybethay vì StdMaybe, đó là kết quả của một vụ hack xấu xí khác trong các thư viện được dịch từ Haskell Datađể có được chức năng trước khi các thư viện của Clean hoàn thành như nhau.

Đưa đầu vào thông qua các đối số dòng lệnh.

Perl, 40 byte

Inludes +1choa

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

Đầu ra không được đặt hàng.

Giả sử số trang tích cực (đặc biệt là không có trang 0). Giả sử các trang bị thiếu chỉ được đề cập một lần. Không quan tâm nếu đầu vào được đặt hàng hay không.

Chỉ xử lý một cuốn sách cho mỗi lần chạy giúp tiết kiệm 3byte cho 37:

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