上个月，我从图书馆借了很多书。他们都是好书，充满了情感和情节扭曲。不幸的是，有时我会非常生气/悲伤/失望，所以我撕了一些纸。

现在图书馆想知道我为每本书撕了多少页。

您的目标是编写一个程序，该程序以逗号分隔的数字列表作为输入，并打印我可能撕裂的最小和最大页数。每行代表一本书，每个数字代表该书中缺少的一页。

输入示例：

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

• 最初是受Olivier的Java解决方案和我自己的（当前已删除）Japt解决方案启发。
• 感谢Arnauld（节省了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))

视网膜0.8.2，60字节

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

在线尝试！说明：

\d+
$*

将页码转换为一元。

.+
$&,/$&,

复制列表，插入/。

,(?=.*/)
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的竞争能力。

对于那些一直关注我在Clean中的答案的人，您会注意到import qualified，这是一个丑陋的技巧，可以绕开不应该一起使用的模块一起使用-仅在这里需要这样做，因为还有另一个丑陋的技巧要做与GenLib根据Data.Maybe，而不是StdMaybe，这是结果又丑陋的黑客从Haskell的翻译库Data获得功能清洁自己的图书馆也同样完成之前。

通过命令行参数获取输入。

Perl，40个字节

Inludes +1为a

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

输出不排序。

假定为正页码（尤其是no page 0）。假设丢失的页面仅被提及一次。不在乎输入是否已订购。

每次运行仅处理一本书，可节省以下3字节37：

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