El mes pasado tomé prestados muchos libros de la biblioteca. Todos eran buenos libros, llenos de emociones y giros en la trama. Desafortunadamente, en algunos momentos me enojé mucho / triste / decepcioné, así que arranqué algunas páginas.

Ahora la biblioteca quiere saber cuántas páginas he arrancado para cada libro.

Su objetivo es escribir un programa, que toma una lista ordenada y delimitada por comas de números como entrada e imprime el recuento de páginas mínimo y máximo posible que podría haber arrancado. Cada línea representa un libro, cada número representa una página faltante del libro.

Entrada de ejemplo:

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

Salida de ejemplo:

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

4/5significa que podría haber arrancado 4 o 5 páginas, dependiendo de qué lado comience la numeración de páginas del libro. Uno podría haber arrancado la página 6/7, la página 8/9, la página 100/101 y la página 222/223 (4 páginas). Alternativamente, uno podría haber arrancado la página 7/8, la página 99/100, la página 101/102, la página 221/222 y la página 223/224 (5 páginas).

Recuerde que una página de libro siempre tiene un anverso y un reverso. Además, la numeración de las páginas difiere de un libro a otro. Algunos libros tienen números de página pares en la página izquierda; algunos en la página correcta. Todos los libros se leen de izquierda a derecha.

El código más corto en bytes gana. Se formato de E / S estricta no es necesario. Sus programas deben poder tomar uno o más libros como entrada. Que te diviertas.

05AB1E , 13 bytes

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

Pruébalo en línea!

Gracias a Emigna por el aviso de cambios de especificaciones.

Explicación

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

Pruébalo en línea!

JavaScript, 104 93 92 85 80 79 74 bytes

Sería 57 bytes si no fuera por el requisito innecesario (en mi opinión) de que cada par de números en la salida se clasifique consistentemente, o 47 bytes si solo necesitáramos tomar un libro como entrada.

La entrada y la salida son ambas una matriz de matrices.

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

• Inicialmente inspirado por la solución Java de Olivier y mi propia solución Japt (actualmente eliminada).
• ¡2 bytes guardados gracias a Arnauld (más otros 3 que ambos vimos al mismo tiempo) y 10 bytes agregados gracias a que descubrió la clasificación rota que esperaba que nadie notara mientras ese requisito aún estaba en discusión!

Casos de prueba

Los casos de prueba se dividen en libros individuales para una mejor legibilidad con el último caso (que incluye el [1,2]caso límite) que sirve para ilustrar que esta solución admite varios libros en la 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>

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 bytes

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

Pruébalo en línea! Explicación:

\d+
$*

Convierta los números de página a unario.

.+
$&,/$&,

Duplicar la lista, interponiendo a /.

,(?=.*/)
1,

Incremente los números de página en una copia de la lista.

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

Cuente el número de páginas, pero los números pares e impares consecutivos solo cuentan como una página.

%O`1+

Ordenar los recuentos en orden.

1+
$.&

Convierta los recuentos a decimales.

Haskell , 62 bytes

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

Pruébalo en línea!

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

Pruébalo en línea!

Explicaciones

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: dado que no hay requisitos al respecto, no se ordenan los números mínimo y máximo de páginas.

APL (Dyalog Unicode) , 37 bytes

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

Pruébalo en línea!

Esto se puede hacer por menos de la mitad del conteo de bytes si el orden de salida de las páginas no importa:

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

¿Cómo?

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

Pruébalo en línea!

Wolfram Language (Mathematica) , 37 bytes

^{¡Gracias @MartinEnder por 8 bytes!}

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

Pruébalo en línea!

Explicación

En: {3, 4, 5}

{#,#+1}

Tomar (entrada) y (entrada + 1). {{3, 4, 5}, {4, 5, 6}}

... ~Floor~2

Para cada número de arriba, tome el número par más grande menos. {{2, 4, 4}, {4, 4, 6}}

Length@*Split/@

Para cada lista de arriba, divida la lista por los mismos elementos. {{{2}, {4, 4}}, {{4, 4}, {6}}}

y toma la longitud de cada uno: {2, 2}

Sort[ ... ]

Ordenar la salida.

Limpio , 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]

Pruébalo en línea!

Los requisitos del programa completo asesinan absolutamente la capacidad de Clean de competir.

Para aquellos que han estado prestando atención a mis respuestas en Clean, notarán import qualified, que es un truco feo para moverse usando módulos que no deberían usarse juntos, juntos, que solo es necesario aquí debido a otro truco feo para hacer con GenLibdependiendo de Data.Maybeen lugar de StdMaybe, que es el resultado de otro truco feo en las bibliotecas traducidos de Haskell Datapara obtener funcionalidad antes propias bibliotecas de limpias son igualmente completa.

Toma entrada a través de argumentos de línea de comandos.

Perl, 40 bytes

Inluye +1paraa

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

La salida no está ordenada.

Asume números de página positivos (especialmente sin página 0). Asume que las páginas faltantes solo se mencionan una vez. No le importa si la entrada está ordenada o no.

Procesar solo un libro por ejecución ahorra 3bytes para 37:

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