Herhangi bir imzasız 16 bit tam sayı verildiğinde, ondalık biçimini (örneğin, baz-10), sol üstündeki en önemli bit (MSB) en az anlamlı bit (LSB) olan bitlerin 4x4 ASCII ızgarasına dönüştürün. sağ alt, okuma ve sonra aşağı (ingilizce metin gibi).

Örnekler

Giriş: 4242

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

Giriş: 33825

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

Belirli gereksinimler

1. Giriş ondalık basamakta olmalıdır (temel-10), ancak istediğiniz şekilde ikiliye dönüştürebilirsiniz (varsa, dil yerleşiklerini kullanma dahil).

2. Çıktı tablosu formatı tam olarak eşleşmelidir . Bu , gösterildiği gibi tablo ızgara çizgileri için belirli ASCII karakterlerini ( -, +ve |) kullanmanız gerekir , her hücrenin içi 3 karakterdir ve false bir boşlukla ( ) temsil edilirken gerçek bitlerle gösterilir .#

3. Lider veya takip eden boşluklara izin verilmez. Son satırsonu gereklidir .

4. Bit sırası, tarif edilen örneklerle eşleşmelidir.

Ödenekler

1. Giriş, komut satırında, standart girişde veya kullanıcı girişinde 10 tabanlı olmalı , ancak kaynak kodunuzda kodlanmış olmamalıdır .

En net kısa kod kazansın! :-)

J, 26 bayt

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

İsimsiz bir fiil. Neyse ki, J çizim kutuları için çok iyidir. Hadi deneyelim:

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

Bazı yorumcuların belirttiği gibi, J'nin kutu çekme şekli sisteme bağlıdır: bazı platformlarda bu kod varsayılan ayarların altında çalışacaktır, ancak bazılarında kutular Unicode çizgi çizme karakterleri kullanılarak çizilecektir. (Komutlar 9!:6ve9!:7 sırasıyla kutulanmış değerler çizmek için karakterleri sorgulamanıza ve ayarlamanıza izin verir.)

JavaScript (ES6), 102

... veya 96 kullanarak returnyerine console.log.

Aşağıdaki pasajı EcmaScript 6 uyumlu bir tarayıcıda çalıştırmayı test edin.

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>

Befunge -93, 196 218 bayt

&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-:#^_$>^

Programı çalıştırmak için ...

1. Git Online tercüman .
2. Bu kodu büyük metin kutusuna yapıştırın.
3. Tıklayın Show.
4. InputKutuya istediğiniz numarayı giriniz.
5. Tıklayın Run. (Veya Slow5 milisaniye gibi bir şeye geçin ve ardından tıklayın Show.)
6. Sürpriz!

4242 için çıktı:

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

33825 için çıktı:

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

açıklama

Aman Tanrım, kendime ne yaptım? Peki, işte gidiyor! (Alakasız kod .s ile değiştirilir .)

Bölüm 1: Girdiyi alın (0,0 olarak kaydedin) ve 32768'i (1,0 olarak girin) hesaplayın.

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

Bölüm 2: "+ --- + --- + --- + ---" çıktısını alın.

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

Bölüm 3: "+" ve bir yeni satır yazdırın ve (1,0) 'ın 0 olup olmadığını kontrol edin (yani bitti). Öyleyse, sonlandır. Aksi takdirde, devam edin.

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

Bölüm 4: İkili giriş hanesini alın, devam ettikçe (0,0) ve (1,0) 'ı güncelleyin. Doğru şeyleri yazdırın. Befunge'nin sarma davranışından yararlanıyorum.

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

5. Bölüm: Yeni bir satır yazdırın ve "+ --- + --- + --- + --- +" yazan bölüme dönün. Wrap-around hilesi kullanılır.

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

Sürpriz!

Julia, 156 143 bayt

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))

Ungolfed:

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

Çevrimiçi deneyin

Python 2, 157 153 151 146 bayt

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+'+'

Morgan Thrapp'a 4 byte kaydettiği için ve Jonathan Frech'e 5 kaydettiği için teşekkürler.

kullanım

$ python test.py
33825
+---+---+---+---+
| # |   |   |   |
+---+---+---+---+
|   | # |   |   |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+
|   |   |   | # |
+---+---+---+---+

Ruby, 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

Bazı karakterleri kaydettiğiniz için @ w0lf için teşekkürler.

GNU sed + dc, 116

Puan -rbayrakları için +1'i içerir 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/

Test çıkışı:

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

Alternatif:

Saf sed, 146

sedBir dckomutu değerlendirmek için GNU eklentisini kullanmanın hile yaptığını düşünebilirsiniz . Bu durumda, bu meta-cevaba göre, bunu biraz daha farklı yapabiliriz . Tabii ki soru açıkça, girişin 10. basamakta olması gerektiğini belirtiyor, ancak burada sedcevaplar için bunu geçersiz kılabileceğimizi ve bunun yerine unary (basamak 1) kullanabileceğimizi iddia etmeye çalışıyorum .

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

Test çıkışı

printfGerekli unary dizesini oluşturmak için kullanma :

$ printf "%33825s" | tr ' ' 1 | sed -rf 16bitgrid.sed 
+---+---+---+---+
| # |   |   |   |
+---+---+---+---+
|   | # |   |   |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+
|   |   |   | # |
+---+---+---+---+
$ 

C ++ 11, 193 191 190 176 172 bayt

Codegolf hakkındaki ilk çözümüm, bu yüzden beni suçlama.

#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?"|":"+");}}

Ungolfed

#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 ? "|" : "+");
    }
}

Önceki versiyon

#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");
    }
}

