Ihre Aufgabe ist es, bei einer vorzeichenlosen Ganzzahl ndie größte Zahl zu finden, die durch Entfernen eines einzelnen Bytes (8 aufeinanderfolgende Bits) von Daten erstellt werden kann.

Beispiel

Angesichts der Zahl 7831konvertieren wir sie zuerst in eine Binärzahl (wobei führende Nullen entfernt werden):

1111010010111

Wir finden dann die aufeinanderfolgende Gruppe von 8 Bits, die, wenn sie entfernt werden, das größte neue Ergebnis liefern. In diesem Fall gibt es drei Lösungen:

1111010010111
  ^      ^       
   ^      ^
    ^      ^

Entfernen Sie diese Ausbeuten 11111, und wandeln Sie sie 31für die Antwort wieder in ihren Dezimalwert um.

Testfälle

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

Regeln

• Es ist garantiert, dass die Bitlänge von ngrößer als 8 ist.
• Ihre Lösung sollte theoretisch für alle Bitlängen ngrößer als 8 funktionieren, in der Praxis muss sie jedoch nur für Ganzzahlen 255 <n <2 ¹⁶ funktionieren
• Eingabe / Ausgabe sollte dezimal sein.
• Sie können ein vollständiges Programm oder eine Funktion einreichen.
• Das ist Code-Golf , also gewinnt das kürzeste Programm (in Bytes)!

Gelee , 6 Bytes

BḄ-8ƤṀ

Ein monadischer Link, der eine Nummer aufnimmt und eine Nummer zurückgibt.

Probieren Sie es online!

Wie?

Verwendet eine schöne schnelle , Ƥvon Meilen entwickelte ...

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 Bytes

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

Probieren Sie es online!

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

Python 2 , 41 Bytes

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

Probieren Sie es online!

JavaScript (ES6), 54 Byte

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>

Funktioniert bis zu 2 ** 31-1. Weil jemand nach einer etwas kribbelnden Antwort gefragt hat ...

Pyth , 21 Bytes

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

Dies ist eine rekursive Funktion (muss mit yoder über den Link aufgerufen werden ).

Probieren Sie es hier aus!

Mathematica, 69 Bytes

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

Probieren Sie es online!

Diese Lösung funktioniert für große Zahlen Probieren Sie es online!

-3 Bytes von KellyLowder

Python 3 , 68 66 60 Bytes

^{-2 Bytes dank Mr. Xcoder!}

^{-4 Bytes dank ovs!}

^{-2 Bytes dank Erik dem Outgolfer!}

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

Probieren Sie es online!

Wolfram Language (Mathematica) , 46 Byte

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

Probieren Sie es online!

Diese Version kann nur Eingaben bis zu 2 ⁵¹⁸ -1 verarbeiten, andernfalls stoßen wir auf die ^maximale Stapelgröße von Mathematica. (Die Grenze kann zwischen Mathematica-Installationen variieren.) Die zweite Lösung in dieser Antwort vermeidet dies.

Wie es funktioniert

Ein rekursiver Ansatz, der auf der folgenden Logik basiert:

• Der Maximalwert sollte 0für jede Eingabe kleiner als sein 256, da ein Byte aus der Zahl die ganze Zahl frisst. Dies ist unser Basisfall, weshalb er enthalten ist, obwohl die Spezifikationen uns versprechen, dass wir solche Eingaben nicht verarbeiten müssen.
• Andernfalls haben wir Maxzwei Möglichkeiten: das niedrigste Byte essen (Eingabe dividiert durch 256) oder das niedrigste Bit abhacken, die verbleibende Ganzzahl erneut verarbeiten und das niedrigste Bit zurückhängen, wenn wir fertig sind.

Wolfram Language (Mathematica) , 55 Byte

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

Probieren Sie es online!

Eine alternative Version, die eine Tabelle anstelle einer Rekursion erstellt, sodass sie für Zahlen jeder Größe funktioniert, die Mathematica verarbeiten kann.

Retina , 71 67 64 Bytes

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

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

Probieren Sie es online! Link enthält nur die schnelleren Testfälle, um Dennis 'Server nicht unnötig zu überlasten. Bearbeiten: 3 Bytes dank @MartinEnder gespeichert. Erläuterung:

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

Konvertiert von Dezimal in Binär.

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

