Le mois dernier, j'ai emprunté beaucoup de livres à la bibliothèque. C'étaient tous de bons livres, pleins d'émotions et de rebondissements. Malheureusement, à certains moments, je suis devenue très en colère / triste / déçue, alors j'ai déchiré certaines pages.

Maintenant, la bibliothèque veut savoir combien de pages j'ai déchirées pour chaque livre.

Votre objectif est d’écrire un programme qui prend en entrée une liste de nombres triée et délimitée par des virgules et qui affiche le nombre de pages minimal et maximal possible que j’aurais pu déchirer. Chaque ligne représente un livre, chaque numéro représente une page manquante du livre.

Exemple d'entrée:

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

Exemple de sortie:

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

4/5Cela signifie que j'ai peut-être déchiré 4 ou 5 pages, en fonction de quel côté commence la numérotation des pages du livre. On aurait pu déchirer page 6/7, page 8/9, page 100/101 et page 222/223 (4 pages). Alternativement, on pourrait avoir déchiré page 7/8, page 99/100, page 101/102, page 221/222 et page 223/224 (5 pages).

Rappelez-vous qu'une page de livre a toujours un recto et un verso. De plus, la numérotation des pages diffère d'un livre à l'autre. Certains livres ont même des numéros de page sur la page de gauche; certains sur la bonne page. Tous les livres sont lus de gauche à droite.

Le code le plus court en octets gagne. Le format strict d'E / S n'est pas requis. Vos programmes doivent pouvoir prendre un ou plusieurs livres en entrée. S'amuser.

05AB1E , 13 octets

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

Essayez-le en ligne!

Merci à Emigna pour son avertissement concernant les modifications apportées aux spécifications.

Explication

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

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

Essayez-le en ligne!

JavaScript, 104 93 92 85 80 79 74 octets

Ce serait 57 octets sans l'exigence inutile (à mon avis) que chaque paire de nombres de la sortie soit systématiquement triée, ou 47 octets si nous n'avions besoin que de prendre un livre en entrée.

L'entrée et la sortie sont à la fois un tableau de tableaux.

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

• Initialement inspirée de la solution Java d' Olivier et de ma propre solution Japt (actuellement supprimée).
• 2 octets économisés grâce à Arnauld (plus 3 autres que nous avons remarqués en même temps) et 10 octets ajoutés grâce à lui qui a vu le tri brisé que j'avais espéré que personne ne remarquerait tant que cette exigence serait encore en discussion!

Cas de test

Les cas de test sont divisés en livres individuels pour une meilleure lisibilité. Le dernier cas (qui inclut le [1,2]cas du bord) sert à illustrer le fait que cette solution prend en charge plusieurs livres en entrée.

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>

Histoire

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

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

Essayez-le en ligne! Explication:

\d+
$*

Convertissez les numéros de page en unaires.

.+
$&,/$&,

Dupliquer la liste en interposant a /.

,(?=.*/)
1,

Incrémenter les numéros de page dans une copie de la liste.

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

Comptez le nombre de pages, mais les nombres pairs et impairs consécutifs ne comptent que pour une page.

%O`1+

Trier les comptes dans l'ordre.

1+
$.&

Convertissez les décomptes en décimal.

Haskell , 62 octets

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

Essayez-le en ligne!

Java (OpenJDK 9) , 163 octets

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

Essayez-le en ligne!

Des explications

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

Remarque: comme il n’existe aucune exigence à ce sujet, les nombres minimum et maximum de pages ne sont pas ordonnés.

APL (Dyalog Unicode) , 37 octets

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

Essayez-le en ligne!

Cela peut être fait pour moins de la moitié du nombre d'octets si l'ordre de sortie des pages n'a pas d'importance:

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

Comment?

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

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

Essayez-le en ligne!

Wolfram Language (Mathematica) , 37 octets

^{Merci @MartinEnder pour 8 octets!}

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

Essayez-le en ligne!

Explication

Dans: {3, 4, 5}

{#,#+1}

Prenez (entrée) et (entrée + 1). {{3, 4, 5}, {4, 5, 6}}

... ~Floor~2

Pour chaque nombre d'en haut, prenez le plus grand nombre pair moins. {{2, 4, 4}, {4, 4, 6}}

Length@*Split/@

Pour chaque liste ci-dessus, divisez la liste par les mêmes éléments {{{2}, {4, 4}}, {{4, 4}, {6}}}

et prendre la longueur de chacun: {2, 2}

Sort[ ... ]

Trier la sortie.

Propre , 222 210 204 196 octets

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]

Essayez-le en ligne!

Les exigences du programme complet rendent absolument impossible la capacité de Clean de concourir.

Pour ceux qui ont prêté attention à mes réponses dans Clean, vous remarquerez import qualifiedqu’il s’agit d’un vilain hack de se déplacer en utilisant des modules qui ne devraient pas être utilisés ensemble, ce qui n’est nécessaire ici que pour un autre vilain hack à faire. avec GenLibdépendre de au Data.Maybelieu de StdMaybe, ce qui est le résultat d' un autre hack laid dans les bibliothèques traduites à partir de Haskell Datapour obtenir des fonctionnalités avant que les propres bibliothèques de Clean ne soient également complètes.

Prend une entrée via des arguments en ligne de commande.

Perl, 40 octets

Inludes +1poura

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

La sortie n'est pas ordonnée.

Suppose des numéros de page positifs (surtout aucune page 0). Suppose que les pages manquantes ne sont mentionnées qu'une fois. Peu importe si l'entrée est commandée ou non.

Le traitement d'un seul livre par cycle enregistre des 3octets pour 37:

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