W zeszłym miesiącu pożyczyłem dużo książek z biblioteki. Wszystkie były dobre książki, pełne emocji i zwrotów akcji. Niestety w niektórych momentach byłem bardzo zły / smutny / rozczarowany, więc wyrwałem kilka stron.

Teraz biblioteka chce wiedzieć, ile stron rozerwałem na każdą książkę.

Twoim celem jest napisanie programu, który pobiera posortowaną listę liczb rozdzielanych przecinkami jako dane wejściowe i drukuje minimalną i maksymalną możliwą liczbę stron, które mogłem oderwać. Każda linia reprezentuje książkę, każda liczba oznacza brakującą stronę z książki.

Przykładowe dane wejściowe:

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

Przykładowe dane wyjściowe:

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

4/5oznacza, że ​​mogłem oderwać 4 lub 5 stron, w zależności od strony, od której zaczyna się numeracja stron książki. Można było oderwać stronę 6/7, stronę 8/9, stronę 100/101 i stronę 222/223 (4 strony). Alternatywnie można oderwać strony 7/8, strony 99/100, strony 101/102, strony 221/222 i strony 223/224 (5 stron).

Pamiętaj, że strona książki ma zawsze przód i tył. Również numeracja stron różni się w zależności od książki. Niektóre książki mają nawet numery stron na lewej stronie; niektóre po prawej stronie. Wszystkie książki są czytane od lewej do prawej.

Najkrótszy kod w bajtach wygrywa. Ścisły format we / wy nie jest wymagany. Twoje programy muszą mieć możliwość pobrania jednej lub więcej książek jako danych wejściowych. Baw się dobrze.

05AB1E , 13 bajtów

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

Wypróbuj online!

Dzięki Emigna za heads-up na temat zmian specyfikacji.

Wyjaśnienie

ε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 bajtów

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

Wypróbuj online!

JavaScript, 104 93 92 85 80 79 74 bajtów

Byłoby 57 bajtów, gdyby nie niepotrzebny (moim zdaniem) wymóg, aby każda para liczb na wyjściu była konsekwentnie sortowana, lub 47 bajtów , gdybyśmy potrzebowali tylko jednej książki jako danych wejściowych.

Wejścia i wyjścia są zarówno tablicami tablic.

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

• Początkowo zainspirowany rozwiązaniem Java Oliviera i moim własnym (obecnie usuniętym) rozwiązaniem Japt.
• 2 bajty zaoszczędzone dzięki Arnauldowi (plus kolejne 3, które oboje zauważyliśmy w tym samym czasie) i 10 bajtów dodanych dzięki temu, że zauważył zepsute sortowanie. Miałem nadzieję, że nikt nie zauważy, gdy wymaganie to jest wciąż przedmiotem dyskusji!

Przypadki testowe

Przypadki testowe są podzielone na pojedyncze książki dla lepszej czytelności, przy czym ostatni przypadek (który obejmuje [1,2]przypadek skrajny) służy do zilustrowania, że ​​to rozwiązanie obsługuje wiele książek na wejściu.

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>

Historia

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

Retina 0.8.2 , 60 bajtów

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

Wypróbuj online! Wyjaśnienie:

\d+
$*

Konwertuj numery stron na unary.

.+
$&,/$&,

Zduplikuj listę, wstawiając a /.

,(?=.*/)
1,

Zwiększ numery stron w jednym egzemplarzu listy.

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

Policz liczbę stron, ale kolejne liczby parzyste i nieparzyste liczą się tylko jako jedna strona.

%O`1+

Posortuj liczby w kolejności.

1+
$.&

Konwertuj liczby z powrotem na dziesiętne.

Haskell , 62 bajty

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

Wypróbuj online!

Java (OpenJDK 9) , 163 bajty

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

Wypróbuj online!

Objaśnienia

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

Uwaga: ponieważ nie ma żadnych wymagań, minimalna i maksymalna liczba stron nie są uporządkowane.

APL (Dyalog Unicode) , 37 bajtów

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

Wypróbuj online!

Można to zrobić dla mniej niż połowy liczby bajtów, jeśli kolejność wyjściowa stron nie ma znaczenia:

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

W jaki sposób?

{(≢⍵)≤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 bajtów

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

Wypróbuj online!

Wolfram Language (Mathematica) , 37 bajtów

^{Dzięki @MartinEnder za 8 bajtów!}

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

Wypróbuj online!

Wyjaśnienie

W: {3, 4, 5}

{#,#+1}

Weź (dane wejściowe) i (dane wejściowe + 1). {{3, 4, 5}, {4, 5, 6}}

... ~Floor~2

Dla każdej liczby z góry weź największą liczbę parzystą pomniejszoną o to. {{2, 4, 4}, {4, 4, 6}}

Length@*Split/@

Dla każdej listy z góry podziel listę według tych samych elementów {{{2}, {4, 4}}, {{4, 4}, {6}}}

i weź długość każdego: {2, 2}

Sort[ ... ]

Posortuj dane wyjściowe.

Czysty , 222 210 204 196 bajtów

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]

Wypróbuj online!

Wymagania pełnego programu absolutnie zabijają zdolność Clean do konkurowania.

Dla tych, którzy zwracali uwagę na moje odpowiedzi w Clean, zauważysz import qualified, że jest to brzydki hack do poruszania się przy użyciu modułów, których nie należy używać razem - co jest potrzebne tylko tutaj z powodu kolejnego brzydkiego hacka do zrobienia z GenLibpoleganiem na Data.Maybezamiast StdMaybe, co jest wynikiem kolejnego brzydkiego włamania do bibliotek przetłumaczonych z Haskella, Dataaby uzyskać funkcjonalność, zanim własne biblioteki Clean będą równie kompletne.

Pobiera dane wejściowe za pomocą argumentów wiersza polecenia.

Perl, 40 bajtów

Zawiera +1dlaa

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

Dane wyjściowe nie są uporządkowane.

Zakłada dodatnie numery stron (szczególnie brak strony 0). Zakłada, że ​​brakujące strony są wymienione tylko raz. Nie obchodzi, czy dane wejściowe są uporządkowane, czy nie.

Przetwarzanie tylko jednej książki na bieg oszczędza 3bajty dla 37:

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