16-bitowa siatka binarna

29

Biorąc pod uwagę dowolną 16-bitową liczbę całkowitą bez znaku, zamień jego liczbę dziesiętną (tj. Base-10) na siatkę 4x4 ASCII jego bitów, z najbardziej znaczącym bitem (MSB) w lewym górnym rogu, najmniej znaczącym bitem (LSB) na w prawym dolnym rogu, czytaj dalej, a następnie w dół (jak tekst w języku angielskim).

Przykłady

Wejście: 4242

+---+---+---+---+
|   |   |   | # |
+---+---+---+---+
|   |   |   |   |
+---+---+---+---+
| # |   |   | # |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+

Dane wejściowe: 33825

+---+---+---+---+
| # |   |   |   |
+---+---+---+---+
|   | # |   |   |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+
|   |   |   | # |
+---+---+---+---+

Specyficzne wymagania

  1. Dane wejściowe muszą być dziesiętne (podstawa-10), jednak można je przekonwertować na pliki binarne w dowolny sposób (w tym za pomocą wbudowanych języków, jeśli są dostępne).

  2. Format tabeli wyjściowej musi być dokładnie zgodny . Oznacza to, że musisz użyć określonych znaków ASCII ( -, +i |) dla linii siatki tabeli, jak pokazano, wnętrze każdej komórki ma 3 znaki, a prawdziwe bity są reprezentowane przez, #a fałsz jest reprezentowany przez spację ( ).

  3. Wiodące lub końcowe białe znaki są niedozwolone. Wymagana jest ostateczna nowa linia .

  4. Kolejność bitów musi być zgodna z opisanymi przykładami.

Dodatki

  1. Dane wejściowe muszą być liczbą dziesiętną w wierszu poleceń, standardowej lub użytkownika, ale nie mogą być zapisane na stałe w kodzie źródłowym.

Niech wygra najczystszy najkrótszy kod! :-)

type_outcast
źródło
1
Powiązane
Sp3000,
2
Pierwsze zdanie wydaje mi się mylące, gdy mówi „przekonwertować jego liczbę dziesiętną ”. Na podstawie reszty postu i przykładu wygląda na to, że dane wejściowe są podawane w postaci dziesiętnej, ale trzeba przekonwertować binarną postać wartości na siatkę.
Reto Koradi,
1
@RetoKoradi masz zasadniczo rację, ale pytanie wymaga przekształcenia liczby dziesiętnej w siatkę binarną . Nie ma wyraźnego wymagania, aby kiedykolwiek pracować z liczbą binarną, tylko prawdopodobny szczegół implementacji.
type_outcast
Czy pisanie funkcji z liczbą 10 jako argumentem funkcji liczy się jako dane wprowadzane przez użytkownika?
Alex A.
2
Ponieważ mówisz, że podana liczba jest „16- bitową liczbą całkowitą bez znaku ”, z definicji ma postać binarną. Kiedy po raz pierwszy to przeczytałem, faktycznie brzmiało to tak, jakby dane wejściowe były podawane w formie binarnej. Wszystko staje się jasne pod koniec. Ale przynajmniej dla mnie pierwszy akapit w ogóle nie uchwycił problemu.
Reto Koradi,

Odpowiedzi:

21

J, 26 bajtów