Pyth, 37 bayt

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

Çevrimiçi deneyin: Gösteri veya Test Paketi

Açıklama:

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

CJam, 43 41 bayt

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

Kesinlikle golf oynayabilir, ama sanırım bir başlangıç. Üst satırı oluşturur, ardından her 4 bit için bir çift satır oluşturur ve önceki tek satırı kopyalar.

Çevrimiçi deneyin .

Python 2, 122 121 120 bayt

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

@ Xnor'ın düzgün 4**8+numarası sayesinde -1 bayt . Ana baskı 9 defa tekrarlanarak tek / çift için uygun sırayı seçerek yapılır.

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

Fikir kalıp almaktır

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

%sboşluklar yerine olanlar hariç ve tuple değişimi yapın. Tuple benziyor

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

Girdideki rakamları ikili olarak çıkartarak ve ilgili sembolü demetin önüne ekleyerek yaratılır. Açık tuple içeren bir ifade eşit uzunluk verdi.

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

2 bayt için Sp3000'e teşekkürler.

PowerShell, 203 188 182 Bayt

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''

_{Düzenleme - |çizilen sırayı değiştirerek 15 bayt kaydetti , böylece .TrimEnd("|")çıktının üzerine bırakabilir ve for-loop'u bir dizi üreten bir alt kod bloğuna dönüştürebiliriz.}

_{Düzen2 - $odeğişkene kaydetme ihtiyacını ortadan kaldırarak ve sadece -join''doğrudan çıktı vererek 6 bayt daha kaydetti .}

Ooooooooof.

PowerShell'de çizim yapmak zordur . PowerShell'de ikili rakamlarla çalışmak zordur .

[convert]İkili bir dize gösterimine giriş tamsayısı için yerleşikler kullanır , ardından tekrar sıfırlama yapar, [int64]böylece .ToString()uygun sıfır sırasını hazırlamak / doldurmak için tekrar arayabiliriz . (Bir dizi dizisi yaratmanın ve bunlara katılmanın @(,"0"*16)-join''değişmez dizgiden 1 karakter daha kısa olduğuna dikkat edin "0000000000000000")

Ardından, 1..16|%{...}çıktı dizimizi oluşturmak için her basamağı kontrol etmek için basit bir döngü forumu alın, ardından -join''tekrar bir araya gelin.

Önceki, 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''

Önceki, 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('|')

Javascript (ES6), 216 207 bayt

Anonim bir işlev tanımlar.

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)

İpuçları için ETHproductions'e teşekkürler!

CJam, 62 bayt

"+---|   "4/{4*_c+N+}%4*_0=]sqi2bG0e[ee{~{_9*\4%5*-K+'#t0}&;}/

Çevrimiçi deneyin .

Pyth, 50 bayt

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

Açıklama başka bir zamana kadar beklemek zorunda kalacak, bunu telefonuma gönderiyorum!

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}

Algoritma

Yatay bir ayırıcı yazdırma

20 kez tekrarla (19..0)

Döngü numarası 5'e bölünmezse, 4/5 ile çarparak 16..0 aralığında bir sayıya dönüştürün. #Önce |ve ardından bir boşluk bırakın (ascii 32) veya (ascii 32 + 3 = 35) .

Döngü numarası 5'e bölünürse, sonlandırıcı bir |, yeni satır ve ilk ile aynı yatay bir bölücü yazdırın.

Perl, 103 bayt

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

Dizisi tekrar bir sürü bir ızgara yapmak için xdaha sonra, ikili ve giriş dönüştürmek, s sn veya ( ) belirtilen pozisyonda işaretine bağlı olarak ( ).s///x#$"$x

PHP, 159 bayt

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

Kullanımı:

php bingrid16.php 4242

Hiçbir şey fantezi, sadece kaba zorla render.

Döngü yerine dizileri kullanarak başka bir açı denedim, ancak 224 baytta daha uzundu:

<?=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)));

Perl 5 , 85 84 bayt

84 83 bayt kodu + -pbayrak

Dom bir newline kullanmamı hatırlattıktan sonra -1 bayt

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

Çevrimiçi deneyin!

c99 263 bayt

golfed:

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

ungolfed:

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

Ben sadece biraz değişken bir değişken sunmaktan hoşlandım ve bunun ilk uygun olduğunu hissettim (hatta bana bazı baytlara mal oldu; / argv

Ruby, 95

Kısa bir Dize dönüştürme için Mhmd'le başını salla, ancak sayı yöntemleri yerine dize yöntemlerini kullanmayı denemek istedim.

->i{puts g='+---'*4+?+;("%016b"%i).scan(/.{4}/){puts$&.gsub(/./){"| #{$&<?1?' ':?#} "}+"|
"+g}}

Ruby, 93

Sadece sayısal işlemleri kullanarak biraz daha kısa versiyon.

->i{n=g='+---'*4+"+
";15.downto(0){|m|n+="| #{[' ',?#][1&i>>m]} "
n+="|
"+g if m%4<1}
puts n}

C # 227 Bayt

golfed:

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

Girintileme:

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

İlk kez böyle bir şey deniyorum, ipuçları memnuniyetle karşılanacaktır!

Python 3, 145 144 Bayt

Çizgide:

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

Yeni satırlarla:

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

Düzenleme: 1 byte tasarruf için @manatwork tankları

Kotlin , 192 bayt

{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()}

Beautified

{
    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()
}

Ölçek

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

05AB1E , 45 bayt

bDg16αúS4ôεεð.ø}õ.ø'|ý}õ.ø…+--3F.∞}¶.øý10„# ‡

Çevrimiçi deneyin!