Letzten Monat habe ich viele Bücher aus der Bibliothek ausgeliehen. Sie alle waren gute Bücher, voller Emotionen und Wendungen. Leider wurde ich an einigen Stellen sehr wütend / traurig / enttäuscht und riss einige Seiten heraus.

Jetzt möchte die Bibliothek wissen, wie viele Seiten ich für jedes Buch herausgerissen habe.

Ihr Ziel ist es, ein Programm zu schreiben, das eine sortierte, durch Kommas getrennte Liste von Zahlen als Eingabe verwendet und die minimal und maximal mögliche Seitenzahl ausgibt, die ich herausgerissen haben könnte. Jede Zeile repräsentiert ein Buch, jede Zahl repräsentiert eine fehlende Seite aus dem Buch.

Beispiel Eingabe:

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

Beispielausgabe:

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

4/5Das bedeutet, dass ich möglicherweise 4 oder 5 Seiten herausgerissen habe, je nachdem, auf welcher Seite die Seitennummerierung des Buches beginnt. Man hätte Seite 6/7, Seite 8/9, Seite 100/101 und Seite 222/223 (4 Seiten) herausreißen können. Alternativ könnte man Seite 7/8, Seite 99/100, Seite 101/102, Seite 221/222 und Seite 223/224 (5 Seiten) herausgerissen haben.

Denken Sie daran, dass eine Buchseite immer eine Vorder- und eine Rückseite hat. Auch die Seitennummerierung unterscheidet sich von Buch zu Buch. Einige Bücher haben auf der linken Seite gerade Seitenzahlen. einige auf der rechten Seite. Alle Bücher werden von links nach rechts gelesen.

Kürzester Code in Bytes gewinnen. Ein striktes E / A-Format ist nicht erforderlich. Ihre Programme müssen in der Lage sein, ein oder mehrere Bücher als Eingabe zu verwenden. Habe Spaß.

05AB1E , 13 Bytes

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

Probieren Sie es online!

Vielen Dank an Emigna für das Heads-up zu Spezifikationsänderungen.

Erläuterung

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

Probieren Sie es online!

JavaScript, 104 93 92 85 80 79 74 Bytes

Wären 57 Bytes, wenn nicht die unnötige (meiner Meinung nach) Anforderung besteht, dass jedes Zahlenpaar in der Ausgabe konsistent sortiert wird, oder 47 Bytes, wenn wir nur ein Buch als Eingabe benötigen.

Eingabe und Ausgabe sind jeweils ein Array von Arrays.

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

• Zunächst inspiriert von Oliviers Java-Lösung und meiner eigenen (derzeit gelöschten) Japt-Lösung.
• Dank Arnauld konnten 2 Bytes eingespart werden (plus 3, die wir beide gleichzeitig entdeckt haben), und dank ihm kamen 10 Bytes hinzu , als er die unterbrochene Sortierung entdeckte.

Testfälle

Testfälle werden zur besseren Lesbarkeit in einzelne Bücher aufgeteilt, wobei der letzte Fall (einschließlich des [1,2]Kantenfalls) dazu dient, zu veranschaulichen, dass diese Lösung mehrere Bücher in der Eingabe unterstützt.

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>

Geschichte

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

Probieren Sie es online! Erläuterung:

\d+
$*

Wandeln Sie die Seitenzahlen in unäre um.

.+
$&,/$&,

Duplizieren Sie die Liste, indem Sie a einfügen /.

,(?=.*/)
1,

Erhöhen Sie die Seitenzahlen in einer Kopie der Liste.

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

Zählen Sie die Anzahl der Seiten, aber fortlaufende gerade und ungerade Zahlen zählen nur als eine Seite.

%O`1+

Sortieren Sie die Zählungen in der Reihenfolge.

1+
$.&

Rechne die Zählungen in Dezimalzahlen um.

Haskell , 62 Bytes

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

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

Probieren Sie es online!

Erklärungen

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

Hinweis: Da dies nicht erforderlich ist, werden die minimalen und maximalen Seitenzahlen nicht bestellt.

APL (Dyalog Unicode) , 37 Byte

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

Probieren Sie es online!

Dies kann für weniger als die Hälfte der Bytezahl durchgeführt werden, wenn die Ausgabereihenfolge der Seiten keine Rolle spielt:

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

Wie?

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

Probieren Sie es online!

Wolfram-Sprache (Mathematica) , 37 Byte

^{Danke @MartinEnder für 8 Bytes!}

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

Probieren Sie es online!

Erläuterung

Im: {3, 4, 5}

{#,#+1}

Nehmen Sie (Eingabe) und (Eingabe + 1). {{3, 4, 5}, {4, 5, 6}}

... ~Floor~2

Nehmen Sie für jede Zahl von oben die größte gerade Zahl abzüglich der Zahl. {{2, 4, 4}, {4, 4, 6}}

Length@*Split/@

Teilen Sie die Liste für jede Liste von oben nach denselben Elementen auf {{{2}, {4, 4}}, {{4, 4}, {6}}}

und nimm die Länge von jedem: {2, 2}

Sort[ ... ]

Sortieren Sie die Ausgabe.

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

Probieren Sie es online!

Vollständige Programmvoraussetzungen bringen die Wettbewerbsfähigkeit von Clean absolut zum Erliegen.

Für diejenigen, die auf meine Antworten in Clean geachtet haben, werden Sie feststellen import qualified, dass es ein hässlicher Hack ist, Module zu verwenden, die nicht zusammen verwendet werden sollten - was nur hier erforderlich ist, weil ein weiterer hässlicher Hack durchgeführt werden muss mit GenLibabhängig von Data.Maybestatt StdMaybe, was das Ergebnis eines weiteren hässlichen Hacks in den von Haskell übersetzten Bibliotheken istData , um Funktionalität zu erhalten, bevor die eigenen Bibliotheken von Clean gleichermaßen vollständig sind.

Übernimmt die Eingabe über Befehlszeilenargumente.

Perl, 40 Bytes

Enthält +1füra

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

Ausgang ist nicht bestellt.

Nimmt positive Seitenzahlen an (insbesondere keine Seite 0). Angenommen, fehlende Seiten werden nur einmal erwähnt. Es ist egal, ob der Eingang bestellt ist oder nicht.

Durch die Verarbeitung von nur einem Buch pro Lauf werden 3Byte gespart für 37:

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