Zabierz z tego bajt!

24

Twoim zadaniem jest, biorąc pod uwagę liczbę całkowitą bez znaku n, znaleźć największą liczbę, którą można utworzyć, usuwając pojedynczy bajt (8 kolejnych bitów) danych.


Przykład

Biorąc pod uwagę liczbę 7831, najpierw konwertujemy ją na binarną (usuwając wszelkie zera na początku):

1111010010111

Następnie znajdujemy kolejną grupę 8 bitów, które po usunięciu dają największy nowy wynik. W tym przypadku istnieją 3 rozwiązania pokazane poniżej

1111010010111
  ^      ^       
   ^      ^
    ^      ^

Usuwając to dowolne z tych zbiorów 11111, które następnie przeliczamy z powrotem na wartość dziesiętną 31dla odpowiedzi.


Przypadki testowe

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

Zasady

  • Gwarantujemy, że długość bitu nbędzie większa niż 8.
  • Twoje rozwiązanie powinno teoretycznie działać na dowolnej długości bitów nwiększej niż 8, ale w praktyce wymaga pracy tylko dla liczb całkowitych 255 <n <2 16
  • Dane wejściowe / wyjściowe powinny być dziesiętne.
  • Możesz przesłać pełny program lub funkcję.
  • To jest , więc wygrywa najkrótszy program (w bajtach)!
FlipTack
źródło
1
Nie rozumiem, dlaczego ludzie umieszczają wykrzykniki w tytułach konkursowych! Myślę, że może to być ograniczenie liczby znaków! Może być tak, aby ludzie zauważyli wyzwanie!
dkudriavtsev
1
@Mendeleev To zdanie nadrzędne. Są one zwykle zakończone wykrzyknikami. To tylko poprawna interpunkcja, dlaczego cię to tak denerwuje?
Arthur
1
@Mendeleev Ludzie często używają wykrzyknika, aby wskazać żart. OP podkreśla fakt, że robi kalambur. F. Scott Fitzgerald nie lubił tego , ale w tym kontekście wydaje mi się to w porządku. Gdyby go nie było, prawdopodobnie ludzie narzekaliby na jego pisownię.
bornfromanegg
@Mendeleev, ponieważ jest to zły kalambur ...
FlipTack,
@bornfromanegg Czuję się, jakby ludzie zauważyli kalambur
dkudriavtsev

Odpowiedzi:

16

Galaretka , 6 bajtów

BḄ-8ƤṀ

Monadyczny link pobierający numer i zwracający numer.

Wypróbuj online!

W jaki sposób?

Używa miłym szybkie , Ƥopracowany przez mil ...

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
Jonathan Allan
źródło
> _> ... Wow, pobiłeś mnie o 10 bajtów
Mr. Xcoder,
8

J , 12 bajtów

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

Wypróbuj online!

          #:     to binary
     8  \.       remove consecutive groups of eight
      #.         convert each result to decimal
  >./            maximum
