त्रिभुज गणना की द्विआधारी छवियाँ

Question

मेरी चुनौतियां थोड़ी कठिन और बदसूरत हैं। तो यहाँ कुछ आसान और मजेदार है।

अलकुइन का क्रम

अलक्यूइन के अनुक्रम A(n) को त्रिभुजों की गणना द्वारा परिभाषित किया गया है। A(n)पूर्णांक पक्षों और परिधि के साथ त्रिकोणों की संख्या है n। इस क्रम को यॉर्क के अल्कुइन के बाद कहा जाता है।

इस क्रम के पहले कुछ तत्व इस प्रकार n = 0हैं:

0, 0, 0, 1, 0, 1, 1, 2, 1, 3, 2, 4, 3, 5, 4, 7, 5, 8, 7, 10, 8, ...

उदाहरण के लिए A(9) = 3, क्योंकि पूर्णांक पक्षों और परिधि के साथ एकमात्र त्रिकोण 9हैं 1 - 4 - 4, 3 - 3 - 3और 2 - 3 - 4। आप नीचे 3 मान्य त्रिकोण नीचे देख सकते हैं।

इस क्रम में कुछ काफी दिलचस्प पैटर्न हैं। उदाहरण के लिए A(2*k) = A(2*k - 3)।

अधिक जानकारी के लिए, OEIS पर A005044 देखें ।

चुनौती

लेकिन आपकी चुनौती इन नंबरों के द्विआधारी प्रतिनिधित्व के बारे में है। यदि हम प्रत्येक अनुक्रम संख्या को बाइनरी प्रतिनिधित्व में परिवर्तित करते हैं, तो उन्हें कॉलम वैक्टर में डालें और उन्हें पंक्तिबद्ध करें, यह एक काफी दिलचस्प बाइनरी चित्र बनाता है।

निम्नलिखित तस्वीर में आप अनुक्रम संख्याओं के द्विआधारी प्रतिनिधित्व को देख सकते हैं A(0), A(1), ..., A(149)। पहले कॉलम में आप बाइनरी प्रतिनिधित्व देख सकते हैं A(1), दूसरे कॉलम में A(1)और इतने पर।

आप इस चित्र में किसी प्रकार का दोहराव पैटर्न देख सकते हैं। यह भी भग्न की तरह थोड़े दिखता है, यदि आप अनुक्रम संख्या के साथ छवि को देखते हैं A(600), A(601), ..., A(899)।

आपका काम ऐसी छवि बनाना है। आपके फ़ंक्शन, आपकी स्क्रिप्ट को दो पूर्णांक प्राप्त होंगे 0 <= m < n, और इसमें अलकिन के अनुक्रम की द्विआधारी छवि उत्पन्न करनी होगी A(m), A(m+1), A(m+2), ..., A(n-2), A(n-1)। तो इनपुट 0, 150पहली तस्वीर उत्पन्न करता है, इनपुट 600, 900दूसरी तस्वीर।

आप किसी भी लोकप्रिय ग्राफिक्स प्रारूप का उपयोग कर सकते हैं। मान लीजिए कि प्रत्येक प्रारूप, जिसे image.online-convert.com का उपयोग करके png में परिवर्तित किया जा सकता है । वैकल्पिक रूप से, आप स्क्रीन पर छवि प्रदर्शित कर सकते हैं। कोई भी प्रमुख सफेद पंक्तियों की अनुमति नहीं है!

यह कोड-गोल्फ है। तो सबसे छोटा कोड (बाइट्स में) जीतता है।

Comments

एह, मुझे इस चुनौती को करने में दिलचस्पी थी जब तक कि मुझे बाइनरी इमेज बनाने के लिए भाग नहीं मिला। यह एक बाहरी कदम की तरह लगता है। मैं पायथन में छवि निर्माण के लिए एक पुस्तकालय सीखने की तरह महसूस नहीं करता हूं, और मुझे उम्मीद है कि अगर मैंने किया, तो गोल्फ के लिए बहुत कुछ नहीं होगा।

— xnor

@ xnor: फिर PBM जैसे कुछ सरल छवि प्रारूप का उपयोग करें ।

