किसी भी अहस्ताक्षरित 16 बिट पूर्णांक को देखते हुए, इसके दशमलव रूप (अर्थात, बेस -10) संख्या को अपने बिट्स के 4x4 ASCII ग्रिड में, सबसे बाईं ओर के सबसे महत्वपूर्ण बिट (MSB) के साथ, कम से कम महत्वपूर्ण बिट (LSB) में बदलें नीचे दाईं ओर, और फिर नीचे (अंग्रेजी पाठ की तरह) पढ़ें।

उदाहरण

इनपुट: 4242

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

इनपुट: 33825

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

विशिष्ठ जरूरतें

इनपुट दशमलव (बेस -10) में होना चाहिए, हालांकि आप अपनी इच्छानुसार किसी भी तरह से द्विआधारी में परिवर्तित कर सकते हैं (भाषा निर्मित इन का उपयोग करके, यदि उपलब्ध हो तो)।
आउटपुट तालिका प्रारूप बिल्कुल मेल खाना चाहिए । इसका मतलब है आप विशिष्ट ASCII वर्ण (का उपयोग करना चाहिए -, +और |दिखाया गया है तालिका ग्रिड लाइन के लिए), प्रत्येक कोशिका की आंतरिक 3 अक्षरों है, और सच बिट्स का प्रतिनिधित्व कर रहे #हैं, जबकि झूठी एक अंतरिक्ष का प्रतिनिधित्व करती है ( )।
व्हाट्सएप का प्रमुख या अनुगामी होना अनुमति नहीं है। अंतिम नईलाइन की आवश्यकता है ।
बिट क्रम को वर्णित उदाहरणों से मेल खाना चाहिए।

भत्ता

कमांड लाइन, मानक इनपुट या उपयोगकर्ता इनपुट पर इनपुट का आधार -10 नंबर होना चाहिए , लेकिन आपके स्रोत कोड में हार्ड-कोड नहीं होना चाहिए ।

सबसे ~~साफ~~ कोड जीत हो सकती है! :-)

— type_outcast
स्रोत

1

सम्बंधित

— Sp3000

2

पहला वाक्य मुझे भ्रमित करने वाला लगता है, जहाँ यह कहता है कि "इसके दशमलव रूप को परिवर्तित करें "। बाकी पोस्ट और उदाहरण के आधार पर, ऐसा लगता है कि इनपुट दशमलव रूप में दिया गया है, लेकिन आपको मूल्य के द्विआधारी रूप को ग्रिड में बदलना होगा ।

— रेटो कोराडी

1

@RetoKoradi आप अनिवार्य रूप से सही हैं, लेकिन सवाल यह है कि आपको दशमलव संख्या को बाइनरी ग्रिड में बदलने की आवश्यकता है । द्विआधारी संख्या के साथ काम करने की कोई स्पष्ट आवश्यकता नहीं है , केवल एक संभावित कार्यान्वयन विवरण।

— type_outcast

क्या बेस -10 नंबर के साथ फ़ंक्शन लिखने से फ़ंक्शन तर्क की गिनती उपयोगकर्ता इनपुट के रूप में होती है?

— एलेक्स ए।

2

चूंकि आप कहते हैं कि दी गई संख्या एक "अहस्ताक्षरित 16 बिट पूर्णांक" है, यह द्विआधारी रूप में परिभाषा के अनुसार है। जब मैंने पहली बार इसे पढ़ा, तो यह वास्तव में लग रहा था कि इनपुट द्विआधारी रूप में दिया जाएगा। यह सब अंत की ओर स्पष्ट हो जाता है। लेकिन कम से कम मेरे लिए, पहला पैराग्राफ वास्तव में समस्या को पकड़ नहीं पाता है।

— रेटो कोराडी

21

जे, 26 बाइट्स

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

एक अनाम क्रिया। शुक्र है, जे ड्राइंग बॉक्स में बहुत अच्छा है। आइए इसे आजमाएँ:

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

जैसा कि कुछ टिप्पणीकारों ने उल्लेख किया है, जिस तरह से जे ड्रॉ बॉक्स सिस्टम-निर्भर है: कुछ प्लेटफार्मों पर, यह कोड डिफ़ॉल्ट सेटिंग्स के तहत काम करेगा, लेकिन दूसरों पर, यूनिकोड लाइन ड्राइंग वर्णों का उपयोग करके बक्से को खींचा जाएगा। (कमांड 9!:6और9!:7 आपको क्रमशः बॉक्स वाले मान खींचने के लिए वर्णों को क्वेरी और सेट करने की अनुमति देता है।)