('   ';' # '){~4 4$_16{.#:

Czasownik anonimowy. Na szczęście J jest bardzo dobry w rysowaniu ramek. Wypróbujmy to:

   f =. ('   ';' # '){~4 4$_16{.#:
   f 4242
+---+---+---+---+
|   |   |   | # |
+---+---+---+---+
|   |   |   |   |
+---+---+---+---+
| # |   |   | # |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+

Jak wspomnieli niektórzy komentatorzy, sposób, w jaki J rysuje ramki, zależy od systemu: na niektórych platformach kod ten będzie działał w ustawieniach domyślnych, ale na innych, pola będą rysowane przy użyciu znaków do rysowania linii Unicode. (Polecenia 9!:6i9!:7 pozwalają na zapytania i ustawić znaki wyciągnąć pudełkowane wartości z, odpowiednio).

Lynn
źródło
Czy ty (lub ktokolwiek inny) wiecie, czy istnieje konsensus w sprawie komendy rysowania pudełka dla punktacji golfa? Osobiście uważam, że w przypadku kodu golfowego założeniem jest, że rozwiązania działają na większości systemów, na których działa język rozwiązania, prawda? Jak wyglądałoby rozwiązanie, które wyświetla prawidłowe pola dla wszystkich (lub prawie wszystkich) instalacji J? Nawiasem mówiąc , naprawdę podoba mi się twoje rozwiązanie! Mój mózg wciąż pracuje nad tym, co lubię w golfie kodowym.
type_outcast
5
@type_outcast Nie wymagamy przenośności w przypadku wyzwań związanych z golfem. Tak długo, jak działa z pewną implementacją na jednej platformie, jest ważny.
Dennis
Dzięki za odpowiedź @Dennis. Cieszę się, że moje domniemanie było błędne, ponieważ (nadal) bardzo podoba mi się rozwiązanie Maurisa! :-)
type_outcast
14

JavaScript (ES6), 102

... lub 96 używając returnzamiast console.log.

Przetestuj poniższy fragment kodu w przeglądarce zgodnej z EcmaScript 6.

f=n=>{for(o=h=`
+---+---+---+---+
`,z=16;z--;n/=2)o=(z&3?'':h+'|')+` ${' #'[n&1]} |`+o;console.log(o)}

// TEST
console.log=x=>O.innerHTML=x+O.innerHTML

function test(n) { f(n); console.log(n); }
<input id=I value=4680><button onclick='test(+I.value)'>-></button>
<pre id=O></pre>

edc65
źródło
6
Czy „JavaScripy” to jakieś dziwne połączenie javascript / python? ;-)
Cyfrowa trauma
6
@DigitalTrauma oczywiście. Ale ponieważ świat nie jest gotowy ( tvtropes.org/pmwiki/pmwiki.php/Main/TheWorldIsNotReady ) na tę nową ewolucję,
powrócę
Fajnie, to działa na Edge!
Arturo Torres Sánchez
Musi ... nie ... kliknąć ... tvtropes ...
RK.
14

Befunge -93, 196 218 bajtów

&00p12*v>>4>"---+",v v <
v*:*:*:<   | :-1,,,< #
>:*2/10p^  >"+",25*,10g|
     > #v^#         $< @
 25*,^  >4" |",,v ,*<>
v>"#",00g10g-00p 10g
 |`-1g01g00     <>48^
v>" ",10g
>2/10p>"| ",,1-:#^_$>^

Aby uruchomić program ...

  1. Idź do tłumacza online .
  2. Wklej ten kod w dużym polu tekstowym.
  3. Kliknij Show.
  4. Wprowadź żądaną liczbę w Inputpolu.
  5. Kliknij Run. (Lub zmień Slowna coś w rodzaju 5 milisekund, a następnie kliknij Show.)
  6. Ta-da!

Wyjście dla 4242:

+---+---+---+---+
|   |   |   | # |
+---+---+---+---+
|   |   |   |   |
+---+---+---+---+
| # |   |   | # |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+

Wyjście dla 33825:

+---+---+---+---+
| # |   |   |   |
+---+---+---+---+
|   | # |   |   |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+
|   |   |   | # |
+---+---+---+---+

Wyjaśnienie

O Boże, w co się wpakowałem? Cóż, proszę bardzo! (Nieistotny kod zostaje zastąpiony przez .s.)

Część 1: Uzyskaj dane wejściowe (zapisz w 0,0) i oblicz 32768 (zapisz w 1,0).

&00p12*v>
v*:*:*:< 
>:*2/10p^

Część 2: Wydrukuj „+ --- + --- + --- + ---”.

>4>"---+",v
  | :-1,,,<

Część 3: Wydrukuj „+” i nowy wiersz i sprawdź, czy (1,0) ma wartość 0 (tzn. Gotowe). Jeśli tak, zakończ. W przeciwnym razie kontynuuj.

 ........... v <
   | ....... # 
   >"+",25*,10g|
v.#         $< @
>4" |",,v ...

Część 4: Otrzymuj binarne cyfry danych wejściowych, aktualizując (0,0) i (1,0) w miarę postępów. Wydrukuj właściwe rzeczy. Korzystam z zachowań Befunge.

 .....  >4" |",,v ,*<.
v>"#",00g10g-00p 10g
 |`-1g01g00     <>48^
v>" ",10g
>2/10p>"| ",,1-:#^_...

Część 5: Wydrukuj nowy wiersz i wróć do części, która drukuje „+ --- + --- + --- + --- +”. Używana jest sztuczka polegająca na obejściu.

     > #.^.         .. .
 25*,^  ......... ...>
................ ...
 .........      .....
........
.................._$>^

Ta-da!

El'endia Starman
źródło
10

Julia, 156 143 bajtów

n->(p=println;l="+"*"---+"^4;for i=1:4 p(l,"\n| ",join([j>"0"?"#":" "for j=reshape(split(lpad(bin(n),16,0),""),4,4)[:,i]]," | ")," |")end;p(l))

Nie golfowany:

function f(n::Int)
    # Convert the input to binary, padded to 16 digits
    b = lpad(bin(n), 16, 0)

    # Split b into a 4x4 matrix
    m = reshape(split(b, ""), 4, 4)

    # Store the line separator for brevity
    l = "+" * "---+"^4

    # Print each column of the matrix as a row
    for i = 1:4
        println(l, "\n| ", join([j > "0" ? "#" : " " for j = m[:,i]], " | "), " |")
    end

    # Print the bottom of the table
    println(l)
end

Wypróbuj online

Alex A.
źródło
10

Python 2, 157 153 151 146 bajtów

J=''.join;R='+---'*4;i=format(input(),'016b')
print J(R+'+\n|'+J(' '+('#'if int(l)else' ')+' |'for l in i[n*4:-~n*4])+'\n'for n in range(4)),R+'+'

Dzięki Morgan Thrapp za uratowanie 4 bajtów i Jonathan Frech za uratowanie 5.

Stosowanie

$ python test.py
33825
+---+---+---+---+
| # |   |   |   |
+---+---+---+---+
|   | # |   |   |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+
|   |   |   | # |
+---+---+---+---+
Zach Gates
źródło
Możesz zapisać dwa bajty, jeśli wciągniesz '+---'*4zmienną, i dwa kolejne, jeśli tak zrobiszj=''.join
Morgan Thrapp
Nie ma problemu! Właściwie pracowałem nad bardzo podobnym rozwiązaniem.
Morgan Thrapp,
@downvoter Chcesz wyjaśnić?
Zach Gates,
Ponieważ nie używać Python 3, można wymienić int(input())ze input()i zapisać pięć bajtów.
Jonathan Frech,
9

Rubin, 118 114

b="%016b"%gets
l=?++"---+"*4
1.upto(16){|i|puts l if i%4==1
print"| #{b[i-1]==?0?' ':?#} "
puts ?|if i%4<1}
puts l

dzięki za @ w0lf za uratowanie niektórych znaków.

Mhm
źródło
1
Możesz zapisać niektóre bajty, jeśli piszesz literalne znaki za pomocą ?notacji (np .: ?|zamiast '|'). Działa to na wszystko oprócz przestrzeni.
Cristian Lupascu,
@ w0lf Stwierdziłem, że ?\sdziała dla przestrzeni, ale w rzeczywistości nie jest to tutaj pomocne.
Mhmd,
7

GNU sed + dc, 116

Wynik obejmuje +1 za -rflagi, aby sed:

s/.*/dc -e2o&p/e
:
s/^.{,15}$/0&/;t
s/./| & /g
s/.{16}/\n+---+---+---+---+\n&|/g
y/01/ #/
s/\n([-+]+)(.*)/\1\2\n\1/

Wyjście testowe:

$ { echo 4242 ; echo 33825 ; } | sed -rf 16bitgrid.sed
+---+---+---+---+
|   |   |   | # |
+---+---+---+---+
|   |   |   |   |
+---+---+---+---+
| # |   |   | # |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+
+---+---+---+---+
| # |   |   |   |
+---+---+---+---+
|   | # |   |   |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+
|   |   |   | # |
+---+---+---+---+
$ 

Alternatywnie:

Pure sed, 146

Możesz pomyśleć, że oszustwo polega na użyciu sedrozszerzenia GNU do ewaluacji dcpolecenia. W takim przypadku możemy to zrobić nieco inaczej, zgodnie z tą meta-odpowiedzią . Oczywiście pytanie wyraźnie stwierdza, że ​​dane wejściowe muszą znajdować się w bazie 10, ale tutaj próbuję twierdzić, że możemy przesłonić to w przypadku sedodpowiedzi i użyć zamiast niej jedności (baza 1).

:
s/11/</g
s/<([ #]*)$/< \1/
s/1/#/
y/</1/
t
:a
s/^.{,15}$/0&/;ta
s/./| & /g
s/.{16}/\n+---+---+---+---+\n&|/g
y/01/ #/
s/\n([-+]+)(.*)/\1\2\n\1/

Wyjście testowe

Użycie printfdo wygenerowania niezbędnego ciągu jednoargumentowego:

$ printf "%33825s" | tr ' ' 1 | sed -rf 16bitgrid.sed 
+---+---+---+---+
| # |   |   |   |
+---+---+---+---+
|   | # |   |   |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+
|   |   |   | # |
+---+---+---+---+
$ 
Cyfrowa trauma
źródło
Niezłe. Wygląda to nieco podobnie do rozwiązania Perla, które wymyśliłem jako (prywatny) dowód koncepcji podczas dopracowywania pytania.
type_outcast
@type_outcast BTW jest całkowicie OK, aby opublikować własne rozwiązanie jako odpowiedź :)
Digital Trauma
Wiem :-) Nie spędziłem dużo czasu na grze w golfa, ponieważ bardziej skupiłem się na postawieniu dobrego pytania, ale mogę jeszcze raz to sprawdzić i opublikować, jeśli mogę zagrać w golfa w coś co najmniej w połowie godnego szacunku. W tej chwili zbyt dobrze się bawię, szukając odpowiedzi innych.
type_outcast
6

C ++ 11, 193 191 190 176 172 bajtów

Moje pierwsze rozwiązanie na codegolf w historii, więc nie obwiniaj mnie.

#include<iostream>
int n,j,i=65536;int main(){std::cin>>n;for(;j<9;){for(int k:{0,0,0,0})if(j%2)printf("| %s",n&(i/=2)?"# ":"  ");else printf("+---");puts(j++%2?"|":"+");}}

Nie golfił

#include <iostream>
int n, i = 65536, j;

int main()
{
    std::cin >> n;

    for (; j < 9;)
    {
        for(int k:{0,0,0,0})
        {
            if (j % 2)
            {
                printf("| %s", n & (i /= 2) ? "# " : "  ");
            }
            else
            {
                printf("+---");
            }
        }
        puts(j++ % 2 ? "|" : "+");
    }
}

Poprzednia wersja

#include <iostream>
using namespace std;

int n, i = 65536, j;
int main()
{
    cin >> n;

    for (; j < 9;)
    {
        for(int k:{0,0,0,0})
        {
            if (j % 2)
            {
                cout << "| " << (n & (i /= 2) ? "# " : "  ");
            }
            else
            {
                cout << "+---";
            }
        }
        cout << (j++ % 2 ? "|\n" : "+\n");
    }
}
Zereges
źródło
Wskazówka: 0x10000 to 65536, z prefiksem „0x”, wartość szesnastkowa jest zawsze dłuższa niż dziesiętna
edc65
Wskazówka 2: należy unikać using namespace stdw kodzie produkcyjnym. I tutaj też nie jest to przydatne.
edc65
@ edc65 dec-> hex dobry pomysł, zawsze myślałem, że hex ma krótszą reprezentację, ale zapominam 0x. using namespace stdoszczędza kilka bajtów, ponieważ nie muszę przedrostka coutani cinz std::. Nawet używanie po prostu using std::cout;nie pomoże.
Zereges
Hej Zereges. Możesz usunąć spację między włączeniem a biblioteką .. i usunąć typ zwracany dla funkcji głównej.
wendelbsilva
C++nie obsługuje auto int.
Zereges
6

Pyth, 37 bajtów

Jj*3\-*5\+JVc4_m@" #".>Qd16jd.i*5\|NJ

Wypróbuj online: pakiet demonstracyjny lub testowy

Wyjaśnienie:

Jj*3\-*5\+J
  *3\-                       the string "---"
      *5\+                   the string "+++++"
 j                           join second by first string: 
                                "+---+---+---+---+"
J                            save in J
          J                  print J

Vc4_m@" #".>Qd16jd.i*5\|NJ
    m         16             map each d in [0, 1, ..., 15] to:
          .>Qd                 input number Q shifted to the right by d
     @" #"                     and take the ^th char in " #" (modulo 2)
   _                         reverse this list of chars
 c4                          split into 4 groups
V                            for each group N in ^:
                    *5\|       the string "|||||"
                  .i    N      interleave ^ with N
                jd             join chars with spaces and print
                         J     print J
Jakube
źródło
5

CJam, 43 41 bajtów

'+5*'-3**N+ri2bG0e[4/{" #"f='|5*.\S*N2$}/

Zdecydowanie do gry w golfa, ale myślę, że to początek. Generuje górny wiersz, a następnie dla każdego 4 bitów tworzy wiersz parzysty i kopiuje poprzedni wiersz nieparzysty.

Wypróbuj online .

Sp3000
źródło
4

Python 2, 122 121 120 bajtów

n=bin(4**8+input())[3:]
i=0
exec"print'| %s |'%' | '.join(' #'[x>'0']for x in n[:4])*i or'+---'*4+'+';n=n[4*i:];i^=1;"*9

-1 bajt dzięki zgrabnej 4**8+sztuczce @ xnor . Główne drukowanie odbywa się przez zapętlenie 9 razy, wybranie odpowiedniego wiersza dla nieparzystych / parzystych.

Sp3000
źródło
Myślę, że to bin(4**8+input())[3:]oszczędza bajtformat
xnor
@xnor Och, to fajnie :)
Sp3000,
4

Python 2, 94

n=input()
s=();exec"s=(' #'[n%2],)+s;n/=2;"*16
a='+---'*4+'+\n'
print(a+'| %s '*4+'|\n')*4%s+a

Chodzi o wzięcie wzoru

+---+---+---+---+
| _ | _ | _ | _ |
+---+---+---+---+
| _ | _ | _ | _ |
+---+---+---+---+
| _ | _ | _ | _ |
+---+---+---+---+
| _ | _ | _ | _ |
+---+---+---+---+

oprócz z %s zamiast pustych miejsc i wykonywania krotek. Krotka wygląda

('#', ' ', ' ', ' ', ' ', '#', ' ', ' ', ' ', ' ', '#', ' ', ' ', ' ', ' ', '#')

Jest on tworzony przez zdejmowanie cyfr z wejścia w postaci binarnej i dodawanie odpowiedniego symbolu z przodu krotki. Wyrażenie z jawną krotką dało jednakową długość.

%tuple(' #'[c>'0']for c in bin(input()+4**8)[3:])

Dzięki Sp3000 za 2 bajty.

xnor
źródło
4

PowerShell, 203 188 182 bajtów

param($a)$l="+---+---+---+---+";$l;$b=([int64][convert]::ToString($a,2)).ToString(@(,"0"*16)-join'');@(1..16|%{if($b[$_-1]-eq'1'){"| # "}else{"|   "};if($_%4-eq0){"|`n$l`n"}})-join''

Edytuj - zapisano 15 bajtów, zmieniając kolejność |rysowania, dzięki czemu możemy zrzucić .TrimEnd("|")dane wyjściowe i zamiast tego przekształcić pętlę for w blok subkodu, który tworzy tablicę

Edit2 - zapisano kolejne 6 bajtów, eliminując potrzebę zapisywania w $ozmiennej i wysyłania -join''bezpośrednio z .

Ooooooooof.

Rysowanie w PowerShell jest trudne . Praca z cyframi binarnymi w PowerShell jest trudna .

Używa wbudowanych [convert]liczb wejściowych do reprezentacji ciągu w formacie binarnym, a następnie ponownie rzutuje na [int64], abyśmy mogli ponownie wywołać .ToString()w celu dodania / uzupełnienia odpowiedniej liczby zer. (Zauważ, że utworzenie tablicy ciągów i połączenie ich @(,"0"*16)-join''jest o 1 znak krótsze niż ciąg literalny"0000000000000000" )

Następnie wykonaj proste 1..16|%{...}sprawdzanie pętli dla każdej cyfry, aby zbudować naszą tablicę wyjściową, a następnie w końcu z -join''powrotem razem.


Poprzedni, 188

param($a)$l="+---+---+---+---+";$l;$b=([int64][convert]::ToString($a,2)).ToString(@(,"0"*16)-join'');$o=@(1..16|%{if($b[$_-1]-eq'1'){"| # "}else{"|   "};if($_%4-eq0){"|`n$l`n"}});$o-join''

Poprzednio, 203

param($a)$l="+---+---+---+---+`n|";$o=$l;$b=([int64][convert]::ToString($a,2)).ToString(@(,"0"*16)-join'');1..16|%{if($b[$_-1]-eq'1'){$o+=" # |"}else{$o+="   |"};if($_%4-eq0){$o+="`n$l"}};$o.TrimEnd('|')
AdmBorkBork
źródło
1
Mam nadzieję, że to było „zabawne trudne”. :-) +1 za wyjaśnienie; pomogło mi to w ograniczonym stopniu zrozumieć PowerShell.
type_outcast
3

JavaScript (ES6), 216 207 bajtów

Definiuje anonimową funkcję.

i=>(","+("0".repeat(16)+i.toString(2)).slice(-16).split``.map((v,l,a)=>l%4<1?"| "+a.slice(l,l+4).map(v=>v?"#":" ").join` | `+" |":"").filter(v=>!!v).join`,`+",").replace(/,/g, `
+---+---+---+---+
`).slice(1)

Dzięki ETHproductions za wskazówki!

adroitwhiz
źródło
Dobra robota! Ponieważ używasz ES6, oto kilka wskazówek: 1. Za każdym razem, gdy potrzebujesz użyć ciągu jako jedynego parametru funkcji, możesz użyć ciągu szablonu, takiego jak: .join` | `​2. Możesz także użyć ciągu szablonu do interpolacji wartości: i=>`,${"0".repeat....join`,`},`.replace...3 Możesz znaleźć więcej porad ES6 w tym wątku .
ETHprodukcje
Wydaje się, że przestało to działać, ale grając w golfa trochę więcej, mogę uzyskać 197 z prawidłowym wynikiem: i=>`,${("0".repeat(16)+i.toString(2)).slice(-16).split``.map((v,l,a)=>l%4?"":"| "+a.slice(l,l+4).map(v=>' #'[v]).join` | `+" |").filter(v=>v).join`,`},`.replace(/,/g,`<line break>+---+---+---+---+<line break>`).slice(1)
ETHprodukcje
2
("0".repeat(16)+i.toString(2)).slice(-16) ->(65536|i).toString(2).slice(1)
edc65
Zachowując dokładną logikę, można ustawić w golfa na 169, patrz jsfiddle.net/76fp7aw6
edc65
2

Pyth, 50 bajtów

j.i*5]<3*5"+---"ms.i*5\|dc4mj@" #"qd\1*2\ .[Z16.BQ

Wyjaśnienie będzie musiało poczekać do następnego razu, publikuję to na swoim telefonie!

Sok
źródło
2

Ruby, 102

n=gets.to_i
print j="+---"*4+"+
" 
19.downto(0){|i|print i%5>0?"| #{((n>>i*4/5)%2*3+32).chr} ":"|
"+j}

Algorytm

Wydrukuj poziomy rozdzielacz

Pętla 20 razy (19..0)

Jeśli liczba pętli nie dzieli się przez 5, zamień na liczbę z zakresu 16..0, mnożąc przez 4/5. Wydrukuj spację (ascii 32) lub #(ascii 32 + 3 = 35) poprzedzone przez| spacją i po niej.

Jeśli liczba pętli dzieli się przez 5, wypisz końcówkę |, nową linię i dzielnik poziomy identyczne z pierwszym.

Level River St
źródło
2

Perl, 103 bajty

$_=(($l='+---'x4 .'+
').'| x 'x4 .'|
')x4 .$l;@n=(sprintf'%016b',<>)=~/./g;s/x/$n[$x++]?'#':$"/eg;print

Dużo ciąg powtórzeń zrobić siatkę xs, konwersja do wejścia binarne, a następnie s///z xs do #lub $"( ) w zależności od flagi na określonej pozycji ( $x).

Dom Hastings
źródło
2

PHP, 159 bajtów

bingrid16.php:

<?$r=10;while(--$r){if($r%2){echo str_repeat('+---',4).'+';}else{$c=9;echo'|';while(--$c){echo' '.($c%2?'|':($argv[1]&pow(2,$r*2+$c/2-5)?'#':' '));}}echo"\n";}

Stosowanie:

php bingrid16.php 4242

Nic szczególnego, po prostu brutalne wymuszenie renderowania.

Próbowałem pod innym kątem, używając tablic zamiast pętli, ale było dłuższe przy 224 bajtach:

<?=implode(array_map(function($r)use($argv){return($r%2?str_repeat('+---',4).'+':'|'.implode(array_map(function($c)use($r,$argv){return' '.($c%2?'|':($argv[1]&pow(2,$r*2+$c/2-5)?'#':' '));},range(8,1))))."\n";},range(9,1)));
zamnuts
źródło
2

Perl 5 , 85 84 bajtów

84 83 bajty kodu + -pflaga

-1 bajt po Dom przypomniał mi o użyciu nowej linii

say$\='+'."---+"x4,"
| ",map y/01/ #/r.' | ',/./g for(sprintf"%016b",$_)=~/..../g}{

Wypróbuj online!

Xcali
źródło
Ładne, znacznie lepsze podejście niż moje! Dosłownie nowa linia pozwoli Ci zaoszczędzić dodatkowy bajt $/!
Dom Hastings,
1

c99 263 bajtów

grał w golfa:

main(int argc,char **argv){short i=atoi(argv[argc-1]);char *t="| # ", *f="|   ",*a[16],**p=a,*b="+---+---+---+---+\r\n";while(p<a+16){if((i|0x8000)==i)(*(p++))=t;else(*(p++))=f;i<<=1;}for(p=a;p<a+16;p+=4)printf("%s%s%s%s%s|\n",b,*p,p[1],p[2],p[3]);printf("%s",b);}

bez golfa:

main(int argc, char **argv)
{
    short i=atoi(argv[argc -1]);
    char *t ="| # ", *f="|   ",*a[16],**p=a,*b="+---+---+---+---+\r\n";

    while (p<a+16)
    {
        if((i|32768)==i)
            (*(p++))=t;
        else
            (*(p++))=f;

        i<<=1;
    }

    for (p=a;p<a+16;p+=4)
        printf("%s%s%s%s%s|\n",b,*p,p[1],p[2],p[3]);
    printf("%s",b);
}

Po prostu lubiłem prezentować nieco zmieniający się wariant i czułem, że po raz pierwszy jest odpowiedni (nawet kosztuje mnie kilka bajtów, ale C nie może tego wyzwania w bajtach nawet z szansą, więc nie obchodzi mnie), aby użyć argc / argv

Zaibis
źródło
1

Ruby, 95

Nod na Mhmd, aby uzyskać zwięzłą konwersję ciągów, ale chciałem spróbować użyć metod ciągów zamiast metod numerycznych.

->i{puts g='+---'*4+?+;("%016b"%i).scan(/.{4}/){puts$&.gsub(/./){"| #{$&<?1?' ':?#} "}+"|
"+g}}
Nie ten Charles
źródło
1

Ruby, 93

Nieco krótsza wersja wykorzystująca tylko operacje numeryczne.

->i{n=g='+---'*4+"+
";15.downto(0){|m|n+="| #{[' ',?#][1&i>>m]} "
n+="|
"+g if m%4<1}
puts n}
Nie ten Charles
źródło
1

C # 227 bajtów

Gra w golfa:

class B{public static string G(short v){string s="",b=System.Convert.ToString(v,2).PadLeft(16,'0');for(int i=9;i>0;){s+=i--%2!=0?"+---+---+---+---+\n":"| "+b[i*2+1]+" | "+b[i*2]+" | "+b[i*2-1]+" | "+b[i*2-2]+" |\n";}return s;}}

Akapit:

class B
{
    public static string G(short v)
    {
        string s="",b=System.Convert.ToString(v, 2).PadLeft(16,'0');
        for(int i=9;i>0;)
            s+=i--%2!=0?"+---+---+---+---+\n":"| "+b[i*2+1]+" | "+b[i*2]+" | "+b[i*2-1]+" | "+b[i*2-2]+" |\n";
        return s;
    }
}

Po raz pierwszy próbuję czegoś takiego, wskazówki będą mile widziane!

anthonytimmers
źródło
Po pierwsze, liczę 286 bajtów i można usunąć spacje wcięcia.
Blue
Jak dokładnie to liczysz? Chodziłem do właściwości, aby zobaczyć tam rozmiar pliku, ale nie jestem pewien, czy tak to zrobić! Bez wcięć zszedłem do 230 bajtów!
anthonytimmers,
Użyj czegoś takiego jak mothereff.in/byte-counter lub jeśli korzystasz z systemu Linux, użyj wcpolecenia
Blue
1

Python 3, 145 144 bajtów

Inline:

a="|";b="+"+"---+"*4+"\n";r=0,1,2,3;(lambda x:print(b+b.join(a+a.join(" %s "%'# '[x&2**(i+j*4)<1]for i in r)+a+"\n"for j in r)+b))(int(input()))

Z nowymi liniami:

a="|"
b="+"+"---+"*4+"\n"
r=0,1,2,3
lambda x:print(b+b.join(a+a.join(" %s "%'# '[x&2**(i+j*4)<1]for i in r)+a+"\n"for j in r)+b)
x(int(input()))

Edycja: Zbiorniki @manatwork za zapisanie 1 bajtu

Bassintag
źródło
1
Na podstawie gnibbler „s końcówki , hardcoding r=0,1,2,3jest 1 znak krótszy niż generowanie go r=range(4).
manatwork
0

Kotlin , 192 bajty

{val v=it.toString(2).padStart(16,'0')
fun p(){(0..3).map{print("+---")}
println("+")}
(0..3).map{p()
v.subSequence(it*4,(it+1)*4).map{print("| ${if(it>'0')'#' else ' '} ")}
println("|")}
p()}

Upiększony

{
    val v = it.toString(2).padStart(16, '0')
    fun p() {
        (0..3).map { print("+---") }
        println("+")
    }
    (0..3).map {
        p()
        v.subSequence(it *4, (it +1) *4).map {print("| ${if (it > '0') '#' else ' '} ")}
        println("|")
    }
    p()
}

Test

var b:(Int) -> Unit =
{val v=it.toString(2).padStart(16,'0')
fun p(){(0..3).map{print("+---")}
println("+")}
(0..3).map{p()
v.subSequence(it*4,(it+1)*4).map{print("| ${if(it>'0')'#' else ' '} ")}
println("|")}
p()}

fun main(args: Array<String>) {
    b(255)
}
jrtapsell
źródło