あなたの仕事は、符号なし整数が与えられた場合n、1バイト（連続した8ビット）のデータを削除することで作成できる最大数を見つけることです。

例

番号7831を指定すると、最初にそれをバイナリに変換します（先行ゼロを削除します）：

1111010010111

次に、8ビットの連続したグループを見つけます。これを削除すると、最大の新しい結果が得られます。この場合、以下に示す3つのソリューションがあります

1111010010111
  ^      ^       
   ^      ^
    ^      ^

これらのyieldsのいずれかを削除11111する31と、回答用に10進数値に変換されます。

テストケース

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

ルール

• のビット長はn8より大きいことが保証されています。
• あなたのソリューションは理論的にnは8を超えるビット長で動作するはずですが、実際には、整数255 <n <2 ^16でのみ動作する必要があります
• 入力/出力は10進数でなければなりません。
• 完全なプログラムまたは機能を提出できます。
• これはcode-golfなので、最短のプログラム（バイト単位）が勝ちです！

ゼリー、6バイト

BḄ-8ƤṀ

数値を受け取り、数値を返すモナドリンク。

オンラインでお試しください！

どうやって？

素敵な使用速い、Ƥによって開発され、マイルを ...

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バイト

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

オンラインでお試しください！

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

Python 2、41バイト

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

オンラインでお試しください！

JavaScript（ES6）、54バイト

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>

2 ** 31-1まで動作します。誰かが少しいじる答えを求めたので...

Pyth、21バイト

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

これは再帰関数です（で呼び出すyか、リンクを参照する必要があります）。

ここで試してみてください！

Mathematica、69バイト

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

オンラインでお試しください！

以下のためにこのソリューションは、作品に大きな数字は、オンラインでそれを試してみてください！

KellyLowderから-3バイト

Pythonの3、68の 66 60バイト

^{-Mr. Xcoderのおかげで2バイト！}

^{ovsのおかげで-4バイト！}

^{アウトゴルファーのエリックに感謝-2バイト！}

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

オンラインでお試しください！

Wolfram言語（Mathematica）、46バイト

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

オンラインでお試しください！

このバージョンは、最大2 ^518の入力のみを処理できます。 -1のます。それ以外の場合は、Mathematicaのスタックサイズ制限に達します。（限界はMathematicaのインストールによって異なる場合があります。）この回答の2番目の解決策はそれを回避します。

使い方

次のロジックに基づく再帰的アプローチ：

• 数値からバイトを取り出すと整数が消費される0ため、最大値は未満の入力に対して必要256です。これが私たちの基本的なケースです。そのため、仕様ではそのような入力を処理する必要がないと約束されていますが、含まれています。
• それ以外の場合、Max2つのオプションのいずれかを使用します。最下位バイトを食べる（入力を256）か、最下位ビットを切り捨て、残りの整数を再帰し、完了時に最下位ビットを追加します。

Wolfram言語（Mathematica）、55バイト

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

オンラインでお試しください！

再帰の代わりにテーブルを作成する代替バージョン。したがって、Mathematicaが処理できる任意のサイズの数値で機能します。

網膜、71 67 64バイト

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

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

オンラインでお試しください！リンクには、デニスのサーバーが過度に過負荷にならないように、より高速なテストケースのみが含まれています。編集：@MartinEnderのおかげで3バイトを保存しました。説明：

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

10進数から2進数に変換します。

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