— लिन
स्रोत

क्या आप (या कोई और) जानते हैं कि क्या गोल्फ स्कोरिंग के लिए बॉक्स ड्राइंग कमांड पर आम सहमति है, तो? मुझे व्यक्तिगत रूप से लगता है कि कोड गोल्फ के साथ धारणा यह है कि समाधान बहुमत सिस्टम पर काम करते हैं जो समाधान की भाषा पर चलता है, है ना? एक समाधान कैसा दिखेगा जो सभी (या लगभग सभी) जे प्रतिष्ठानों पर सही बक्से को आउटपुट करता है? मैं वास्तव में आपके समाधान को पसंद करता हूं , वैसे! मेरा मस्तिष्क अभी भी अपने तरीके से काम कर रहा है, जो कि कोड गोल्फ के बारे में मुझे पसंद है।

— type_outcast

5

@type_outcast हमें कोड गोल्फ चुनौतियों के लिए पोर्टेबिलिटी की आवश्यकता नहीं है। जब तक यह एक मंच पर कुछ कार्यान्वयन के साथ काम करता है, तब तक यह मान्य है।

— डेनिस

प्रतिक्रिया के लिए धन्यवाद @ डेनिस। मुझे खुशी है कि मेरा अनुमान गलत था, फिर, क्योंकि मैं (अभी भी) वास्तव में मौरिस के समाधान की तरह हूं! :-)

— टाइप_आउटकास्ट

14

जावास्क्रिप्ट (ईएस 6), 102

... या 96 के returnबजाय का उपयोग कर console.log।

एक 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
स्रोत

6

है "JavaScripy" कुछ अजीब जावास्क्रिप्ट / अजगर मैशप? ;-)

— डिजिटल ट्रामा

6

@DigitalTrauma बेशक। लेकिन जैसा कि दुनिया तैयार नहीं है ( tvtropes.org/pmwiki/pmwiki.php/Main/TheWorldIsNotReady ) इस नए विकास के लिए, मैं जावास्क्रिप्ट पर वापस लौट

— आऊंगा

कूल, एज पर यह काम करता है!

— आर्टुरो टॉरेस सैंचेज़

चाहिए ... नहीं ... क्लिक करें ... tvtropes ...

— आरके।

14

बेफुंज -93, 196 218 बाइट्स

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

कार्यक्रम चलाने के लिए ...

ऑनलाइन दुभाषिया पर जाएं ।
इस कोड को बड़े टेक्स्ट बॉक्स में पेस्ट करें।
क्लिक करें Show।
Inputबॉक्स में वांछित संख्या इनपुट करें ।
क्लिक करें Run। (या Slow5 मिलीसेकंड जैसी किसी चीज़ में बदलाव करें और फिर क्लिक करें Show।)
टा-दा!

4242 के लिए आउटपुट:

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

33825 के लिए आउटपुट:

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

व्याख्या

ओह अच्छाई, मैं अपने आप में क्या मिला है? खैर, यहाँ जाता है! (अप्रासंगिक कोड को .s के साथ बदल दिया जाता है ।)

भाग 1: इनपुट प्राप्त करें (0,0 में स्टोर करें) और 32768 (1,0 में स्टोर) की गणना करें।

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

भाग 2: "+ --- + --- + --- + ---" प्रिंट करें।

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

भाग 3: प्रिंट "+" और एक नई पंक्ति और यह देखने के लिए जांचें कि क्या (1,0) 0 है (यानी हम काम कर रहे हैं)। यदि हां, तो समाप्त करें। अन्यथा, जारी रखें।

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

भाग 4: इनपुट के द्विआधारी अंक प्राप्त करें, अद्यतन (0,0) और (1,0) जैसा कि हम साथ चलते हैं। सही चीजों को प्रिंट करें। मैं Befunge के रैप-अराउंड व्यवहार का लाभ उठाता हूं।

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

भाग 5: एक नई लाइन प्रिंट करें और उस भाग पर वापस जाएँ जो "+ --- + --- + --- + --- +" प्रिंट करता है। रैप-अराउंड ट्रिक का उपयोग किया जाता है।

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

