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

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

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

Приклад введення:

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}{

Спробуйте в Інтернеті!

Дякуємо Еміньї за те, що вони змінили специфікації.

Пояснення

ε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+
$.&

Перетворити відліки назад у десяткові.

Хаскелл , 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 (Діалог 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"

Спробуйте в Інтернеті!

Мова Вольфрама (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, який є результатом ще один потворний хак в бібліотеках в перекладі з Хаскеля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"