— जेक्यूब

क्या यह white=1 and black=0या दूसरा तरीका है?

— माल्टीसेन

@ माल्टीसेन white=0 and black=1। तो दूसरा तरीका। A(0)सफेद कॉलम A(9)=3बनाता है, सबसे नीचे 2 काले पिक्सेल के साथ एक सफेद कॉलम बनाता है।

— जक्यूब

क्या आप सुनिश्चित हैं कि पहली छवि सही है? यह 0,0,0,1,0,2सवाल की शुरुआत में सूची कहता है, जबकि है 0,0,0,1,0,1।

— माल्टसेन

Answer 1

जे ( ५२ ४५ (कोडपेज ४३)))

इसकी अनुमति होगी (मुझे लगता है)

[:|:' █'{~[:#:[:([:<.48%~*:+24+6*]*2|])(}.i.)

हेक्स डंप

(वास्तव में कुछ खास नहीं है, ब्लैक स्क्वायर डीबी ₁₆ या 219 ₁₀ कोडपेज 437 में है।)

0000: 5b 3a 7c 3a 27 20 db 27 7b 7e 5b 3a 23 3a 5b 3a   [:|:' .'{~[:#:[:
0010: 28 5b 3a 3c 2e 34 38 25 7e 2a 3a 2b 32 34 2b 36   ([:<.48%~*:+24+6
0020: 2a 5d 2a 32 7c 5d 29 28 7d 2e 69 2e 29            *]*2|])(}.i.)

प्रयोग

यह आउटपुट निम्नानुसार है (कोड टैग लाइनों के बीच स्थान जोड़कर इसे गड़बड़ करते हैं):

   A=:[:|:' █'{~[:#:[:([:<.48%~*:+24+6*]*2|])(}.i.)
   0 A 100
                                                                             █ █████████████████████                                          
                                                     █ ██████████████████████ █              █ █████                          
                                     █ ██████████████ █          █ ██████████ █      █ ██████ █                   
                         █ ██████████ █      █ ██████ █    █ ████ █    █ ████ █  █ ██ █  █ ██ █  █ █  
                 █ ██████ █    █ ████ █  █ ██ █  █ ██ █  █  █  █  █  █  ██ ██ ██  ██  ██  ██  ██  ██
           █ ████ █  █ ██ █  █  █  █  ██  ██  ██  ██  ██  █  █  █  █ ██ █  █ ████ █                               
       █ ██ █  █  ██  ██  ██  █  █ ██ █                █ ██ █  █  ██  ██  ██  █  █ ██ █                                   
   █ ██ ██  ██ ██ █        █ ██ ██  ██ ██ █        █ ██ ██  ██ ██ █        █ ██ ██  ██ ██ █        █    
   2000 A 2100
████████████████████████████████████████████████████████████████████████████████████████████████████

████████████████████████████████████████████████████████████████████████████████████████████████████
                                                                             █ █████████████████████
                             █ ██████████████████████████████████████████████ █
     █ ██████████████████████ █                      █ ██████████████████████ █
█████ █          █ ██████████ █          █ ██████████ █          █ ██████████ █          █ █████████
 ████ █    █ ████ █    █ ████ █    █ ████ █    █ ████ █    █ ████ █    █ ████ █    █ ████ █    █ ███
█  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █
██  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █ ██ ██ █
 █ ██ ██ ██ ██ ██ █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  ██ ██ ██ ██ ██  █  █
  ██ ██ ██  █  █  ██ ██ ██  █  █  █  █  █  █  █  █  █  █  █  █  █  █ ██ ██ ██ █  █  █  █ ██ █  █ ██
 █ ██ █  █ ██ █  █ ██ █  █ ██ █  █  █  █  █  █  █  █  █  █  ██ ██ ██  █  █  ██  ██ ██ ██  ██  ██  ██
  ██  ██  ██  ██  ██  ██  ██  ██ ██ ██  █  █  █  █  █  █ ██ █  █ ██ █  █ ████ █    █ ██████ █
█ █                        █ ████ █  █ ██ █  █  █  █  ██  ██  ██  ██  ██  █  █  █  █ ██ █  █ ████ █
 █ ██ █                █ ██ █  █  ██  ██  ██  █  █ ██ █                █ ██ █  █  ██  ██  ██  █  █ █
██  ██ ██ █        █ ██ ██  ██ ██ █        █ ██ ██  ██ ██ █        █ ██ ██  ██ ██ █        █ ██ ██

मानक J कंसोल में, लाइनों के बीच कोई रिक्ति नहीं है, इसलिए मैं नियम को 'वैकल्पिक रूप से, आप स्क्रीन पर छवि प्रदर्शित कर सकते हैं।' (कहीं यह नहीं कहा कि इस छवि को आंतरिक रूप से एक समझदार छवि प्रारूप के रूप में प्रतिनिधित्व करना था)

संपादित करें: Jconsole (JQT के विपरीत) एक डिफ़ॉल्ट के रूप में कोडपेज 437 का उपयोग करता है, और स्ट्रिंग से उनका उपयोग करते समय आयतों को सही ढंग से प्रस्तुत करता है।

Answer 2

गणितज्ञ, 126 122 121 89 बाइट्स

Image[1-Thread@IntegerDigits[l=Round[(#+3#~Mod~2)^2/48]&/@Range@##,2,⌈2~Log~Max@l⌉]]&

यह दो पूर्णांकों को मापदंडों के रूप में लेने और स्क्रीन पर छवि प्रदर्शित करने के लिए एक अनाम फ़ंक्शन को परिभाषित करता है। यह प्रत्येक वर्ग को एक एकल पिक्सेल के रूप में प्लॉट करता है, लेकिन यदि आप चाहें तो वास्तव में ज़ूम इन कर सकते हैं।

अब मैं OEIS लेख में दिए गए एक स्पष्ट फार्मूले का उपयोग कर रहा हूं (पहले मैथमेटिका अनुभाग में, डेविड कारराहर को धन्यवाद जो इसे इंगित करने के लिए धन्यवाद)। यह भी अब धधक रहा है।

यहाँ कुछ टिप्पणियों के साथ इंडेंट कोड दिया गया है:

Image[1-Thread@IntegerDigits[   (* 3. Convert each number to padded binary, transpose
                                      invert colours, and render as Image. *)
    l = Round[
      (#+3#~Mod~2)^2/48
    ] & /@ Range@##,            (* 1. Turn input into a range and get the Alcuin
                                      number for each element. *)
    2,
    ⌈2~Log~Max@l⌉               (* 2. Determine the maximum number of binary digits. *)
]] &

यहाँ के लिए उत्पादन है 0, 600:

Comments

बस एक ही आकार के बारे में (क्योंकि बाएं और दाएं छत को वर्तनी होना चाहिए):Image[1 - Thread@IntegerDigits[ l = Round[If[EvenQ[#], #^2, (# + 3)^2]/48] & /@ Range@##, 2, \[LeftCeiling]2~Log~Max@l\[RightCeiling]]] &

— डेविडक

@DavidCarraher धन्यवाद, मैंने इसे थोड़ा और आगे बढ़ाया। :) (OEIS लेख की जाँच करनी चाहिए।)

— मार्टिन एंडर

Answer 3

CJam ( 56 55 53 वर्ण) / GolfScript (64 वर्ण)

CJam:

"P1"q~,>{_1&3*+_*24+48/}%_:e>2b,\2_$#f+2fbz(,@@:~~]N*

GolfScript:

"P1"\~,>{.1&3*+.*24+48/}%.$-1=2base,\{2.$?+2base}%zip(,@@{~}/]n*

दोनों NetPBM प्रारूप में उत्पादन करते हैं, और वे अनिवार्य रूप से एक दूसरे के बंदरगाह हैं।

विच्छेदन

CJam                 GolfScript           Explanation

"P1"                 "P1"\                NetPBM header
q~,>                 ~,>                  Create array [m .. n-1]
{_1&3*+_*24+48/}%    {.1&3*+.*24+48/}%    Map the sequence calculation
_:e>2b,\             .$-1=2base,\         Compute image height H as highest bit
                                          in largest number in sequence
2_$#f+2fb            {2.$?+2base}%        Map sequence to bits, ensuring that
                                          each gives H bits by adding 2^H
z(,@@                zip(,@@              Transpose and pull off dummy row to use
                                          its length as the "width" in the header
:~~                  {~}/                 Flatten double array and dump on stack
]N*                  ]n*                  Separate everything with whitespace

करने के लिए धन्यवाद CJam 56 -> 53 ऑप्टिमाइज़र के लिए ।

Comments

किसी भी कारण से आपके पास शुरुआत में "P1" नहीं है और इस प्रकार `` से बचकर 1 बाइट बचाएं?

— ऑप्टिमाइज़र

@ ऑप्टिमाइज़र, जीएस में भी सोचता था।

— पीटर टेलर

बिल्कुल नहीं: ऊंचाई को आउटपुट में दिखाई देना चाहिए। लेकिन नक्शे को छोटा करने के लिए अभी भी एक बचत है।

— पीटर टेलर

51:'PoXq~{_1&3*+_*24+48/}%>_:e>2b,\2_$#f+2fbz(,@@]e_N*

— अनुकूलक

Answer 4

पायथ - 101 60 59

आउटपुट ए .pbm। संभावना अधिक गोल्फ हो सकती है।

Km.B/++24*dd**6%d2d48rvzQJCm+*\0-eSmlkKlddK"P1"lhJlJjbmjbdJ

अत्यधिक असहमत हूं क्योंकि मैं पर्थ में अनुवाद करूंगा।

आगे आने वाला स्पष्टीकरण। अभी बराबर पायथन कोड को देखें।

यह अनुक्रम की गणना करने के लिए OEIS एल्गोरिथ्म का उपयोग करता है और फिर यह बाइनरी में कनवर्ट करता है, संख्याओं को पैड करता है, एक मैट्रिक्स रोटेशन करता है, और इसे एक pbmछवि में प्रारूपित करता है । चूंकि मैं जानवर बल का उपयोग नहीं कर रहा हूं, यह अविश्वसनीय रूप से तेज है।

         K=
 m          rvzQ      Map from eval input to eval input
  .B                  Binary rep
   /      48          Divided by 48
    ++                Triple sum      
     24               Of 24,
     *dd              Square of d
     **               Triple product
      6               6
      %d2             Modulo d%2
      d               Var d
J                     Set J=
 C                    Matrix rotation from columns of row to rows of columns
  m           K       Map K (This does padding)
   +                  String concat
    *                 String repeat
     \0               "0"
     -     ld         Subtract the length of the column from
      eS              The max
       mlkK           Of all the column lengths
    d                 The column
"P1"                  Print header "P1"
l                     Length of
 hJ                   First row
lJ                    Number of columns
jb                    Join by linebreaks
 m  J                 Map on to J
  jb                  Joined columns by linb
   d

यहाँ 600,900उदाहरण है:

इसे यहाँ ऑनलाइन प्रयास करें ।

Answer 5

आर - 127 125

मुझे यकीन नहीं है कि यह पूरी तरह से नियमों का अनुपालन करता है। यह एक फ़ाइल के लिए एक छवि आउटपुट नहीं करता है, लेकिन यह एक रेखापुंज बनाता है और इसे आउटपुट डिवाइस पर प्लॉट करता है।

मुझे मार्टिन के समान सूत्र मिला, लेकिन यहां ।

यह एक अनाम फ़ंक्शन का उपयोग करता है।

require(raster);function(m,n)plot(raster(mapply(function(n)rev(as.integer(intToBits(round((n+n%%2*3)^2/48)))),m:n),0,n,0,32))

इस प्रकार चलाएं

require(raster);(function(m,n)plot(raster(mapply(function(n)rev(as.integer(intToBits(round((n+n%%2*3)^2/48)))),m:n),0,n,0,32)))(0,600)

निम्नलिखित कथानक का निर्माण करता है

Comments

आप rasterनामस्थान से संलग्न न करके 7 बाइट्स को छोड़ सकते हैं , क्योंकि raster()उस पैकेज के लिए केवल वही चीज है। इसके बजाय बस करो raster::raster(...)।

— एलेक्स ए।

@AlexA। धन्यवाद, उस एडिट को

— बनाऊंगा

@AlexA। दुर्भाग्य से मैंने अभी इसकी कोशिश की और यह मेरे लिए गलत है। मुझे संदेह है कि यह इसलिए है क्योंकि रेखापुंज के रूप में अच्छी तरह से सपा की आवश्यकता है। मैं देखूंगा कि क्या मैं इसे ट्रैक कर सकता हूं।

— मिकी टीटी

ओह। क्षमा करें, आप भटक गए हैं।

— एलेक्स ए।

Answer 6

पायथन 2 + पीआईएल , 255 184

छवि दिखाने के लिए PIL का उपयोग मेरा पहला संस्करण:

i,R,B=input,range,lambda x:bin((x*x+6*x*(x%2)+24)/48)[2:]
def F(k,v):i.load()[k]=v
a,b=i(),i();h=len(B(b));from PIL import Image;i=Image.new('P',(b-a,h))
[F((x-a,y),int(B(x).zfill(h)[y])) for x in R(a,b) for y in R(h)]
i.putpalette([255]*3+[0]*3)
i.show()

नया संस्करण सिर्फ stdout पर एक b & w PPM छवि तैयार करता है:

i,R,B=input,range,lambda x:bin((x*x+6*x*(x%2)+24)/48)[2:]
def p(s):print s
a,b=i(),i();h=len(B(b));p('P1 %i %i'%(b-a,h))
[p(' '.join([B(x).zfill(h)[y] for x in R(a,b)])) for y in R(h)]

Comments

कुछ वर्ण PPM संस्करण के लिए सहेजता है: आपको पहले किसी स्थान की आवश्यकता नहीं है for। आप x%2ऑर्डर बदलने के लिए आसपास के पार्न्स से बच सकते हैं x%2*...। यह एक फ़ंक्शन के रूप में प्रिंट को परिभाषित नहीं करने के लिए छोटा है और नई रेखाओं से बचने के लिए और नई पंक्ति शुरू करने के लिए रिक्त forका उपयोग करते हुए, बस दो नेस्टेड छोरों का उपयोग print ...,करें print। द्विआधारी विस्तार को बाध्य करने की एक चाल hबिना लंबाई के zfillहै 2**h, फिर अंतिम hअंकों को निकालना है ।

— xnor

Answer 7

JAVASCRIPT - 291

कोड:

(function(a,b,c){c.width=b;t=c.getContext('2d');t.strokeStyle='black';for(i=a;i<=b;i++){g=(Math.floor(((i*i)+6*i*(i%2)+24)/48)>>>0).toString(2);l=g.length;for(j=0;j<l;j++){if(g[l-1-j]=='1'){t.rect(i-a,j,1,1);t.fill();}}}document.body.appendChild(c);})(0,300,document.createElement('canvas'))

स्पष्टीकरण:

(function (a, b, c) {
    //setting canvas width
    c.width = b;
    //get context 2d of canvas
    t = c.getContext('2d');
    //setting storke style.
    t.strokeStyle = 'black';
    //looping from a to b
    for (i = a; i <= b; i++) {
        //calculating A(i) and converting it to a binary string
        g = (Math.floor(((i * i) + 6 * i * (i % 2) + 24) / 48) >>> 0).toString(2);
        //looping through that string
        for (j = 0; j < g.length; j++) {
            //since canvas is upside down and the first digit is actually the last digit:
            if (g[g.length - 1 - j] == '1') {
                //we create the 1 by 1 rect
                t.rect(i - a, j, 1, 1);
                //we draw the rect
                t.fill();
            }
        }
    }
    //we append everything to the body
    document.body.appendChild(c);
    //parameters are put here
})(0, 300, document.createElement('canvas'))

परिणाम:

हाँ परिणाम उल्टा है, लेकिन क्योंकि उस के 0,0एक पर js canvasऊपरी बाएँ है। : 3

डेमो:

Jsfiddle पर डेमो