टा-दा!

— एलेंडिया स्ट्राटन
स्रोत

10

जूलिया, 156 143 बाइट्स

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

इसे ऑनलाइन आज़माएं

— एलेक्स ए।
स्रोत

10

पायथन 2, 157 153 151 146 बाइट्स

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

4 बाइट्स बचाने के लिए मॉर्गन थ्राप और 5 को बचाने के लिए जोनाथन फ्रेच को धन्यवाद।

प्रयोग

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

— Zach गेट्स
स्रोत

यदि आप '+---'*4एक चर में खींचते हैं और दो और बचा सकते हैं यदि आप करते हैं तो दो औरj=''.join

— मॉर्गन थ्रैप

कोई बात नहीं! मैं वास्तव में एक बहुत ही समान समाधान पर काम कर रहा था।

— मॉर्गन थ्रैप

@downvoter देखभाल के बारे में बताएं?

— ज़च गेट्स

जब से तुम अजगर 3 का उपयोग नहीं करते हैं, तो आप बदल सकते हैं int(input())के साथ input()और पांच बाइट्स सहेजें।

— जोनाथन फ्रेच

9

रूबी, ११ Rub ११४

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

कुछ पात्रों को बचाने के लिए @ w0lf के लिए धन्यवाद।

— mhmd
स्रोत

1

यदि आप ?नोटेशन (उदाहरण: के ?|बजाय '|') का उपयोग करके शाब्दिक वर्ण लिखते हैं तो आप कुछ बाइट्स बचा सकते हैं । यह अंतरिक्ष को छोड़कर हर चीज के लिए काम करता है।

— क्रिस्चियन लुपस्क्यू

@ w0lf मैंने पाया है कि ?\sअंतरिक्ष के लिए काम करता है, हालांकि यह वास्तव में मददगार नहीं है।

— ममद

7

GNU sed + dc, 116

-rझंडे के लिए स्कोर में +1 शामिल है 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/

परीक्षण उत्पादन:

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

वैकल्पिक रूप से:

शुद्ध पालकी, १४६

आपको लगता है कि यह sedएक dcआदेश को विकसित करने के लिए GNU एक्सटेंशन का उपयोग करने के लिए धोखा दे सकता है । इस मामले में, हम इस मेटा-उत्तर के अनुसार इसे थोड़ा अलग तरीके से कर सकते हैं । बेशक यह सवाल स्पष्ट रूप से बताता है कि इनपुट बेस 10 में होना चाहिए, लेकिन यहां मैं यह दावा करने का प्रयास कर रहा हूं कि हम sedउत्तर के लिए इसे ओवरराइड कर सकते हैं और इसके बजाय (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/

परीक्षण उत्पादन

printfआवश्यक एकात्मक स्ट्रिंग उत्पन्न करने के लिए उपयोग करना :

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

— डिजिटल आघात
स्रोत

अच्छा है। यह कुछ हद तक पर्ल समाधान के समान है जिसे मैं प्रश्न को ठीक करते हुए अवधारणा के एक (निजी) सबूत के रूप में आया था।

— type_outcast

@type_outcast BTW एक जवाब के रूप में अपना खुद का समाधान पोस्ट करने के लिए पूरी तरह से ठीक है :)

— डिजिटल ट्रामा

मुझे पता है :-) मैंने इसे गोल्फिंग के लिए ज्यादा समय नहीं दिया, क्योंकि मैं एक अच्छा सवाल डालने पर ज्यादा ध्यान केंद्रित कर रहा था, लेकिन मैं अभी तक इसे फिर से देख सकता हूं और इसे पोस्ट कर सकता हूं अगर मैं इसे कम से कम आधे रास्ते में सम्मानित कर सकता हूं। फिलहाल मुझे बहुत मज़ा आ रहा है और हर किसी के जवाबों का मज़ा ले रहा हूँ।

— type_outcast

6

सी ++ 11, 193 191 190 176 172 बाइट्स

कोडगोल्फ पर मेरा पहला समाधान कभी, तो मुझे दोष मत देना।

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

पुराना वर्जन

#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
स्रोत

संकेत: 0x10000 65536 है, '0x' उपसर्ग होने से, हेक्स हमेशा दशमलव से अधिक लंबा होता है

— edc65

