Votre tâche consiste à, étant donné un entier non signé n, trouver le plus grand nombre qui peut être créé en supprimant un seul octet (8 bits consécutifs) de données.

Exemple

Compte tenu du nombre 7831, nous le convertissons d'abord en binaire (en supprimant les zéros non significatifs):

1111010010111

Nous trouvons ensuite le groupe consécutif de 8 bits qui, une fois retiré, donnera le nouveau résultat le plus important. Dans ce cas, il existe 3 solutions, présentées ci-dessous

1111010010111
  ^      ^       
   ^      ^
    ^      ^

Suppression de l'un de ces rendements 11111, que nous convertissons ensuite à sa valeur décimale 31pour la réponse.

Cas de test

256        ->   1
999        ->   3
7831       ->   31
131585     ->   515
7854621    ->   31261
4294967295 ->   16777215 (if your language can handle 32 bit integers)

Règles

• Il est garanti que la longueur du bit nsera supérieure à 8.
• Votre solution devrait théoriquement fonctionner pour toute longueur de bit nsupérieure à 8, mais en pratique, elle n'a besoin de fonctionner que pour les entiers 255 <n <2 ¹⁶
• L'entrée / sortie doit être décimale.
• Vous pouvez soumettre un programme complet ou une fonction.
• Il s'agit de code-golf , donc le programme le plus court (en octets) gagne!

Gelée , 6 octets

BḄ-8ƤṀ

Un lien monadique prenant un numéro et renvoyant un numéro.

Essayez-le en ligne!

Comment?

Utilise un beau rapide , Ƥdéveloppé par miles ...

BḄ-8ƤṀ - Link: number
B      - convert to a binary list
    Ƥ  - for loop over some slices to be determined...
  -8   - this is a negative nilad, therefore: use overlapping outfixes of length 8
       -   (exactly what the specification asks us to inspect)
 Ḅ     -   convert from a binary list to an integer (vectorises)
     Ṁ - maximum

J , 12 octets

