당신의 작업은 부호없는 integer가 주어지면 n1 바이트 (8 연속 비트)의 데이터를 제거하여 만들 수있는 가장 큰 숫자를 찾는 것입니다.

예

number가 주어지면 7831먼저 이진수를 이진수로 변환합니다 (앞의 0을 제거).

1111010010111

그런 다음 제거 될 때 가장 큰 새로운 결과를 산출하는 8 비트의 연속 그룹을 찾습니다. 이 경우 아래에 표시된 세 가지 솔루션이 있습니다.

1111010010111
  ^      ^       
   ^      ^
    ^      ^

이 yields를 제거 하면 답 11111을 위해 10 진수 값으로 다시 변환됩니다 31.

테스트 사례

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

규칙

• 비트 길이는 n8보다 커야합니다.
• 솔루션은 이론적으로 n8보다 큰 비트 길이에서 작동해야 하지만 실제로는 정수 255 <n <2 ¹⁶
• 입력 / 출력은 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

파이썬 2 , 41 바이트

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

온라인으로 사용해보십시오!

자바 스크립트 (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 하거나 링크 참조).

여기 사용해보십시오!

수학, 69 바이트

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

온라인으로 사용해보십시오!

이 솔루션은 많은 수의 온라인에서 작동합니다 !

KellyLowder에서 -3 바이트

파이썬 3 , 68 66 60 바이트

^{Mr. Xcoder 덕분에 -2 바이트 !}

^{ovs 덕분에 -4 바이트 !}

^{Outgolfer Erik 덕분에 -2 바이트 !}

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

온라인으로 사용해보십시오!

볼프람 언어 (수학) , 46 바이트

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

온라인으로 사용해보십시오!

이 버전은 최대 2 개의 입력 만 처리 할 수 ​​있습니다 ⁵¹⁸ -1의 . 그렇지 않으면 Mathematica의 스택 크기 제한이 적용됩니다. (Mathematica 설치마다 범위가 다를 수 있습니다.)이 답변의 두 번째 솔루션은이를 방지합니다.

작동 원리

다음 논리를 기반으로하는 재귀 적 접근 방식 :

• 최대 값이어야 0미만 모든 입력256숫자에서 바이트를 빼면 정수 . 이것이 우리의 기본 사례이므로 사양이 우리에게 그러한 입력을 처리 할 필요가 없다고 약속하더라도 포함되어 있습니다.
• 그렇지 않으면, 우리 Max는 두 가지 옵션 중 하나를 취합니다 : 가장 낮은 바이트를 먹거나 (입력을으로 나눔 256) 또는 가장 낮은 비트를 잘라 내고, 나머지 정수를 재귀하고, 끝났을 때 가장 낮은 비트를 다시 추가하십시오.