संकेत 2: youd को using namespace stdउत्पादन कोड से बचना चाहिए । और यह यहाँ भी उपयोगी नहीं है।

— edc65

@ edc65 dec-> हेक्स अच्छा विचार, मैंने हमेशा हेक्स को छोटे प्रतिनिधित्व के बारे में सोचा, लेकिन भूल जाओ 0x। using namespace stdकुछ बाइट्स बचाता है, क्योंकि मुझे उपसर्ग coutऔर cinसाथ नहीं है std::। यहां तक कि सिर्फ using std::cout;अभ्यस्त सहायता का उपयोग करना ।

— ज़ेरेगेस

अरे ज़ेरेगेस। आप शामिल और लाइब्रेरी के बीच की जगह को हटा सकते हैं .. और मुख्य फ़ंक्शन के लिए वापसी प्रकार को हटा सकते हैं।

— वेंडलेबसिल्वा

C++ऑटो इंट का समर्थन नहीं करता है।

— ज़ेरेगेस

6

पायथ, 37 बाइट्स

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

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट

स्पष्टीकरण:

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
स्रोत

5

CJam, 43 41 बाइट्स

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

निश्चित रूप से गोल्फ, लेकिन यह एक शुरुआत है जो मुझे लगता है। शीर्ष पंक्ति बनाता है, फिर प्रत्येक 4 बिट्स के लिए यह एक समान पंक्ति बनाता है और पिछली विषम पंक्ति को कॉपी करता है।

इसे ऑनलाइन आज़माएं ।

— Sp3000
स्रोत

4

पायथन 2, 122 121 120 बाइट्स

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 बाइट के लिए धन्यवाद @ xnor की साफ सुथरी 4**8+चाल। मुख्य मुद्रण 9 बार लूपिंग द्वारा किया जाता है, विषम / यहां तक कि उपयुक्त पंक्ति का चयन करता है।

— Sp3000
स्रोत

मुझे लगता है कि bin(4**8+input())[3:]एक बाइट ओवर बचाता हैformat

— xnor

@xnor ओह, यह साफ है :)

— Sp3000

4

पायथन 2, 94

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

विचार को पैटर्न लेना है

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

सिवाय %sरिक्त स्थान के और टपल प्रतिस्थापन का प्रदर्शन करने के लिए। टुपल जैसा दिखता है

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

यह बाइनरी में इनपुट से अंकों को उतारने और टुपल के सामने संबंधित प्रतीक को जोड़कर बनाया गया है। स्पष्ट टपल के साथ एक अभिव्यक्ति ने समान लंबाई दी।

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

2 बाइट्स के लिए Sp3000 का धन्यवाद।

— XNOR
स्रोत

4

पॉवरशेल, 203 188 182 बाइट्स

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

_{संपादित - |आरेखित किए गए ऑर्डर को बदलकर 15 बाइट्स सहेजे गए, इसलिए हम .TrimEnd("|")आउटपुट पर डंप कर सकते हैं और इसके बजाय एक लूप बनाने वाले सबकोड ब्लॉक में फॉर-लूप को परिवर्तित कर सकते हैं}

_{एडिट 2 - $oवेरिएबल में सेव करने और सिर्फ आउटपुट देने की जरूरत को खत्म करके एक और 6 बाइट्स बचाए-join'' सीधे ।}

Ooooooooof।

पॉवरशेल में ड्राइंग कठिन है । पॉवरशेल में द्विआधारी अंकों के साथ काम करना कठिन है ।

[convert]द्विआधारी में एक स्ट्रिंग प्रतिनिधित्व करने के लिए इनपुट पूर्णांक के लिए बिल्ट-इन का उपयोग करता है , फिर वापस कास्ट करें [int64]ताकि हम .ToString()उचित संख्या में ज़ीरो को प्रीपेंड / पैड करने के लिए फिर से कॉल कर सकें । (ध्यान दें कि तार की एक सरणी बनाना और उनसे जुड़ना @(,"0"*16)-join''शाब्दिक स्ट्रिंग से 1 वर्ण छोटा है "0000000000000000")

फिर, 1..16|%{...}हमारे आउटपुट ऐरे को बनाने के लिए प्रत्येक अंक की जाँच के लिए एक सरल-लूप लें, फिर अंत में -join''वापस एक साथ।

पिछला, 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''