[:>./8#.\.#:

Essayez-le en ligne!

          #:     to binary
     8  \.       remove consecutive groups of eight
      #.         convert each result to decimal
  >./            maximum
[:               do nothing, this lets me avoid parentheses

Python 2 , 41 octets

f=lambda n:n>>8and max(n>>8,2*f(n/2)+n%2)

Essayez-le en ligne!

JavaScript (ES6), 54 octets

f=(n,v=n>>8,b=1,m=0)=>b>v?m:f(n,(v^n)&b^v,b+b,v>m?v:m)

<input type=number min=256 max=2147483647 oninput=o.textContent=f(this.value)><pre id=o>

Fonctionne jusqu'à 2 ** 31-1. Parce que quelqu'un a demandé une réponse un peu tordue ...

Pyth , 21 octets

L&K.>b8eS,K+*2y/b2%b2

Il s'agit d'une fonction récursive (doit être appelée avec y , ou voir le lien).

Essayez-le ici!

Mathematica, 69 octets

Max@Array[Drop[#&@@s,#;;#+7]~FromDigits~2&,Last[s=#~RealDigits~2]-7]&

Essayez-le en ligne!

Cette solution fonctionne pour les grands nombres Essayez-la en ligne!

-3 octets de KellyLowder

Python 3 , 68 66 60 octets

^{-2 octets grâce à M. Xcoder!}

^{-4 octets grâce aux ovs!}

^{-2 octets grâce à Erik l'Outgolfer!}

lambda n:max(n%2**i|n>>i+8<<i for i in range(len(bin(n))-9))

Essayez-le en ligne!

Wolfram Language (Mathematica) , 46 octets

Floor@If[#<256,0,Max[#/256,2#0[#/2]+#~Mod~2]]&

Essayez-le en ligne!

Cette version ne peut gérer que des entrées jusqu'à 2 ⁵¹⁸ -1, sinon nous rencontrons la limite de taille de pile de Mathematica. (La limite peut varier entre les installations de Mathematica.) La deuxième solution de cette réponse évite cela.

Comment ça marche

Une approche récursive basée sur la logique suivante:

• La valeur maximale doit être 0inférieure à toute entrée 256, car la suppression d'un octet du nombre mange le nombre entier. C'est notre cas de base, c'est pourquoi il est inclus même si les spécifications nous promettent que nous n'aurons pas à gérer de telles entrées.
• Sinon, nous prenons l'une Maxdes deux options: manger l'octet le plus bas (en nous donnant l'entrée divisée par 256) ou couper le bit le plus bas, récuser sur l'entier restant et ajouter le bit le plus bas lorsque nous avons terminé.

Wolfram Language (Mathematica) , 55 octets

Max@Table[Mod[#,m=2^k]+Floor[#/m/2^8]m,{k,0,Log2@#-8}]&

Essayez-le en ligne!

Une version alternative qui construit une table au lieu de la récursivité, donc elle fonctionne pour les nombres de toute taille que Mathematica peut gérer.

Rétine , 71 67 64 octets

.+
$*
+`(1+)\1
$+0
01
1
.
$`_$'¶
_.{7}

A`_
O^`
1G`
+1`\B
:$`:
1

Essayez-le en ligne! Link ne comprend que les cas de test les plus rapides, afin de ne pas surcharger indûment le serveur de Dennis. Edit: sauvé 3 octets grâce à @MartinEnder. Explication:

.+
$*
+`(1+)\1
$+0
01
1

Convertissez de décimal en binaire.

.
$`_$'¶
_.{7}

A`_

Construisez une liste de chaînes obtenues en supprimant 8 chiffres consécutifs de toutes les manières possibles.

O^`
1G`

Triez-les dans l'ordre inverse et prenez le premier (le plus grand).

+1`\B
:$`:
1

Reconvertissez en décimal. (Voir l' explication de @ MartinEnder .)

Java (OpenJDK 8) , 138 134 octets

i->{int l=0,m=0,x;String y=i.toString(i,2);for(;l<y.length()-7;m=x>m?x:m)x=i.valueOf(y.substring(0,l)+y.substring(l+++8),2);return m;}

Essayez-le en ligne!

ReRegex , 294 275 octets

19 octets enregistrés en utilisant de meilleures définitions de «fonction»

Je dirais que c'est assez bon pour une langue Regex uniquement.

La bibliothèque de base permet la conversion entre Unary et Decimal (ce qui est nécessaire car la spécification de défi indique explicitement décimal), mais ne prend pas en charge Binary; J'ai donc dû l'écrire dans le cadre du script en y ajoutant 120 octets.

#import base
b(\d*):(_*)\2_b/b1$1:$2b/b(\d*):(_+)\2b/b0$1:$2b/b(\d+):b/$1/b:b/0/B(_*):1/B$1$1_:/B(_*):0/B$1$1:/B(_*):B/$1/j(\d*),\1(\d)(\d{7})(\d*):/j$1$2,$1$2$3$4:,B:$1$4B/j(\d*),\1\d{0,7}:,?(.*)/,$2,/,((_+)_+),(\2),/,$1,/,(_+),(\1_*),/,$2,/^,(_*),$/d<$1>/j,b:u<(?#input)>b:

Essayez-le en ligne!

Par des expressions rationnelles individuelles.

#import base
b(\d*):(_*)\2_b/b1$1:$2b/
b(\d*):(_+)\2b/b0$1:$2b/
b(\d+):b/$1/
b:b/0/
B(_*):1/B$1$1_:/
B(_*):0/B$1$1:/
B(_*):B/$1/
j(\d*),\1(\d)(\d{7})(\d*):/j$1$2,$1$2$3$4:,B:$1$4B/
j(\d*),\1\d{0,7}:,?(.*)/,$2,/
,((_+)_+),(\2),/,$1,/
,(_+),(\1_*),/,$2,/
^,(_*),$/d<$1>/
j,b:u<(?#input)>b:

Pas

Premièrement, nous importons la bibliothèque «de base», qui donne deux expressions régulières. Celui qui se transforme u<numbers>en unaire. Et celui qui convertitd<unary_underlines> en décimal. En effet, le défi nécessite des E / S en base10.

Ensuite, nous définissons une poignée de regex qui convertissent unaire en binaire.

b(\d*):(_*)\2_b/b1$1:$2b/
b(\d*):(_+)\2b/b0$1:$2b/
b(\d+):b/$1/
b:b/0/

Le premier d'entre eux, b(\d*):(_*)\2_b/b1$1:$2b/recherche b, éventuellement suivi de quelques chiffres binaires, puis a :, puis n'importe quel nombre de soulignements, suivi du même nombre exact de soulignements plus un, et enfin un autre b.

Nous remplaçons ensuite cela par b1suivi des chiffres binaires d'avant, :et juste la première moitié des traits de soulignement, et enfin la dernière b.

Donc, cela vérifie si l'unaire n'est pas divisible par deux, et si c'est le cas, ajoute 1 à ses chiffres binaires, puis le divise moins un par deux.

Le second b(\d*):(_+)\2b/b0$1:$2b/est presque idendique, mais ne recherche pas de supplément _, ce qui signifie qu'il ne correspond que s'il est divisible par deux, et dans ce cas, ajoute un à la 0place.

Le troisième vérifie si nous n'avons plus de chiffres unaires, et si c'est le cas, supprime le rembourrage pour ne laisser que les chiffres binaires.

Le dernier vérifie s'il n'y a jamais eu de chiffres binaires fournis, et dans ce cas, laisse simplement 0 .

Le groupe suivant de regex que nous définissons consiste à reconvertir le binaire en unaire, et est légèrement plus simple.

B(_*):1/B$1$1_:/
B(_*):0/B$1$1:/
B(_*):B/$1/

Le premier de ce groupe, B(_*):1/B$1$1_:/tout comme son antithèse, détecte alors un B, suivi de n'importe quelle quantité de chiffres unaires :1. Il ne vérifie pas la correspondanceB dans ce cas, car il ne recherche qu'un seul chiffre à la fois. Si cela correspond, il double le nombre de chiffres unaires précédemment appariés et en ajoute un, puis supprime celui-ci.

Le second B(_*):0/B$1$1:/,, est presque identique au premier, sauf qu'il correspond à a 0plutôt qu'à a 1, et n'ajoute pas de chiffre unaire supplémentaire.

Le dernier de ces derniers, B(_*):B/$1/vérifie s'il n'y a plus de chiffres binaires, et si c'est le cas, décompresse l'unaire. Contrairement à son antithèse, cela n'a pas besoin d'un cas 0 spécial.

Ensuite, nous définissons les jregexes, qui agissent comme une fonction de division.

j(\d*),\1(\d)(\d{7})(\d*):/j$1$2,$1$2$3$4:,B:$1$4B/
j(\d*),\1\d{0,7}:,?(.*)/,$2,/

Le premier, j(\d*),\1(\d)(\d{7})(\d*):/j$1$2,$1$2$3$4:,B:$1$4B/fait la plupart des travaux lourds. Il recherche j, éventuellement suivi de chiffres binaires qui sont "l'incrémenteur", puis une virgule suivie de l'incrémenteur puis exactement 8 chiffres binaires suivis du reste du nombre binaire, puis a :. Le premier des 8 chiffres est ajouté à l'incrémenteur, l'incrémentant ainsi, puis tout sauf les 8 chiffres de l'entrée binaire est ajouté après le :suivant a ,. Donc (si nous utilisions 2 chiffres au lieu de 8) j,1001:deviendrait j1:1001:,01alors j10:1001,01,11. En outre, les éléments de tableau ajoutés sont enveloppés dans Bs, pour les reconvertir en unaire.

L'autre j(\d*),\1\d{0,7}:,?(.*)/,$2,/vérifie s'il reste moins de 8 chiffres binaires à vérifier après l'incrémenteur et, dans l'affirmative, supprime tout autre que le tableau encapsulé dans ,s. Par exemple.,_,___,

Pendant et après la création du tableau, nous définissons les expressions rationnelles de comparaison.

,((_+)_+),(\2),/,$1,/
,(_+),(\1_*),/,$2,/

La première d'entre elles, ,((_+)_+),(\2),/,$1,/vérifie une virgule suivie d'une certaine quantité de soulignements, puis de quelques autres, suivis d'une virgule, puis de la première quantité de soulignements, qu'une virgule. Il le remplace ensuite par le nombre total de soulignements dans le premier élément entouré de l' ,art.

Ce dernier, ,(_+),(\1_*),/,$2,/vérifie la présence d'une virgule suivie d'une certaine quantité de tirets bas suivis d'une autre virgule, puis du même montant ou de plusieurs tirets bas, et d'une dernière virgule. Cela laissera à la place le bon élément.

Enfin, quand il y a un élément restant correspondant ^,(_*),$, nous supprimons les virgules environnantes et reconvertissons en décimal via d<>. Ensuite, plus aucune expression régulière ne peut se déclencher et la sortie est présentée.

L'entrée est initialement placée dans le modèle j,b:u<(?#input)>b:, qui convertit d'abord l'entrée décimale en unaire, par exemple 5-> j,b:_____b:, puis l'unaire résultant en binaire, j,101:puis divise le binaire (qui ne fonctionne pas pour l'exemple), obtient le plus grand élément, convertit retour à la décimale, et terminé.

C (gcc), 91 octets

j;m;t;f(x){for(j=m=0;t=x>>j+8;m<t?m=t:j++)t=t<<j|x%(1<<j);return m;}

-23 octets de Colera Su

Prend en charge jusqu'à 2**31-1

Essayez-le en ligne!

Commence par les 8 bits les plus bas (j=0), puis monte, changeant la sortie si le nombre avec des bits [j,j+8)coupés est plus grand que notre courant, et continue jusqu'à ce que x n'ait pas de bits au-dessusj+8

Gelée , 12 octets

BJṡ8ḟ@€ƊịBḄṀ

Essayez-le en ligne!

Octets enregistrés grâce à Jonathan Allan !

JavaScript (ES6), 94 91 octets

-3 octets grâce à Justin Mariner

f=(n,d='',c=n.toString(2).match(`(${d}).{8}(.*)`))=>c?Math.max('0b'+c[1]+c[2],f(n,d+'.')):0

Je lance simplement une solution basée sur des chaînes JavaScript, mais j'espère que quelqu'un publiera une solution distincte basée sur les bits afin que je puisse apprendre quelque chose.

Ma solution récupère récursivement un morceau de 8 bits de la chaîne, en prenant la valeur maximale trouvée.

f=(n,d='',c=n.toString(2).match(`(${d}).{8}(.*)`))=>c?Math.max('0b'+c[1]+c[2],f(n,d+'.')):0

console.log(f(256));
console.log(f(999));
console.log(f(7831));
console.log(f(131585));
console.log(f(7854621));
console.log(f(4294967295));

C # (.NET Core) , 122 + 13 = 135120 + 13 = 133 octets

n=>{int m=0,i=0,t;for(var b=Convert.ToString(n,2);i<b.Length-7;m=t>m?t:m)t=Convert.ToInt32(b.Remove(i++,8),2);return m;}

Essayez-le en ligne!

+13 pour using System;

J'imagine qu'il existe un moyen de le faire sans utiliser Convert. De toute façon, je suis sûr que cela pourrait être réduit.

Remerciements

-2 octets grâce à Kevin Cruijssen

UnGolfed

n=>{
    int m=0,
        i=0,
        t;

    // convert n to a binary string,
    // go through removing each possible byte,
    // check if this is the biggest int so far
    for (var b=Convert.ToString(n,2); i<b.Length-7; m=t>m?t:m)
        t=Convert.ToInt32(b.Remove(i++,8),2); // remove 8 bits from position i, then convert from binary string to int

    return m;
}

PHP, 67 + 1 octets

do$r=max($r,$argn&($x=2**$i++-1)|$z=$argn>>8&~$x);while($z);echo$r;

Exécuter en tant que pipe avec -nRou l' essayer en ligne .

Pyth, 19 octets

eSmi.>>.<.BQd8d2a6l

Réponse alternative:

eSmi.<<8.>.BQdd2a6l

Explication:

eSmi.>>.<.BQd8d2a6lQ | Implicit Q at the end, where Q = input
  m             a6lQ | Map the over [0, 1, 2, ... , floor(log base 2 of Q) - 7]
         .BQ         |  Convert Q to binary string
       .<   d        |  Cyclically rotate left by d
      >      8       |  Get string from position 8 to end.
    .>        d      |  Cyclically rotate right by d
   i           2     |  Convert from binary string to integer
eS                   | Find the last element of sorted list (maximum value)

L'autre réponse utilise une approche similaire, sauf qu'elle tourne en premier à droite et obtient tous les bits sauf les 8 derniers.

MATL , 23 21 octets

Bn8-:"GB[]@8:q+(XBvX>

Essayez-le en ligne!

B                       % Implicitly grab input, convert to binary
 n8-:                   % Create list of 1,2,... n-8, with n the size of the binary string
     "                  % Loop over this list
      GB                % Grab the input again, convert to binary once more.
        @8:q+           % Create indices of a slice of length 8
             [](        % Index into binary string, delete the slice
                XB    % Convert the remainder from binary to integer
                  vX> % Get the maximum number so far.

Malheureusement, Bn8-:8:!+q&)ne produit que les tranches à supprimer, pas le reste que nous aimerions conserver.

Java (OpenJDK 8) , 73 octets

n->{int m=0,i=1;for(;i<n>>7;i*=2)m=Math.max(m,n&~-i|(n>>8&-i));return m;}

Essayez-le en ligne!

Octave , 81 80 octets

@(x)max(bin2dec(dec2bin(x*(c=2.^(0:(b=nextpow2(x+1)-8))))(:,[1:b b+9:end]))'./c)

Essayez-le en ligne!

Il s'agit d'une solution différente de ma tentative d'origine, économisant 14 octets supplémentaires.

Le code se décompose comme suit:

@(x)max(                                                                       )
        bin2dec(                                                          )'./c
                                                         (:,[1:b b+9:end])
                dec2bin(x*(                            ))
                           c=2.^(0:                   )
                                   (b=nextpow2(x+1)-8)

Sur la sixième ligne, le nombre de groupes est calculé en trouvant l'exposant de la puissance suivante de deux plus grand que l'entrée (nombre de bits dans le numéro d'entrée), et en soustrayant 7 car nous supprimons 8 bits de chaque groupe - le nombre résultant est stocké dans b pour plus tard.

Nous calculons ensuite un tableau de puissances de deux sur la cinquième ligne qui est assez grand pour tous les groupes possibles qui peuvent être supprimés. Nous enregistrons cela en variablec pour plus tard.

À la ligne suivante (quatrième ligne), nous multiplions l'entrée par le tableau de puissances de deux (essentiellement le décalage binaire de chaque nombre vers le haut) et convertissons le résultat en binaire. Si nous prenons l'exemple du 7831, cela donne un tableau 2D contenant:

000001111010010111
000011110100101110
000111101001011100
001111010010111000
011110100101110000
111101001011100000

Si nous coupons ensuite les 8 bits du centre, cela équivaut à supprimer chacun des groupes de 8 bits. Cela se fait par la troisième ligne.

Le tableau résultant est reconverti en décimal sur la deuxième ligne. Nous devons également diviser parc pour annuler la mise à l'échelle qui a été effectuée pour chaque groupe au départ.

Enfin, sur la première ligne, une fonction anonyme est déclarée et la valeur maximale de tous les groupes est calculée.

• Économisez 1 octet en utilisant nextpow2(x+1)plutôt quennz(bin2dec(x))

Tentative d'origine - 120 98 95 octets

@(x)max(bin2dec(reshape(repmat(a=(d=@dec2bin)(x)',1,b=nnz(a)-7)(d(255*2.^(0:b-1))'<49),[],b)'))

Essayez-le en ligne!

Le code est divisé comme suit:

@(x)max(                                                                                      )
        bin2dec(                                                                             )
                reshape(                                                              ,[],b)'
                        repmat(a=(d=@dec2bin)(x)',1,b=nnz(a)-7)(                     )
                                                                d(255*2.^(0:b-1))'<49

Fondamentalement, il calcule une matrice contenant les groupes de valeurs possibles qui peuvent être supprimés, puis détermine laquelle finit par donner le plus grand nombre.

En travaillant ligne par ligne, la cinquième ligne calcule les groupes qui peuvent être supprimés. Par exemple, prenez 7831. Il s'agit d'un nombre de 13 bits, donnant aux groupes:

1111100000000
1111000000001
1110000000011
1100000000111
1000000001111
0000000011111

Le résultat de la cinquième ligne est un tableau logique 2D qui peut être utilisé pour l'indexation.

La quatrième ligne du code convertit l'entrée en un tableau de bits (représentés par les caractères «0» et «1»), puis la réplique n-7 fois (oùn en nombre de bits) en donnant une ligne pour chaque regroupement possible. Le masque de groupe ci-dessus est utilisé pour supprimer chacun des groupes possibles.

Sur la troisième ligne, le résultat est ensuite remodelé pour annuler l'aplatissement indésirable résultant de l'application du masque de groupe. La deuxième ligne se reconvertit en un tableau de nombres décimaux résultants. Et la première ligne définit la fonction anonyme comme étant la valeur maximale d'un tableau de groupes possibles.

• Enregistrement de 22 octets en générant la matrice de groupes à l'aide des mathématiques.
• Enregistrement de 3 octets lors de la conversion des chaînes binaires en masque de groupe logique.

Perl 5 , 78 + 1 ( -p) = 79 octets

map{$\=$"if($"=oct$s=~s/.{$_}\K.{8}//r)>$\}2..length($s=sprintf'0b%b',$_)-10}{

Essayez-le en ligne!

Ruby , 55 octets

->n{(8../$/=~"%b"%n).map{|r|n>>8&(a=-1<<r-8)|n&~a}.max}

Essayez-le en ligne!

Perl, 53 octets

(le use 5.10.1pour amener perl au niveau 5.10.1 est gratuit)

Donnez le numéro d'entrée sur STDIN. Manque de mémoire pour les grands nombres, mais le nombre 32 bits en entrée n'est pas encore un problème

#!/usr/bin/perl
use 5.10.1;
$_=sprintf"%b",<>;/.{8}(?{\$F[oct"0b$`$'"]})^/;say$#F