Wolfram Language (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

온라인으로 사용해보십시오! 링크에는 더 빠른 테스트 사례 만 포함되므로 Dennis 서버에 지나치게 과부하가 걸리지 않습니다. 편집 : @MartinEnder 덕분에 3 바이트가 절약되었습니다. 설명:

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

십진수를 이진수로 변환합니다.

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

A`_

가능한 모든 방법으로 8 개의 연속 숫자를 삭제하여 얻은 문자열 목록을 구성하십시오.

O^`
1G`

역순으로 정렬하고 첫 번째 (가장 큰) 것을 취하십시오.

+1`\B
:$`:
1

십진수로 다시 변환합니다. (@MartinEnder의 설명 참조 )

자바 (오픈 JDK 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 바이트 절약

나는 이것이 정규식 전용 언어에 꽤 좋다고 말하고 싶습니다.

기본 lib는 Unary와 Decimal 사이의 변환을 허용하지만 (챌린지 사양에 명시 적으로 10 진수가 명시되어 있으므로 필요) Binary는 지원하지 않습니다. 그래서 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:

단계

먼저 'base'라이브러리를 가져와 두 개의 정규 표현식을 제공합니다. u<numbers>단항으로 변환 하는 것. 그리고 d<unary_underlines>다시 십진수 로 변환하는 것 입니다. 문제는 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임의로 다음 약간 이진수하는 다음 :,이어서 동일한 밑줄 양을 더한, 마지막으로 다른 밑줄 뒤에 어떤 양 b.

그런 다음 그 b1이전의 :, 및 밑줄의 첫 절반과 마지막의 이진수로 바꿉니다 b.

따라서 단항을 2로 나눌 수 없는지 확인하고, 그렇다면 1을 2 진수 앞에 추가 한 다음 1을 2로 나눕니다.

두 번째 b(\d*):(_+)\2b/b0$1:$2b/는 거의 동일하지 않지만 extra를 확인하지 않으므로 _2로 나눌 수있는 경우에만 일치 하며이 경우 0대신 앞에 추가 됩니다.

세 번째는 우리가 단항 숫자가 아닌지 확인하고, 그렇다면 이진수를 남기기 위해 패딩을 제거합니다.

마지막은 이진 숫자가 제공되지 않았는지 확인하고이 경우 그냥 떠납니다 0.

우리가 정의한 다음 Regex 그룹은 바이너리를 단항으로 다시 변환하는 것이며 약간 더 간단합니다.

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

이 그룹의 첫 번째 그룹 B(_*):1/B$1$1_:/은 대립 법과 마찬가지로 B, 다음에 임의의 양의 단항 숫자를 감지합니다 :1. B이 경우 한 번에 한 자리 만 검색하기 때문에 일치 여부를 확인하지 않습니다 . 일치하면 이전에 일치 한 단항 자릿수를 두 배로 늘리고 1을 더한 다음 제거합니다.

두 번째 B(_*):0/B$1$1:/는 첫 번째와 거의 동일 0하지만1 하고는 단항 숫자를 추가하지 않습니다.

이 중 마지막은 B(_*):B/$1/이진수가 더 이상 없는지 확인하고, 그렇지 않은 경우 단항을 줄입니다. 대립과 달리 특별한 경우는 필요하지 않습니다.

다음 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,/

첫 번째 j(\d*),\1(\d)(\d{7})(\d*):/j$1$2,$1$2$3$4:,B:$1$4B/는 대부분의 무거운 작업을 수행합니다. 이는 검색 j임의로 "증 분기"이다 이진수 뒤에 다음 콤마는 정확히 8 이진수이 후, 이진수의 나머지 뒤에 증 분기 하였다 :. 8 자리 숫자 중 첫 번째 자리가 증 분자에 추가되어 증분 된 다음 이진 입력에서 8 자리 이외의 모든 것이 :다음 a 뒤에 추가됩니다 ,. (우리가 대신 8의 두 자리 숫자를 사용한다면) 그래서 j,1001:될 것입니다 j1:1001:,01후 j10:1001,01,11. 또한 추가 된 배열 요소는 Bs 로 래핑되어 다시 단항으로 변환됩니다.

다른 하나 j(\d*),\1\d{0,7}:,?(.*)/,$2,/는 증분 후 점검 할 이진 숫자가 8 개 미만인지 확인하고,있는 경우 ,s로 래핑 된 배열 이외의 모든 항목을 제거합니다 . 예 :,_,___,

배열을 만드는 동안과 후에 우리는 비교 정규 표현식을 정의합니다.

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

이들 중 첫 번째는 ,((_+)_+),(\2),/,$1,/쉼표를 확인한 다음 쉼표보다 약간의 밑줄, 쉼표, 쉼표, 첫 번째 밑줄을 확인합니다. 그런 다음 ,s로 둘러싸인 첫 번째 요소의 총 밑줄 수로 바꿉니다 .

후자 ,(_+),(\1_*),/,$2,/는 쉼표를 확인한 다음 일부 밑줄, 다른 쉼표, 같은 금액 이상의 밑줄 및 마지막 쉼표를 확인합니다. 대신 올바른 요소가 남습니다.

마지막으로 일치하는 요소가 왼쪽에 있으면 ^,(_*),$주변 쉼표를 제거하고 다음을 통해 십진수로 다시 변환합니다.d<> 합니다. 그런 다음 더 이상 정규 표현식을 실행할 수 없으며 출력이 표시됩니다.

입력은 처음에 템플릿에 배치됩니다. j,b:u<(?#input)>b:먼저 소수 입력을 단항으로 변환합니다 (예 : 5->) j,b:_____b:, 결과 단항을 이진수로 변환 한 j,101:다음 이진을 분할하고 (이 예제에서는 작동하지 않음) 가장 큰 요소를 가져옵니다. 십진수로 돌아가서 끝났습니다.

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ḄṀ

온라인으로 사용해보십시오!

Jonathan Allan 덕분에 바이트를 절약했습니다 !

자바 스크립트 (ES6), 94 91 바이트

Justin Mariner 덕분에 -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 코어) , 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합니다. 어느 쪽이든, 나는 이것이 줄어들 수 있다고 확신합니다.

감사의 말

Kevin Cruijssen 덕분에 -2 바이트

언 골프

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)

다른 대답은 먼저 오른쪽으로 회전하고 마지막 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&)제거 할 슬라이스 만 생성하고 나머지는 유지하지 않습니다.

자바 (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)

여섯 번째 줄에서 그룹 수는 입력보다 2보다 큰 다음 거듭 제곱 지수 (입력 번호의 비트 수)를 찾아 각 그룹에서 8 비트를 제거 할 때 7을 빼서 계산됩니다. 결과 수는 다음과 같습니다. b나중에 저장합니다 .

그런 다음 다섯 번째 줄에서 2의 거듭 제곱을 계산하여 제거 할 수있는 모든 가능한 그룹에 대해 충분히 큽니다. c나중에 변수 에 저장합니다 .

다음 라인업 (4 번째 라인)에서는 입력에 2의 거듭 제곱 (필수적으로 각 숫자를 비트 시프트)의 배열을 곱하고 결과를 이진수로 변환합니다. 7831의 예를 들면 다음과 같은 2D 배열이 생성됩니다.

000001111010010111
000011110100101110
000111101001011100
001111010010111000
011110100101110000
111101001011100000

중앙 8 비트를 잘라 내면 8 비트 그룹을 제거하는 것과 같습니다. 이것은 세 번째 줄에 의해 수행됩니다.

결과 배열은 두 번째 줄에서 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

기본적으로 제거 할 수있는 가능한 값 그룹이 포함 된 행렬을 계산 한 다음 가장 큰 숫자를 제공합니다.

한 줄씩 작업하면 다섯 번째 줄은 제거 할 수있는 그룹을 계산합니다. 예를 들어, 7831을 사용하십시오. 이것은 13 비트 숫자이며 그룹에 다음을 제공합니다.

1111100000000
1111000000001
1110000000011
1100000000111
1000000001111
0000000011111

다섯 번째 줄의 결과는 인덱싱에 사용할 수있는 2D 논리 배열입니다.

코드의 네 번째 줄은 입력을 비트 배열 (문자 '0'과 '1'로 표시)로 변환 한 다음 가능한 각 그룹화에 대해 한 줄을 제공 하여 n-7 번 ( n비트 수로) 복제합니다 . 위의 그룹 마스크는 가능한 각 그룹을 제거하는 데 사용됩니다.

세 번째 줄에서 그룹 마스크를 적용한 결과 원치 않는 평탄화가 실행 취소되도록 결과가 재구성됩니다. 두 번째 줄은 결과 10 진수 배열로 다시 변환됩니다. 첫 번째 줄은 익명 함수를 가능한 그룹 배열의 최대 값으로 정의합니다.

• 수학을 사용하여 그룹 행렬을 생성하여 22 바이트를 절약했습니다.
• 이진 문자열을 논리 그룹 마스크로 변환하여 3 바이트를 절약했습니다.

Perl 5 , 78 + 1 ( -p) = 79 바이트

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

온라인으로 사용해보십시오!

루비 , 55 바이트

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

온라인으로 사용해보십시오!

펄, 53 바이트

( use 5.10.1펄 레벨을 언어 5.10.1로 가져 오는 것은 무료입니다)

STDIN에 입력 번호를 제공하십시오. 큰 숫자의 메모리가 부족하지만 입력의 32 비트 숫자는 아직 문제가되지 않습니다.

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