पिछला-एर, 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
स्रोत

1

मुझे आशा है कि यह "मज़ेदार" था। :-) +1 आपके स्पष्टीकरण के लिए; इसने पावरशेल की मेरी सीमित समझ की मदद की।

— type_outcast

3

जावास्क्रिप्ट (ईएस 6), 216 207 बाइट्स

एक अनाम फ़ंक्शन को परिभाषित करता है।

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)

टिप्स के लिए ETHproductions का धन्यवाद!

— adroitwhiz
स्रोत

अच्छा काम! जब से आप ES6 का उपयोग कर रहे हैं, तो यहां कुछ सुझाव दिए गए हैं: 1. कभी भी आपको फ़ंक्शन के एकमात्र पैरामीटर के रूप में स्ट्रिंग का उपयोग करने की आवश्यकता होती है, आप टेम्पलेट स्ट्रिंग का उपयोग कर सकते हैं, जैसे: .join` | `2. आप मानों को प्रक्षेपित करने के लिए टेम्पलेट स्ट्रिंग का उपयोग भी कर सकते हैं: i=>`,${"0".repeat....join`,`},`.replace...3 आप इस धागे पर अधिक ES6 युक्तियाँ पा सकते हैं ।

— ETHproductions

ऐसा लगता है कि काम करना बंद कर दिया है, लेकिन इसे थोड़ा और अधिक गोल्फिंग करके, मैं सही परिणाम के साथ 197 प्राप्त कर सकता हूं:

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)

— ETHproductions

2

("0".repeat(16)+i.toString(2)).slice(-16) ->(65536|i).toString(2).slice(1)

— edc65

अपने सटीक तर्क को ध्यान में रखते हुए, इसे 169 तक पहुंचाया जा सकता है, jsfiddle.net/76fp7aw6

— edc65

2

सीजेएम, 62 बाइट्स

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

इसे ऑनलाइन आज़माएं ।

— एंड्रिया बियोन्डो
स्रोत

2

पायथ, 50 बाइट्स

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

स्पष्टीकरण के लिए एक और समय तक इंतजार करना होगा, मैं इसे अपने फोन पर पोस्ट कर रहा हूं!

— सोक
स्रोत

2

रूबी, 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}

कलन विधि

एक क्षैतिज विभक्त मुद्रित करें

20 बार लूप (19..0)

यदि लूप संख्या 5 से विभाजित नहीं होती है, तो 16..0 की संख्या को 4/5 से गुणा करके संख्या में परिवर्तित करें। एक स्थान (ascii 32) या #(ascii 32 + 3 = 35) से पहले मुद्रित करें| और उसके बाद एक स्थान छोड़ें।

यदि लूप संख्या 5 से विभाजित होती है, तो एक समाप्ति प्रिंट करें, नई रेखा और पहले के समान एक क्षैतिज विभक्त।

— स्तर नदी सेंट
स्रोत

2

पर्ल, 103 बाइट्स

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

स्ट्रिंग पुनरावृत्ति बहुत सारे का एक ग्रिड बनाने के लिए xहै, द्विआधारी और फिर करने के लिए इनपुट कन्वर्ट करने के लिए रों या ( ) निर्दिष्ट स्थान पर झंडा पर निर्भर करता है ( )।s///x#$"$x

— डोम हेस्टिंग्स
स्रोत

2

PHP, 159 बाइट्स

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

उपयोग:

php bingrid16.php 4242

कुछ भी नहीं फैंसी, बस जानवर मजबूर प्रतिपादन।

मैंने छोरों के बजाय सरणियों का उपयोग करके एक और कोण की कोशिश की, लेकिन यह 224 बाइट्स में लंबा था:

<?=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
स्रोत

2

पर्ल 5 , 85 84 बाइट्स

कोड + के 84 83 बाइट्स-p ध्वज के

डोम के बाद -1 बाइट ने मुझे एक नई लाइन का उपयोग करने की याद दिलाई

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

इसे ऑनलाइन आज़माएं!

— Xcali
स्रोत

अच्छा है, मेरा बेहतर दृष्टिकोण! एक शाब्दिक न्यूलाइन आपको एक अतिरिक्त बाइट से $/भी बचाएगा !

— डोम हेस्टिंग्स

1

c99 263 बाइट्स

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