A`_

Erstellen Sie eine Liste von Zeichenfolgen, indem Sie 8 aufeinanderfolgende Ziffern auf alle möglichen Arten löschen.

O^`
1G`

Sortiere sie in umgekehrter Reihenfolge und nimm die erste (größte).

+1`\B
:$`:
1

Zurück in Dezimalzahl konvertieren. (Siehe @ MartinEnder Erklärung .)

Java (OpenJDK 8) , 138 bis 134 Byte

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

Probieren Sie es online!

ReRegex , 294 275 Bytes

Durch Verwendung besserer 'Funktions'-Definitionen wurden 19 Bytes eingespart

Ich würde sagen, das ist ziemlich gut für eine Regex-Sprache.

Die Basisbibliothek ermöglicht die Konvertierung zwischen Unary und Decimal (was erforderlich ist, da die Challenge-Spezifikation explizit Decimal angibt), unterstützt jedoch nicht Binary. Also musste ich das als Teil des Skripts schreiben und 120 Bytes hinzufügen.

#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:

Probieren Sie es online!

Nach individuellen Regeln.

#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:

Schritte

Zunächst importieren wir die 'base'-Bibliothek, die zwei reguläre Ausdrücke enthält. Eine, die sich u<numbers>in eine unäre umwandelt . Und eine, die sich d<unary_underlines>wieder in Dezimalzahlen umwandelt . Dies liegt daran, dass die Herausforderung IO in base10 erfordert.

Dann definieren wir eine Handvoll regulärer Ausdrücke, die unär in binär konvertieren.

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

Der erste b(\d*):(_*)\2_b/b1$1:$2b/sucht nach b, optional gefolgt von einigen Binärziffern, dann nach a :, dann nach einer beliebigen Anzahl von Unterstreichungen, gefolgt von genau der gleichen Anzahl von Unterstreichungen plus einer und schließlich einer weiteren b.

Wir ersetzen das dann durch b1gefolgt von den Binärziffern von zuvor :und nur der ersten Hälfte der Unterstriche und schließlich der letzten b.

Dies überprüft also, ob der Unary nicht durch zwei teilbar ist, und stellt in diesem Fall 1 vor die Binärziffern und dividiert sie dann minus eins durch zwei.

Das zweite b(\d*):(_+)\2b/b0$1:$2b/ist fast idendisch, prüft jedoch nicht auf ein Extra _, dh es stimmt nur überein, wenn es durch zwei teilbar ist, und stellt in diesem Fall stattdessen ein voran 0.

Die dritte prüft, ob wir keine unären Ziffern mehr haben, und entfernt in diesem Fall die Polsterung, um nur die binären Ziffern zu belassen.

Der letzte prüft, ob keine Binärziffern angegeben wurden, und geht dann einfach 0.

Die nächste Gruppe von Regexen, die wir definieren, besteht darin, Binärdaten wieder in Unärdaten umzuwandeln. Sie sind etwas einfacher.

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

Die erste dieser Gruppe B(_*):1/B$1$1_:/erkennt, ähnlich wie ihre Antithese, a B, gefolgt von einer beliebigen Anzahl von unären Ziffern :1. BIn diesem Fall wird nicht nach Übereinstimmungen gesucht, da immer nur nach einer Ziffer gesucht wird. Wenn dies zutrifft, verdoppelt es die zuvor übereinstimmende Anzahl von unären Ziffern und fügt eine hinzu und entfernt dann die eine.

Die zweite, B(_*):0/B$1$1:/ist fast identisch mit der ersten, abgesehen von Übereinstimmungen mit a 0anstelle von a 1, und fügt keine zusätzliche unäre Ziffer hinzu.

Der letzte B(_*):B/$1/Befehl prüft, ob keine Binärziffern mehr vorhanden sind, und packt den Unären aus, falls dies der Fall ist. Im Gegensatz zu seiner Antithese benötigt dies keinen speziellen 0-Fall.

Als nächstes definieren wir die jregulären Ausdrücke, die als Aufteilungsfunktion fungieren.

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

Der erste j(\d*),\1(\d)(\d{7})(\d*):/j$1$2,$1$2$3$4:,B:$1$4B/macht den größten Teil des schweren Hebens. Es wird gesucht j, optional gefolgt von Binärziffern, die der "Inkrementierer" sind, dann ein Komma, gefolgt vom Inkrementierer, dann genau 8 Binärziffern, gefolgt vom Rest der Binärzahl, dann a :. Die erste der 8 Ziffern wird an den Inkrementierer angehängt, wodurch dieser inkrementiert wird. Danach wird nach dem :folgenden a alles andere als diese 8 Ziffern vom Binäreingang angehängt ,. Also (wenn wir 2 statt 8 Ziffern verwenden j,1001:würden ) würde es j1:1001:,01dann werden j10:1001,01,11. Darüber hinaus werden die angehängten Array-Elemente in Bs eingeschlossen, um sie wieder in unary umzuwandeln.

Die andere j(\d*),\1\d{0,7}:,?(.*)/,$2,/prüft, ob nach dem Inkrementierer weniger als 8 Binärziffern übrig sind, und entfernt in diesem Fall alles andere als das in ,s eingeschlossene Array . Z.B.,_,___,

Während und nach der Erstellung des Arrays definieren wir die Vergleichsregexes.

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

Bei der ersten ,((_+)_+),(\2),/,$1,/Option wird ein Komma gefolgt von einer bestimmten Anzahl von Unterstrichen und einer weiteren, gefolgt von einem Komma gefolgt von der ersten Anzahl von Unterstrichen und einem Komma überprüft. Anschließend wird es durch die Gesamtzahl der Unterstriche im ersten Element ersetzt, das von ,s umgeben ist.

Letzteres ,(_+),(\1_*),/,$2,/sucht nach einem Komma, gefolgt von einer bestimmten Anzahl von Unterstrichen, gefolgt von einem weiteren Komma, der gleichen Menge oder mehreren Unterstrichen und einem letzten Komma. Dies wird stattdessen das richtige Element belassen.

Wenn schließlich noch ein passendes Element übrig ist ^,(_*),$, entfernen wir die umgebenden Kommas und konvertieren zurück in das Dezimal-Via d<>. Dann können keine regulären Ausdrücke mehr ausgelöst werden und die Ausgabe wird präsentiert.

Die Eingabe wird anfangs in die Vorlage eingefügt j,b:u<(?#input)>b:, die zuerst die Dezimaleingabe in Unär umwandelt, z. B. 5-> j,b:_____b:, dann die resultierende Unärzahl in Binärzahl, j,101:dann die Binärzahl aufteilt (was für das Beispiel nicht funktioniert), das größte Element erhält, konvertiert zurück zur Dezimalzahl und fertig.

C (gcc) 91 Bytes

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 Bytes von Colera Su

Unterstützt bis zu 2**31-1

Probieren Sie es online!

Beginnt mit den niedrigen 8 Bits (j=0), steigt dann an und ändert die Ausgabe, wenn die Zahl mit den ausgeschnittenen Bits [j,j+8)größer als unsere aktuelle ist, und fährt fort, bis x keine Bits mehr darüber hatj+8

Gelee , 12 Bytes

BJṡ8ḟ@€ƊịBḄṀ

Probieren Sie es online!

Gespeicherte Bytes dank Jonathan Allan !

JavaScript (ES6), 94 91 Byte

-3 Bytes dank Justin Mariner

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

Wir werfen nur eine auf JavaScript-Strings basierende Lösung raus, aber ich hoffe, dass jemand eine separate auf Bit basierende Lösung veröffentlicht, damit ich etwas lernen kann.

Meine Lösung greift rekursiv nach einem 8-Bit-Block aus der Zeichenfolge und nimmt den gefundenen Maximalwert.

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 = 135, 120 + 13 = 133 Byte

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

Probieren Sie es online!

+13 für using System;

Ich stelle mir vor, es gibt eine Möglichkeit, dies ohne Verwendung von zu tun Convert. Ich bin mir sicher, dass dies reduziert werden könnte.

Danksagung

-2 Bytes dank 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 Bytes

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

Laufen Sie als Pipe mit -nRoder versuchen Sie es online .

Pyth, 19 Bytes

eSmi.>>.<.BQd8d2a6l

Alternative Antwort:

eSmi.<<8.>.BQdd2a6l

Erläuterung:

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)

Die andere Antwort verwendet einen ähnlichen Ansatz, außer dass sie sich zuerst nach rechts dreht und alle Bits mit Ausnahme der letzten 8 abruft.

MATL , 23 21 Bytes

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

Probieren Sie es online!

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.

Leider werden Bn8-:8:!+q&)nur die zu entfernenden Scheiben erzeugt, nicht der Rest, den wir behalten möchten.

Java (OpenJDK 8) , 73 Byte

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

Probieren Sie es online!

Oktave , 81 80 Bytes

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

Probieren Sie es online!

Dies ist eine andere Lösung als mein ursprünglicher Versuch, weitere 14 Bytes einzusparen.

Der Code setzt sich wie folgt zusammen:

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

In der sechsten Zeile wird die Anzahl der Gruppen berechnet, indem der Exponent der nächsten Zweierpotenz ermittelt wird, der größer ist als die Eingabe (Anzahl der Bits in der Eingabenummer), und 7 subtrahiert wird, wenn 8 Bits aus jeder Gruppe entfernt werden bfür später gespeichert .

Wir berechnen dann ein Array von Zweierpotenzen in der fünften Zeile, das groß genug für alle möglichen Gruppen ist, die entfernt werden können. Wir speichern dies cfür später in einer Variablen .

In der nächsten Zeile (vierten Zeile) multiplizieren wir die Eingabe mit dem Array von Zweierpotenzen (im Wesentlichen Bitverschiebung jeder Zahl nach oben) und konvertieren das Ergebnis in binär. Wenn wir das Beispiel von 7831 nehmen, ergibt dies ein 2D-Array mit:

000001111010010111
000011110100101110
000111101001011100
001111010010111000
011110100101110000
111101001011100000

Wenn wir dann die mittleren 8 Bits herausschneiden, entspricht dies dem Entfernen jeder der 8-Bit-Gruppen. Dies geschieht in der dritten Zeile.

Das resultierende Array wird in der zweiten Zeile wieder in Dezimalzahlen umgewandelt. Wir müssen auch durch teilen c, um die Skalierung, die anfangs für jede Gruppe durchgeführt wurde , rückgängig zu machen.

Schließlich wird in der ersten Zeile eine anonyme Funktion deklariert und der Maximalwert aller Gruppen berechnet.

• Sparen Sie 1 Byte, indem Sie nextpow2(x+1)anstatt verwendennnz(bin2dec(x))

Ursprünglicher Versuch - 120 98 95 Bytes

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

Probieren Sie es online!

Der Code ist wie folgt aufgeteilt:

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

Grundsätzlich wird eine Matrix berechnet, die die möglichen Wertegruppen enthält, die entfernt werden können, und anschließend wird berechnet, welche die größte Zahl ergibt.

Die fünfte Zeile berechnet zeilenweise die Gruppen, die entfernt werden können. Nehmen Sie zum Beispiel 7831. Dies ist eine 13-Bit-Zahl mit den folgenden Gruppen:

1111100000000
1111000000001
1110000000011
1100000000111
1000000001111
0000000011111

Das Ergebnis der fünften Zeile ist ein logisches 2D-Array, das zur Indizierung verwendet werden kann.

Die vierte Codezeile konvertiert die Eingabe in ein Array der Bits (dargestellt als Zeichen '0' und '1') und repliziert es dann n-7 Mal (wobei die nAnzahl der Bits angegeben ist), wobei für jede mögliche Gruppierung eine Zeile angegeben wird. Die Gruppenmaske oben wird verwendet, um jede der möglichen Gruppen zu entfernen.

In der dritten Zeile wird das Ergebnis dann umgeformt, um die unerwünschte Verflachung aufzuheben, die durch das Anwenden der Gruppenmaske verursacht wurde. Die zweite Zeile konvertiert zurück in ein Array von resultierenden Dezimalzahlen. Und die erste Zeile definiert die anonyme Funktion als den Maximalwert des Arrays möglicher Gruppen.

• 22 Bytes gespart durch Generieren der Gruppenmatrix mit Mathematik.
• 3 Byte bei der Konvertierung von binären Zeichenfolgen in eine logische Gruppenmaske gespeichert.

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

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

Probieren Sie es online!

Ruby , 55 Bytes

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

Probieren Sie es online!

Perl, 53 Bytes

(das use 5.10.1perl auf lanugage level 5.10.1 bringen ist kostenlos)

Geben Sie die Eingangsnummer bei STDIN ein. Der Speicher für große Zahlen wird knapp, aber die 32-Bit-Zahl in der Eingabe ist noch kein Problem

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