В прошлом месяце я позаимствовал много книг из библиотеки. Все они были хорошими книгами, наполненными эмоциями и интригами. К сожалению, в некоторые моменты я очень разозлился / расстроился / разочаровался, поэтому порвал несколько страниц.

Теперь библиотека хочет знать, сколько страниц я вырвал за каждую книгу.

Ваша цель - написать программу, которая использует отсортированный список чисел, разделенных запятыми, в качестве входных данных и печатает минимально и максимально возможное количество страниц, которое я мог бы вырвать. Каждая строка представляет книгу, каждое число представляет отсутствующую страницу из книги.

Пример ввода:

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 страниц).

Помните, что страница книги всегда имеет переднюю и заднюю стороны. Кроме того, нумерация страниц отличается от книги к книге. Некоторые книги имеют четные номера страниц на левой странице; некоторые на правой странице. Все книги читаются слева направо.

Самый короткий код в байтах побеждает. Строгий формат ввода-вывода не требуется. Ваши программы должны быть в состоянии принять одну или несколько книг в качестве входных данных. Повеселись.

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 Оливье и моим собственным (в настоящее время удаленным) решением Japt.
• 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+
$*

Преобразуйте номера страниц в одинарные.

.+
$&,/$&,

Дублируйте список, вставив a /.

,(?=.*/)
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 Language (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]

Попробуйте онлайн!

Требования полной программы абсолютно убивают способность Клин конкурировать.

Для тех, кто обращал внимание на мои ответы в Чистом, вы заметите import qualified, что это уродливый хакер, использующий модули, которые не должны использоваться вместе, что необходимо здесь только из-за другого уродливого хака. с GenLibзависимостью Data.Maybeвместо вместо StdMaybe, что является результатом еще одного уродливого хака в библиотеках, переведенных с Haskell Dataдля получения функциональности до того, как собственные библиотеки Clean будут в равной степени завершены.

Принимает ввод через аргументы командной строки.

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"