Il mese scorso ho preso in prestito molti libri dalla biblioteca. Erano tutti buoni libri, pieni di emozioni e colpi di scena. Sfortunatamente, ad alcuni punti sono diventato molto arrabbiato / triste / deluso, quindi ho strappato alcune pagine.

Ora la biblioteca vuole sapere quante pagine ho strappato per ogni libro.

Il tuo obiettivo è quello di scrivere un programma, che prende come input un elenco di numeri ordinati e delimitati da virgole e stampa il numero minimo e massimo possibile di pagine che avrei potuto strappare. Ogni riga rappresenta un libro, ogni numero rappresenta una pagina mancante dal libro.

Esempio di input:

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

Esempio di output:

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

4/5significa che potrei aver strappato 4 o 5 pagine, a seconda del lato da cui inizia la numerazione delle pagine del libro. Uno avrebbe potuto strappare pagina 6/7, pagina 8/9, pagina 100/101 e pagina 222/223 (4 pagine). In alternativa, si sarebbe potuto strappare pagina 7/8, pagina 99/100, pagina 101/102, pagina 221/222 e pagina 223/224 (5 pagine).

Ricorda che una pagina del libro ha sempre un lato anteriore e uno posteriore. Anche la numerazione delle pagine differisce da libro a libro. Alcuni libri hanno numeri di pagina pari sulla pagina di sinistra; alcuni sulla pagina giusta. Tutti i libri vengono letti da sinistra a destra.

Il codice più corto in byte vince. È formato I / O Strict non richiesto. I tuoi programmi devono essere in grado di accettare uno o più libri come input. Divertiti.

05AB1E , 13 byte

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

Provalo online!

Grazie a Emigna per l'heads-up sulle modifiche alle specifiche.

Spiegazione

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

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

Provalo online!

JavaScript, 104 93 92 85 80 79 74 byte

Sarebbe 57 byte se non per il requisito non necessario (secondo me) che ogni coppia di numeri nell'output fosse ordinata in modo coerente, o 47 byte se avessimo solo bisogno di prendere un libro come input.

Input e output sono entrambi una matrice di array.

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

• Inizialmente ispirato alla soluzione Java di Olivier e alla mia soluzione Japt (attualmente eliminata).
• 2 byte salvati grazie ad Arnauld (più altri 3 rilevati entrambi contemporaneamente) e 10 byte aggiunti grazie a lui individuando l'ordinamento non funzionante che speravo che nessuno avrebbe notato mentre tale requisito era ancora in discussione!

Casi test

I casi di test sono suddivisi in singoli libri per una migliore leggibilità con l'ultimo caso (che include il [1,2]caso limite) che serve a illustrare che questa soluzione supporta più libri nell'input.

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>

Storia

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

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

Provalo online! Spiegazione:

\d+
$*

Converti i numeri di pagina in unario.

.+
$&,/$&,

Duplica l'elenco, interponendo a /.

,(?=.*/)
1,

Incrementa i numeri di pagina in una copia dell'elenco.

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

Conta il numero di pagine, ma i numeri pari e dispari consecutivi contano solo come una pagina.

%O`1+

Ordina i conteggi in ordine.

1+
$.&

Converti i conteggi in decimali.

Haskell , 62 byte

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

Provalo online!

Java (OpenJDK 9) , 163 byte

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

Provalo online!

spiegazioni

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: poiché non è richiesto, i numeri minimo e massimo di pagine non sono ordinati.

APL (Dyalog Unicode) , 37 byte

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

Provalo online!

Questo può essere fatto per meno della metà del conteggio dei byte se l'ordine di output delle pagine non ha importanza:

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

Come?

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

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

Provalo online!

Wolfram Language (Mathematica) , 37 byte

^{Grazie @MartinEnder per 8 byte!}

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

Provalo online!

Spiegazione

Nel: {3, 4, 5}

{#,#+1}

Prendi (input) e (input + 1). {{3, 4, 5}, {4, 5, 6}}

... ~Floor~2

Per ogni numero dall'alto, prendi il numero pari più grande meno. {{2, 4, 4}, {4, 4, 6}}

Length@*Split/@

Per ogni elenco dall'alto, dividere l'elenco per gli stessi elementi {{{2}, {4, 4}}, {{4, 4}, {6}}}

e prendere la lunghezza di ciascuno: {2, 2}

Sort[ ... ]

Ordina l'output.

Pulito , 222 210 204 196 byte

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]

Provalo online!

I requisiti del programma completo uccidono assolutamente la capacità di Clean di competere.

Per coloro che hanno prestato attenzione alle mie risposte in Clean, noterai import qualifiedche è un brutto hack per spostarsi usando moduli che non dovrebbero essere usati insieme, che è necessario solo qui a causa di un altro brutto hack da fare a GenLibseconda di Data.Maybeinvece di StdMaybe, che è il risultato di un altro brutto hack nelle librerie tradotte da Haskell Dataper ottenere funzionalità prima che le librerie di Clean siano ugualmente complete.

Accetta input tramite argomenti della riga di comando.

Perl, 40 byte

inludes +1pera

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

L'output non è ordinato.

Presuppone numeri di pagina positivi (in particolare nessuna pagina 0). Presuppone che le pagine mancanti siano menzionate una sola volta. Non importa se l'ingresso è ordinato o meno.

L'elaborazione di un solo libro per esecuzione consente di risparmiare 3byte per 37:

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