No mês passado, peguei emprestados muitos livros da biblioteca. Todos eram bons livros, cheios de emoções e reviravoltas na trama. Infelizmente, em alguns momentos fiquei muito zangado / triste / decepcionado, por isso rasguei algumas páginas.

Agora a biblioteca quer saber quantas páginas eu rasguei para cada livro.

Seu objetivo é escrever um programa, que use uma lista de números ordenada e delimitada por vírgulas como entrada e imprima a contagem mínima e máxima possível de páginas que eu poderia ter arrancado. Cada linha representa um livro, cada número representa uma página ausente do livro.

Exemplo de entrada:

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

Exemplo de saída:

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

4/5significa que eu posso ter rasgado 4 ou 5 páginas, dependendo de qual lado a numeração das páginas do livro começa. Alguém poderia ter arrancado as páginas 6/7, 8/9, 100/101 e 222/223 (4 páginas). Como alternativa, alguém poderia ter arrancado as páginas 7/8, página 99/100, página 101/102, página 221/222 e página 223/224 (5 páginas).

Lembre-se de que uma página de livro sempre tem uma frente e um verso. Além disso, a numeração das páginas difere de livro para livro. Alguns livros têm números pares de páginas na página esquerda; alguns na página certa. Todos os livros são lidos da esquerda para a direita.

O código mais curto em bytes vence. Formato estrito de E / S não é necessário. Seus programas devem poder receber um ou mais livros como entrada. Diverta-se.

05AB1E , 13 bytes

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

Experimente online!

Obrigado a Emigna pelo aviso sobre alterações nas especificações.

Explicação

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

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

Experimente online!

JavaScript, 104 93 92 85 80 79 74 bytes

Seriam 57 bytes, se não fosse o requisito desnecessário (na minha opinião) de que cada par de números na saída seja classificado de maneira consistente, ou 47 bytes, se precisássemos usar apenas um livro como entrada.

Entrada e saída são uma matriz de matrizes.

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

• Inicialmente inspirado na solução Java da Olivier e na minha (atualmente excluída) solução Japt.
• 2 bytes salvos graças a Arnauld (mais outros 3 que nós vimos ao mesmo tempo) e 10 bytes adicionados graças a ele detectando a classificação quebrada que eu esperava que ninguém notasse enquanto esse requisito ainda estivesse em discussão!

Casos de teste

Os casos de teste são divididos em livros individuais para melhor legibilidade, com o último caso (que inclui o [1,2]caso extremo) servindo para ilustrar que esta solução suporta vários livros na entrada.

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>

História

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

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

Experimente online! Explicação:

\d+
$*

Converta os números de página em unário.

.+
$&,/$&,

Duplique a lista, interpondo a /.

,(?=.*/)
1,

Incremente os números de página em uma cópia da lista.

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

Conte o número de páginas, mas os números pares e ímpares consecutivos contam apenas como uma página.

%O`1+

Classifique as contagens em ordem.

1+
$.&

Converta as contagens novamente em decimal.

Haskell , 62 bytes

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

Experimente online!

Java (OpenJDK 9) , 163 bytes

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

Experimente online!

Explicações

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

Nota: como não há requisitos, os números mínimo e máximo de páginas não são solicitados.

APL (Dyalog Unicode) , 37 bytes

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

Experimente online!

Isso pode ser feito por menos da metade da contagem de bytes, se a ordem de saída das páginas não for importante:

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

Quão?

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

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

Experimente online!

Wolfram Language (Mathematica) , 37 bytes

^{Obrigado @MartinEnder por 8 bytes!}

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

Experimente online!

Explicação

Em: {3, 4, 5}

{#,#+1}

Tome (entrada) e (entrada + 1). {{3, 4, 5}, {4, 5, 6}}

... ~Floor~2

Para cada número acima, pegue o maior número par menos. {{2, 4, 4}, {4, 4, 6}}

Length@*Split/@

Para cada lista acima, divida a lista pelos mesmos elementos {{{2}, {4, 4}}, {{4, 4}, {6}}}

e tome o comprimento de cada um: {2, 2}

Sort[ ... ]

Classifique a saída.

Limpo , 222 210 204 196 bytes

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]

Experimente online!

Os requisitos do programa completo assassinam absolutamente a capacidade de Clean de competir.

Para aqueles que prestaram atenção às minhas respostas no Clean, você notará import qualifiedque é um truque feio para se locomover usando módulos que não devem ser usados ​​juntos, juntos - o que é necessário aqui apenas por causa de outro truque feio para fazer com GenLibdependendo de em Data.Maybevez de StdMaybe, que é o resultado de mais um truque feio nas bibliotecas traduzidas do Haskell's Datapara obter funcionalidade antes que as próprias bibliotecas do Clean sejam igualmente concluídas.

Recebe entrada por meio de argumentos da linha de comando.

Perl, 40 bytes

Inludes +1paraa

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

A saída não está ordenada.

Assume números de página positivos (especialmente nenhuma página 0 ). Assume que as páginas ausentes são mencionadas apenas uma vez. Não se importa se a entrada está ordenada ou não.

O processamento de apenas um livro por execução salva 3bytes para 37:

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