[:               do nothing, this lets me avoid parentheses
FrownyFrog
źródło
Jaki masz fajny algorytm? Czy możesz dodać wyjaśnienie?
Pan Xcoder,
@Pan. Xcoder FrownyFrog konwertuje liczbę na listę cyfr binarnych (#:), a następnie konwertuje wszystkie 8-outfiksy lub listę z kolejnymi 8-bitowymi poprawkami usuniętymi z powrotem do systemu liczb dziesiętnych (8 #. \.) I ostatecznie przyjmuje duży kamień. [: po prostu ogranicza dwa poprzednie czasowniki, wykonując> ./, które ma być wykonywane monadycznie (tylko z właściwym argumentem)
Galen Iwanow
Nauczyłeś mnie dzisiaj o outfixie, dzięki za to! Szkoda, że ​​nie wydaje się być krótszy w użyciu pod- &.; jest to idealny rodzaj problemu.
cole
6

JavaScript (ES6), 54 bajty

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>

Działa do 2 ** 31-1. Ponieważ ktoś poprosił o nieco kręcącą się odpowiedź ...

Neil
źródło
4

Pyth , 21 bajtów

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

Jest to funkcja rekurencyjna (należy ją wywołać za pomocą ylub zobaczyć link).

Wypróbuj tutaj!

Pan Xcoder
źródło
3

Mathematica, 69 bajtów

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

Wypróbuj online!

To rozwiązanie działa na duże liczby Wypróbuj online!

-3 bajty od KellyLowder

J42161217
źródło
Zaoszczędź 3 kolejne bajty:Max[c=#~RealDigits~2;Array[Drop[c[[1]],#;;#+7]~FromDigits~2&,Last@c-7]]&
Kelly Lowder
1
@KellyLowder nice! Grałem trochę w golfa w Twoje rozwiązanie
J42161217,
3

Wolfram Language (Mathematica) , 46 bajtów

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

Wypróbuj online!

Ta wersja obsługuje tylko dane wejściowe do 2 518 -1, w przeciwnym razie napotkamy limit wielkości stosu Mathematiki. (Granice mogą się różnić w zależności od instalacji Mathematica). Drugie rozwiązanie w tej odpowiedzi pozwala tego uniknąć.

Jak to działa

Podejście rekurencyjne oparte na następującej logice:

  • Maksymalna wartość powinna być 0dla każdego wejścia mniejsza niż 256, ponieważ usunięcie bajtu z liczby zjada całą liczbę. To jest nasz podstawowy przypadek, dlatego został uwzględniony, mimo że specyfikacje obiecują nam, że nie będziemy musieli obsługiwać takich danych wejściowych.
  • W przeciwnym razie bierzemy Maxdwie opcje: zjedz najniższy bajt (dzieląc się z nami danymi wejściowymi 256) lub odetnij najniższy bit, powtórz na pozostałej liczbie całkowitej i dołącz ponownie najniższy bit, gdy skończymy.

Wolfram Language (Mathematica) , 55 bajtów

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

Wypróbuj online!

Alternatywna wersja, która buduje tabelę zamiast rekurencji, więc działa dla liczb dowolnej wielkości, które Mathematica może obsłużyć.

Misza Ławrow
źródło
2
Głębokość rekurencji jest przekroczona dla liczb większych niż 10 ^ 160, chociaż matematyka może obsługiwać większe liczby. Ale myślę, że OP jest w porządku
J42161217,
2

Retina , 71 67 64 bajtów

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

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

Wypróbuj online! Link zawiera tylko szybsze przypadki testowe, aby nie nadmiernie przeciążać serwera Dennisa. Edycja: Zapisano 3 bajty dzięki @MartinEnder. Wyjaśnienie:

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

Konwertuj z dziesiętnego na dwójkowy.

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

A`_

Zbuduj listę ciągów znaków, usuwając 8 kolejnych cyfr na wszystkie możliwe sposoby.

O^`
1G`

Posortuj je w odwrotnej kolejności i wybierz pierwszą (największą).

+1`\B
:$`:
1

Konwertuj z powrotem na dziesiętne. (Zobacz wyjaśnienie @ MartinEnder .)

Neil
źródło
1
Jakiś czas temu wymyśliłem tę krótszą konwersję binarną na dziesiętną . W tej odpowiedzi wyjaśniłem, jak to działa .
Martin Ender
2

Java (OpenJDK 8) , 138 134 bajtów

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

Wypróbuj online!

Roberto Graham
źródło
1
i.toBinaryString(i)może być i.toString(i,2).
Kevin Cruijssen
2

ReRegex , 294 275 bajtów

Zaoszczędzono 19 bajtów dzięki lepszym definicjom „funkcji”

Powiedziałbym, że jest to całkiem dobre dla języka opartego tylko na Regex.

Podstawowa biblioteka lib pozwala na konwersję między jednostkową i dziesiętną (co jest potrzebne, ponieważ specyfikacja wyzwania wyraźnie określa dziesiętną), ale nie obsługuje wersji binarnej; Musiałem więc napisać to jako część skryptu, dodając do niego 120 bajtów.

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

Wypróbuj online!

Według poszczególnych regeksów.

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

Kroki

Po pierwsze, importujemy bibliotekę „podstawową”, która daje dwa wyrażenia regularne. Ten, który konwertujeu<numbers> w jedność. I taki, który konwertuje z d<unary_underlines>powrotem na dziesiętne. Wynika to z faktu, że wyzwanie wymaga IO w bazie 10.

Następnie definiujemy garść wyrażeń regularnych, które przekształcają jednoargumentowy na binarny.

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

Pierwsza z nich b(\d*):(_*)\2_b/b1$1:$2b/wyszukuje b, opcjonalnie następuje kilka cyfr binarnych, następnie a :, Następnie dowolna liczba podkreśleń, następnie dokładnie taka sama ilość podkreśleń plus jeden, a na końcu kolejnyb .

Następnie zamieniamy to na b1poprzedzone cyframi binarnymi z poprzedniej :, i tylko pierwszą połowę podkreślenia, a na koniec ostatniąb .

Sprawdza to, czy jednostka jednoargumentowa nie jest podzielna przez dwa, a jeśli tak, wstawia 1 do cyfr binarnych, a następnie dzieli ją minus jeden przez dwa.

Drugi b(\d*):(_+)\2b/b0$1:$2b/jest prawie identyczny, jednak nie sprawdza dodatkowych _, co oznacza, że ​​pasuje tylko wtedy, gdy można go podzielić przez dwa, aw tym przypadku wstawia0 zamiast niego.

Trzeci sprawdza, czy brakuje nam jednoznacznych cyfr, a jeśli tak, to usuwa dopełnienie, aby po prostu zostawić cyfry binarne.

Ostatni sprawdza, czy nigdy nie podano żadnych cyfr binarnych, i w takim przypadku po prostu wychodzi 0 .

Następna grupa Regexów, którą definiujemy, polega na konwersji plików binarnych z powrotem na jednoargumentowe i są nieco prostsze.

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

Pierwsza z tej grupy, B(_*):1/B$1$1_:/podobnie jak jej antyteza, wykrywa a B, a następnie dowolną liczbę Unary cyfr :1. Nie sprawdza dopasowaniaB tym przypadku , ponieważ szuka tylko jednej cyfry na raz. Jeśli jest to dopasowane, podwaja poprzednio dopasowaną liczbę jednoargumentowych cyfr i dodaje jedną, a następnie usuwa jedną.

Drugi B(_*):0/B$1$1:/,, jest prawie identyczny z pierwszym, z wyjątkiem dopasowań 0raczej niż a1 i nie dodaje dodatkowej jednoznacznej cyfry.

Ostatni z nich B(_*):B/$1/ sprawdza, czy nie ma już cyfr binarnych, a jeśli tak, to rozpakowuje unary. W przeciwieństwie do jego antytezy, nie wymaga specjalnego przypadku 0.

Następnie definiujemy jwyrażenia regularne, które działają jak funkcja dzielenia.

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

Pierwszy j(\d*),\1(\d)(\d{7})(\d*):/j$1$2,$1$2$3$4:,B:$1$4B/robi większość ciężkiego podnoszenia. Wyszukuje j, opcjonalnie po nich cyfry binarne, które są „inkrementatorem”, następnie przecinek, po którym następuje inkrementator, a następnie dokładnie 8 cyfr binarnych, po których następuje reszta liczby binarnej, a następnie a :. Pierwsza z 8 cyfr jest dołączana do inkrementatora, zwiększając go, a następnie wszystko oprócz tych 8 cyfr z wejścia binarnego jest dołączane po :następującym a ,. Tak więc (gdybyśmy używali 2 cyfr zamiast 8) j,1001:stałoby się j1:1001:,01wtedy j10:1001,01,11. Dodatkowo dołączone elementy tablicy są owinięte w Bs, aby przekonwertować je z powrotem na jednoargumentowe.

Drugi j(\d*),\1\d{0,7}:,?(.*)/,$2,/sprawdza, czy pozostało mniej niż 8 cyfr binarnych do sprawdzenia za inkrementatorem, a jeśli tak, usuwa wszystko inne niż tablicę owiniętą w ,s. Na przykład.,_,___,

Podczas i po utworzeniu tablicy definiujemy wyrażenia regularne porównania.

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

Pierwszy z nich ,((_+)_+),(\2),/,$1,/sprawdza przecinek, po którym następuje pewna liczba znaków podkreślenia, potem jeszcze kilka, następnie przecinek, a następnie pierwsza liczba znaków podkreślenia, niż przecinek. Następnie zastępuje go całkowitą liczbą znaków podkreślenia w pierwszym elemencie otoczonym przez ,s.

Ten ostatni ,(_+),(\1_*),/,$2,/sprawdza przecinek, po którym następuje pewna liczba znaków podkreślenia, po których następuje kolejny przecinek, następnie ta sama liczba lub więcej znaków podkreślenia i ostatni przecinek. To zamiast tego pozostawi właściwy element.

Na koniec, gdy pozostanie element pasujący w ten sposób ^,(_*),$, usuwamy otaczające go przecinki i przekształcamy z powrotem na dziesiętny przezd<> . Wtedy nie będzie już więcej wyrażeń regularnych, a wynik zostanie przedstawiony.

Dane wejściowe są początkowo umieszczane w szablonie j,b:u<(?#input)>b:, który najpierw przekształca dane dziesiętne na jednoargumentowe, np. 5-> j,b:_____b:, a następnie wynikowe jednostkowe na binarne, a j,101:następnie dzieli binarne (co nie działa w tym przykładzie), pobiera największy element, konwertuje powrót do miejsca po przecinku i gotowe.

ATaco
źródło
2

C (gcc), 91 bajtów

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 bajty od Colera Su

Obsługuje do 2**31-1

Wypróbuj online!

Zaczyna się od niskich 8 bitów (j=0), a następnie idzie w górę, zmieniając moc wyjściową, jeśli liczba z [j,j+8)odciętymi bitami jest większa niż nasz prąd, i kontynuowana, aż x nie będzie miało bitów powyżejj+8

pizzapanty184
źródło
2
Zapisz x>>j+8i x>>j+8<<j|x%(1<<j)w zmiennej (usunięte nawiasy) zmniejszy ją do 68 bajtów .
Colera Su
1

JavaScript (ES6), 94 91 bajtów

-3 bajty dzięki Justinowi Marinerowi

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

Po prostu wyrzucam rozwiązanie oparte na łańcuchach JavaScript, ale mam nadzieję, że ktoś opublikuje osobne rozwiązanie oparte na bitach, abym mógł się czegoś nauczyć.

Moje rozwiązanie rekurencyjnie pobiera 8-bitową porcję z łańcucha, przyjmując maksymalną znalezioną wartość.

Rick Hitchcock
źródło
1
Myślę, że możesz upuścić +(...)konwertujący '0b'+c[1]+c[2]na liczbę, ponieważ Math.maxjuż to robi. Wypróbuj online! ( specyfikacja do wykorzystania w przyszłości )
Justin Mariner,
@JustinMariner, słodki, dzięki!
Rick Hitchcock
1

C # (.NET Core) , 122 + 13 = 135 120 + 13 = 133 bajtów

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

Wypróbuj online!

+13 dla using System;

Wyobrażam sobie, że istnieje sposób na zrobienie tego bez użycia Convert. Tak czy inaczej, jestem pewien, że można to zmniejszyć.

Podziękowanie

-2 bajty dzięki 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;
}
Ayb4btu
źródło
Można zapisać bajt zmieniając whilesię fori kładzenie var bsię w nim:for(var b=Convert.ToString(n,2);i<b.Length-7;)
Kevin Cruijssen
Możesz zaoszczędzić jeszcze 1 bajt, dodając nową zmienną int ,ti nieużywając Math.Max, ale zamiast tego sprawdzając ręcznie: 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;}( 120 + 13 bajtów )
Kevin Cruijssen
1

PHP, 67 + 1 bajtów

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

Uruchom jako potok z -nRlub spróbuj online .

Tytus
źródło
1

Pyth, 19 bajtów

eSmi.>>.<.BQd8d2a6l

Alternatywna odpowiedź:

eSmi.<<8.>.BQdd2a6l

Wyjaśnienie:

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)

Druga odpowiedź wykorzystuje podobne podejście, z tym wyjątkiem, że najpierw obraca się w prawo i otrzymuje wszystkie bity oprócz ostatnich 8.

K Zhang
źródło
1

MATL , 23 21 bajtów

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

Wypróbuj 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.

Niestety Bn8-:8:!+q&)produkuje tylko plastry do usunięcia, a nie resztę, którą chcielibyśmy zachować.

Sanchises
źródło
Oszczędza to kilka bajtów: Bn8-:"GB[]@8:q+(XBvX>(przypisuj za []pomocą (zamiast &), i zastępuj &:przez :i dodawanie)
Luis Mendo
@LuisMendo Thanks. Źle odczytałem dokumenty, które mówiły gdzieś, że możesz użyć tylko jednego indeksu dla przypisań zerowych, ale dla innej sytuacji.
Sanchises
0

Oktawa , 81 80 bajtów

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

Wypróbuj online!

Jest to inne rozwiązanie niż moja pierwotna próba, oszczędzając kolejne 14 bajtów.

Kod jest podzielony w następujący sposób:

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

W szóstym wierszu liczba grup jest obliczana przez znalezienie wykładnika następnej potęgi dwóch większych niż wejściowa (liczba bitów w liczbie wejściowej) i odjęcie 7, ponieważ usuwamy 8 bitów z każdej grupy - otrzymana liczba jest przechowywane bna później.

Następnie obliczamy tablicę potęg dwóch w piątej linii, która jest wystarczająco duża dla wszystkich możliwych grup, które można usunąć. Zapisujemy to w zmiennej cna później.

W następnym wierszu w górę (czwarta linia) mnożymy dane wejściowe przez tablicę potęg dwóch (zasadniczo bitowo przesuwamy każdą liczbę w górę) i przekształcamy wynik na binarny. Jeśli weźmiemy przykład 7831, wynikiem jest tablica 2D zawierająca:

000001111010010111
000011110100101110
000111101001011100
001111010010111000
011110100101110000
111101001011100000

Jeśli następnie wycinamy środkowe 8 bitów, jest to równoważne usunięciu każdej z grup 8 bitów. Odbywa się to przez trzecią linię.

Powstała tablica jest konwertowana z powrotem na dziesiętne w drugim wierszu. Musimy również podzielić przez, caby cofnąć skalowanie, które zostało początkowo wykonane dla każdej grupy.

Wreszcie w pierwszym wierszu deklarowana jest funkcja anonimowa i obliczana jest maksymalna wartość ze wszystkich grup.


  • Zaoszczędź 1 bajt, używając nextpow2(x+1)zamiastnnz(bin2dec(x))


Oryginalna próba - 120 98 95 bajtów

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

Wypróbuj online!

Kod dzieli się w następujący sposób:

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

Zasadniczo oblicza macierz zawierającą możliwe grupy wartości, które można usunąć, a następnie oblicza, co daje największą liczbę.

Działająca linia po linii, piąta linia oblicza grupy, które można usunąć. Na przykład weź 7831. Jest to liczba 13-bitowa, która daje grupom:

1111100000000
1111000000001
1110000000011
1100000000111
1000000001111
0000000011111

Wynikiem piątej linii jest dwuwymiarowa tablica logiczna, której można użyć do indeksowania.

Czwarty wiersz kodu konwertuje dane wejściowe na tablicę bitów (przedstawionych jako znaki „0” i „1”), a następnie powtarza je n-7 razy (gdzien w liczbie bitów), dając jedną linię dla każdego możliwego grupowania. Powyższa maska ​​grupy służy do usuwania każdej z możliwych grup.

W trzecim wierszu wynik jest następnie przekształcany w celu cofnięcia niechcianego spłaszczenia wynikającego z zastosowania maski grupy. Drugi wiersz konwertuje z powrotem na tablicę wynikowych liczb dziesiętnych. Pierwszy wiersz definiuje funkcję anonimową jako maksymalną wartość tablicy możliwych grup.


  • Zaoszczędzono 22 bajty, generując macierz grup za pomocą matematyki.
  • Zapisano 3 bajty w konwersji z ciągów binarnych na logiczną maskę grupy.
Tom Carpenter
źródło
0

Perl, 53 bajty

( use 5.10.1przeniesienie perla na poziom językowy 5.10.1 jest bezpłatny)

Podaj numer wejściowy na STDIN. W przypadku dużych liczb zabraknie pamięci, ale liczba 32-bitowa na wejściu nie jest jeszcze problemem

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