A`_

可能なすべての方法で8桁の連続した数字を削除して取得した文字列のリストを作成します。

O^`
1G`

それらを逆の順序で並べ替え、最初の（最大）を取得します。

+1`\B
:$`:
1

10進数に戻します。（@MartinEnderの説明を参照してください。）

Java（OpenJDK 8）、138 134バイト

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

オンラインでお試しください！

ReRegex、294 275バイト

より良い「関数」定義を使用して19バイトを節約

これは正規表現のみの言語にはかなり良いと思います。

基本ライブラリは、単項と小数の間の変換を許可します（チャレンジ仕様で明示的に小数が指定されているため必要です）が、バイナリはサポートしていません。そのため、120バイトを追加するスクリプトの一部としてそれを記述する必要がありました。

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

オンラインでお試しください！

個々の正規表現による。

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

手順

最初に、2つの正規表現を提供する「ベース」ライブラリをインポートします。u<numbers>単項に変換するもの。そして変換するものd<unary_underlines>、10進数に戻すもの。これは、チャレンジがbase10のIOを必要とするためです。

次に、単項をバイナリに変換する少数の正規表現を定義します。

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

これらの最初は、をb(\d*):(_*)\2_b/b1$1:$2b/検索しb、オプションでいくつかの2進数が続き、a :、その後、任意の量の下線、正確に同じ量の下線+ 1、最後に別のb。

次に、それをb1、前からの2進数:、、アンダースコアの前半部分、最後に最後のに置き換えbます。

したがって、これは、単項が2で割り切れないかどうかをチェックし、割り切れる場合は、1を2進数の前に追加し、マイナス1を2で除算します。

2つ目b(\d*):(_+)\2b/b0$1:$2b/はほぼ同じですが、余分なをチェックしません_。つまり、2で割り切れる場合にのみ一致し、この場合は0代わりにaを追加します。

3番目のものは、単項数字がないかどうかをチェックし、そうでない場合は、パディングを取り除き、2進数字だけを残します。

最後の1つは、2進数字が提供されていないかどうかをチェックし、その場合はそのままになり0ます。

定義する正規表現の次のグループは、バイナリを単項に戻すことであり、もう少し単純です。

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

このグループの最初のグループはB(_*):1/B$1$1_:/、そのアンチテーゼによく似ており、aを検出しB、その後に任意の量の単項数字が続き:1ます。一致をチェックしませんB一度に1桁のみを検索するため、この場合を。これが一致する場合、以前に一致した単項数字の量を2倍にして1を追加し、1を削除します。

2番目の、はB(_*):0/B$1$1:/、a 0ではなくaに一致することを除いて、最初とほぼ同一1であり、追加の単項数字を追加しません。

これらの最後B(_*):B/$1/ので、2進数がもうないかどうかを確認し、ない場合は単項をアンラップします。そのアンチテーゼとは異なり、これは特別な0ケースを必要としません。

次にj、分割関数として機能する正規表現を定義します。

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

1つ目は、j(\d*),\1(\d)(\d{7})(\d*):/j$1$2,$1$2$3$4:,B:$1$4B/ほとんどの重い作業を行います。を検索しj、オプションで「インクリメント」である2進数が続き、次にコンマ、インクリメントが続き、正確に8桁のバイナリ、残りの2進数、aが続き:ます。8桁の最初の数字はインクリメンターに追加され、インクリメントされます。その後、バイナリ入力からの8桁以外のすべてが、:次のaの後に追加されます,。したがって（8の代わりに2桁を使用している場合）j,1001:はj1:1001:,01thenになりj10:1001,01,11ます。さらに、追加された配列要素はBsにラップされて、単項に変換されます。

もう1つはj(\d*),\1\d{0,7}:,?(.*)/,$2,/、インクリメンタの後にチェックするバイナリ桁が8桁未満かどうかをチェックし、残っている場合は、,sでラップされた配列以外をすべて削除します。例えば。,_,___,

配列の作成中および作成後に、比較正規表現を定義します。

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

これらの最初は,((_+)_+),(\2),/,$1,/、コンマの後にいくつかのアンダースコアが続き、さらにいくつかが続き、コンマが続き、最初のアンダースコアがコンマよりも先にチェックされます。次に、,sで囲まれた最初の要素のアンダースコアの合計量に置き換えます。

後者は,(_+),(\1_*),/,$2,/、コンマの後にいくつかのアンダースコアが続き、さらに別のコンマが続き、同じ量以上のアンダースコア、最後のコンマがあるかどうかをチェックします。代わりに、正しい要素が残されます。

最後に、一致する要素が残っている場合^,(_*),$、周囲のコンマを削除し、を介して10進数に戻しますd<>。その後、これ以上正規表現を実行できなくなり、出力が表示されます。

入力は最初にテンプレートj,b:u<(?#input)>b:に配置され、最初に10進数の入力を単項に変換します（例：5-> j,b:_____b:、次に結果の単項をバイナリj,101:に変換） 10進数に戻り、完了です。

C（gcc）、91バイト

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

Colera Suから-23バイト

までサポート 2**31-1

オンラインでお試しください！

下位8ビット(j=0)から開始し、上に移動して、[j,j+8)切り取られたビットの数が現在の値よりも大きい場合に出力を変更し、xのビットがなくなるまで続けますj+8

ゼリー、12バイト

BJṡ8ḟ@€ƊịBḄṀ

オンラインでお試しください！

ジョナサンアランのおかげでバイトを節約できました！

JavaScript（ES6）、94 91バイト

ジャスティン・マリナーのおかげで-3バイト

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

JavaScriptの文字列ベースのソリューションを捨てるだけですが、何かを学ぶために誰かが別のビットベースのソリューションを投稿することを望んでいます。

私のソリューションは、見つかった最大値を取得して、文字列から8ビットのチャンクを再帰的に取得します。

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バイト

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

オンラインでお試しください！

+13 using System;

を使用せずにこれを行う方法があると思いConvertます。いずれにせよ、これは削減できると確信しています。

謝辞

-2バイト、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バイト

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

でパイプとして実行する-nRか、オンラインで試してください。

Pyth、19バイト

eSmi.>>.<.BQd8d2a6l

別の答え：

eSmi.<<8.>.BQdd2a6l

説明：

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)

もう1つの答えは、最初に右に回転し、最後の8以外のすべてのビットを取得することを除いて、同様のアプローチを使用します。

MATL、23 21バイト

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

オンラインでお試しください！

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.

悲しいことに、Bn8-:8:!+q&)削除するスライスのみが生成され、残りのスライスは生成されません。

Java（OpenJDK 8）、73バイト

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

オンラインでお試しください！

オクターブ、81 80バイト

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

オンラインでお試しください！

これは私の最初の試みに対する別の解決策であり、さらに14バイトを節約します。

コードは次のように分類されます。

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

6行目では、入力（入力番号のビット数）よりも大きい次の2のべき乗の指数を求め、各グループから8ビットを削除するときに7を引くことでグループ数が計算されます-結果の数はb後で保存します。

次に、5行目の2のべき乗の配列を計算します。これは、削除可能なすべてのグループに十分な大きさです。これcを後で使用するために変数に保存します。

次の行（4行目）では、入力に2のべき乗の配列を乗算し（基本的に各数値をビットシフトします）、結果をバイナリに変換します。7831の例をとると、これは次を含む2D配列になります。

000001111010010111
000011110100101110
000111101001011100
001111010010111000
011110100101110000
111101001011100000

次に、中央の8ビットを切り出すと、8ビットの各グループを削除することになります。これは3行目で行われます。

結果の配列は、2行目の10進数に変換されます。またc、最初に各グループに対して行われたスケーリングを元に戻すために、分割する必要があります。

最後に、最初の行で匿名関数が宣言され、すべてのグループからの最大値が計算されます。

• nextpow2(x+1)ではなくを使用して1バイト節約nnz(bin2dec(x))

元の試行-120 98 95バイト

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

オンラインでお試しください！

コードは次のように分割されます。

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

基本的には、削除可能な値のグループを含むマトリックスを計算し、最終的に最大数が得られます。

5行目は、行ごとに作業して、削除できるグループを計算します。たとえば、7831を使用します。これは、グループに次の13ビットの数値を与えます。

1111100000000
1111000000001
1110000000011
1100000000111
1000000001111
0000000011111

5行目の結果は、インデックス作成に使用できる2D論理配列です。

コードの4行目は、入力をビットの配列（文字「0」および「1」として表される）に変換し、n-7回（nビット数で）複製して、可能なグループごとに1行を与えます。上記のグループマスクは、考えられる各グループを削除するために使用されます。

3行目では、グループマスクを適用したことで生じた不要な平坦化を元に戻すために、結果の形状が変更されます。2行目は、結果の10進数の配列に変換されます。そして、最初の行は、可能な関数の配列の最大値となる匿名関数を定義しています。

• 数学を使用してグループのマトリックスを生成することにより、22バイトを節約しました。
• バイナリ文字列から論理グループマスクへの変換で3バイトを保存しました。

Perl 5、78 + 1（-p）= 79バイト

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

オンラインでお試しください！

Ruby、55バイト

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

オンラインでお試しください！

Perl、53バイト

（use 5.10.1perlを言語レベル5.10.1にすることは無料です）

STDINに入力番号を指定します。大きな数ではメモリ不足になりますが、入力の32ビット数はまだ問題ではありません

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