मैं बस थोड़ा सा बदलाव करना पसंद करता हूं और यह पहली बार महसूस किया कि यह उपयुक्त है (यहां तक कि मुझे कुछ बाइट्स की लागत भी है, लेकिन सी इस बाइट्स को एक मौका के साथ भी बाइट्स में शामिल नहीं कर सकता है) इसलिए मुझे argc का उपयोग करने की आवश्यकता नहीं है / argv

— Zaibis
स्रोत

1

रूबी, 95

एक संक्षिप्त स्ट्रिंग रूपांतरण के लिए एमएचडी को नोड, लेकिन मैं संख्या विधियों के बजाय स्ट्रिंग विधियों का उपयोग करने की कोशिश करना चाहता था।

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

— चार्ल्स नहीं
स्रोत

1

रूबी, 93

केवल संख्यात्मक संचालन का उपयोग करके थोड़ा छोटा संस्करण।

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

— चार्ल्स नहीं
स्रोत

1

सी # 227 बाइट्स

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

दांतेदार बनाना:

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

पहली बार मैं कुछ इस तरह की कोशिश कर रहा हूँ, सुझावों का स्वागत किया जाएगा!

— anthonytimmers
स्रोत

सबसे पहले, मैं 286 बाइट्स गिनता हूं और आप इंडेंटेशन स्पेस को हटा सकते हैं।

— ब्लू

आप वास्तव में इसे कैसे गिनते हैं? मैं वहाँ फ़ाइल का आकार देखने के लिए गुणों के लिए जा रहा हूँ, लेकिन मुझे यकीन नहीं है कि अगर ऐसा करने का तरीका है! इंडेंटेशन के बिना मैं 230 बाइट्स पर आ गया हूँ!

— एंथोनीटाइमर

Mothereff.in/byte-counter जैसी किसी चीज़ का उपयोग करें , या यदि आप linux पर हैं, तो wcकमांड का उपयोग करें

— Blue

1

पायथन 3, 145 144 बाइट्स

पंक्ति में:

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

नई सुर्खियों के साथ:

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

संपादित करें: 1 बाइट की बचत के लिए टैंक @manatwork

— Bassintag
स्रोत

1

Gnibbler की नोक पर आधारित , हार्डकोडिंग r=0,1,2,31 वर्ण है जो इसे बनाने से छोटा है r=range(4)।

— मैनावर्क

0

कोटलिन , 192 बाइट्स

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

सजा हुआ

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

परीक्षा

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
स्रोत

0

05AB1E , 45 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— जादू ऑक्टोपस Urn
स्रोत

16-बिट बाइनरी ग्रिड

उदाहरण

इनपुट: 4242

इनपुट: 33825

विशिष्ठ जरूरतें

भत्ता

जे, 26 बाइट्स

जावास्क्रिप्ट (ईएस 6), 102

बेफुंज -93, 196 218 बाइट्स

कार्यक्रम चलाने के लिए ...

व्याख्या

भाग 1: इनपुट प्राप्त करें (0,0 में स्टोर करें) और 32768 (1,0 में स्टोर) की गणना करें।

भाग 2: "+ --- + --- + --- + ---" प्रिंट करें।

टा-दा!

जूलिया, 156 143 बाइट्स

पायथन 2, 157 153 151 146 बाइट्स

प्रयोग

रूबी, ११ Rub ११४

GNU sed + dc, 116

शुद्ध पालकी, १४६

परीक्षण उत्पादन

सी ++ 11, 193 191 190 176 172 बाइट्स

पायथ, 37 बाइट्स

स्पष्टीकरण:

CJam, 43 41 बाइट्स

पायथन 2, 122 121 120 बाइट्स

पायथन 2, 94

पॉवरशेल, 203 188 182 बाइट्स

पिछला, 188

पिछला-एर, 203

जावास्क्रिप्ट (ईएस 6), 216 207 बाइट्स

सीजेएम, 62 बाइट्स

पायथ, 50 बाइट्स

रूबी, 102

पर्ल, 103 बाइट्स

PHP, 159 बाइट्स

पर्ल 5 , 85 84 बाइट्स

c99 263 बाइट्स

रूबी, 95

रूबी, 93

सी # 227 बाइट्स

पायथन 3, 145 144 बाइट्स

कोटलिन , 192 बाइट्स

सजा हुआ

परीक्षा

05AB1E , 45 बाइट्स