64 बिट ASCII बुनाई

18

इनपुट

दो पूर्णांक:

  • बुनाई को निर्दिष्ट करते हुए 0 से 2 ^ 64-1 की सीमा में एक गैर-नकारात्मक पूर्णांक डब्ल्यू ।
  • एक सकारात्मक पूर्णांक S , सीमा 1 से 255 तक, साइड की लंबाई निर्दिष्ट करता है।

इनमें से जो भी आपको सूट करे, लिया जा सकता है।

उत्पादन

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

परिवर्तित डब्ल्यू 8 बाइट्स में द्विआधारी और विभाजन करने के लिए। पहली (सबसे महत्वपूर्ण) बाइट शीर्ष पंक्ति को परिभाषित करती है, बाएं (सबसे महत्वपूर्ण बिट) से दाईं ओर। अगली बाइट अगली पंक्ति को परिभाषित करती है, और इसी तरह 8 पंक्तियों के लिए। बुनाई की संख्या 8 से 8 वर्ग को परिभाषित करती है जिसे शीर्ष बाएं से शुरू होने वाले आवश्यक क्षेत्र पर टाइल किया जाना चाहिए। यही है, इसके शीर्ष बाएं कोने को कवर किए जाने वाले क्षेत्र के शीर्ष बाएं कोने के अनुरूप होना चाहिए।

प्रत्येक 0को ए के रूप में प्रदर्शित किया जाना चाहिए |और प्रत्येक 1को ए के रूप में प्रदर्शित किया जाना चाहिए-

उदाहरण

इनपुट: 0 8

ouput:

||||||||
||||||||
||||||||
||||||||
||||||||
||||||||
||||||||
||||||||

इनपुट: 3703872701923249305 8

आउटपुट:

||--||--
|--||--|
--||--||
-||--||-
||--||--
|--||--|
--||--||
-||--||-

इनपुट: 3732582711467756595 10

आउटपुट:

||--||--||
--||--||--
--||--||--
||--||--||
||--||--||
--||--||--
--||--||--
||--||--||
||--||--||
--||--||--

इनपुट: 16141147355100479488 3

आउटपुट:

---
|||
---

लीडरबोर्ड स्निपेट

( मार्टिन के टेम्पलेट का उपयोग करते हुए )

कोड स्निपेट दिखाएं

code-golf  ascii-art  base-conversion  tiling 
— trichoplax
स्रोत

जवाबों:

10

के, २०

{y#y#'"|-"8 8#0b\:x}

।

             0b\:x    // convert to binary
         8 8#         // reshape into an 8x8 boolean matrix
     "|-"             // index into this char vector using the booleans as indices  
  y#'                 // extend horizontally
y#                    // extend vertically

।

k){y#y#'"|-"8 8#0b\:x}[3703872701923249305j;10]
"||--||--||"
"|--||--||-"
"--||--||--"
"-||--||--|"
"||--||--||"
"|--||--||-"
"--||--||--"
"-||--||--|"
"||--||--||"
"|--||--||-"

k){y#y#'"|-"8 8#0b\:x}[3703872701923249305j;8]
"||--||--"
"|--||--|"
"--||--||"
"-||--||-"
"||--||--"
"|--||--|"
"--||--||"
"-||--||-"
— tmartin
स्रोत
यह वास्तव में इस से अधिक सरल या अधिक सरल नहीं है!
— जॉन जूल
1
@ जॉन यह केवल उन लोगों के लिए सच है जो के।;) को समझते हैं
— एलेक्स ए।
14

CJam, 33 31 बाइट्स

q~:X;2b64Te["|-"f=8/{X*X<z}2*N*

इसका परीक्षण यहां करें।

व्याख्या

q~      e# Read and eval input.
:X;     e# Store the side length in X and discard it.
2b      e# Convert to base 2.
64Te[   e# Left-pad to length 64 with zeroes.
"|-"f=  e# Select '|' for 0 and '=' for 1.
8/      e# Split into chunks of 8 bits.
{       e# Do the following twice:
  X*    e#   Repeat lines X times (to ensure we have enough of them).
  X<    e#   Truncate them to exactly X lines.
  z     e#   Transpose the grid.
        e#   The transpose ensures that the second pass tiles the columns, and that the
        e#   grid is oriented correctly again after both passes are done.
}2*
N*      e# Join lines by newline characters.
— मार्टिन एंडर
स्रोत
2
मैं आपकी सराहना करता हूं :)। पीपीसीजी के इतिहास में शायद यह सबसे तेज जवाब है
— बीटा
7
@ BetaDecay गोल्फ भाषाओं का लाभ यह है कि आपके पास टाइप करना कम है, इसलिए आप तेजी से कोड कर सकते हैं। : पी
— मार्टिन एंडर
1
गीज़, यहां तक कि जवाब देने से पहले टैग्स को संपादित करने की परेशानी में चला गया ! कोई बहुत अधिक समय व्यतीत करता है गोल्फिंग; पी
— सब्रे
क्या यह इरादा आउटपुट है: लिंक
— ऑक्टेविया तोगामी
@Kenzie कि इनपुट नंबर से बड़ा है 2^64-1।
— मार्टिन एंडर
5

जावा, 110 109 107 बाइट्स

मेरा कोड एक अनाम लंबो फ़ंक्शन के रूप में है जो एक लेता है longऔर intफिर एक रिटर्न देता है String।

(w,s)->{String b="";for(int j,i=s--;i-->0;b+='\n')for(j=s;j>=0;)b+=(w>>8*(i%8)+j--%8)%2<1?'|':45;return b;}

पूर्ण परीक्षण योग्य वर्ग

import java.util.function.BiFunction;
public class AsciiWeave {   
    public static void main(String[] args){
        BiFunction<Long,Integer,String> weave = 
            (w,s)->{String b="";for(int j,i=s--;i-->0;b+='\n')for(j=s;j>=0;)b+=(w>>8*(i%8)+j--%8)%2<1?'|':45;return b;}}
        ;
        System.out.println(weave.apply(Long.valueOf(args[0]),Integer.valueOf(args[1])));
    }
}
— आंख-morpork
स्रोत
3
मुझे कहना होगा, मुझे जावा द्वारा पीटा जाने की आदत नहीं है। : पी अच्छा काम।
— एलेक्स ए।
धन्यवाद @AlexA! लैम्ब्डा वास्तव में जावा को गोल्फ के लिए अधिक उपयोगी बनाते हैं: (w,s)->इसके बजाय String w(long w,int s)बल्ले से एक बड़ी बचत है।
— आख-मोपर्क
@Ypnypn को निश्चित रूप से काम करना चाहिए
— akh-morpork
वाह, यह प्रभावशाली है। बहुत बढ़िया।
— TheNumberOne
4

मतलाब, 86 80 बाइट्स

function f(W,S)
a='|-';x=de2bi(typecast(W,'uint8'))+1;s=8-mod(0:S-1,8);a(x(s,s))

उनके सुझाव के लिए होकी का शुक्रिया, जिसके कारण मुझे 6 बाइट बचाने में मदद मिली।

उदाहरण:

>> W = uint64(3732582711467756595)
W =
  3732582711467756595
>> S = uint8(10)
S =
   10
>> f(W,S)
ans =
||--||--||
--||--||--
--||--||--
||--||--||
||--||--||
--||--||--
--||--||--
||--||--||
||--||--||
--||--||--
— लुइस मेंडो
स्रोत
de2biआपको कुछ और पात्रों को बचाएगा ;-)
— होकी
@Hoki! धन्यवाद! मैंने इसके बारे में सोचा ... लेकिन यह परिणाम का एक अलग क्रम देता है
— लुइस मेंडू
हाँ, आपको उल्टा a='|-'करना होगा a='-|'। और उपयोगx=de2bi(typecast(W,'uint8'))+1;
— होकी
@ होकी मैं de2biकेवल 9-पद को स्थानांतरित करने के लिए फिट हुआ (उत्क्रमण के लिए प्रयुक्त)। एक बार फिर धन्यवाद!
— लुइस मेंडो
3

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

f(w,s)=(A=map(i->i=="1"?"-":"|",reshape(split(lpad(bin(w),64,0),""),8,8))';for i=1:s A=hcat(A,A)end;for i=1:s println(join(A[i>8?i%8:i,1:s]))end)

यह एक फ़ंक्शन बनाता है जो दो पूर्णांकों को स्वीकार करता है और प्रिंटआउट को प्रिंट करता है।

असंगठित + स्पष्टीकरण:

function f(w,s)
    # Convert w to binary, left-padded with zeros to length 64
    b = lpad(bin(w), 64, 0)

    # Create an 8x8 array of | and -
    A = transpose(map(i -> i == "1" ? "-" : "|", reshape(split(b, ""), 8, 8)))

    # Horizontally concatenate A to itself s times
    for i = 1:s
        A = hcat(A, A)
    end

    # Print the rows of A, recycling as necessary
    for i = 1:s
        println(join(A[i > 8 ? i % 8 : i, 1:s]))
    end
end

यह बहुत लंबा है और मुझे यकीन है कि इसे बहुत छोटा किया जा सकता है। इस पर काम करते हुए।

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

जे, 28 बाइट्स

'|-'{~]$"1]$8 8$_64{.#.inv@[

उपयोग:

   3732582711467756595 ('|-'{~]$"1]$8 8$_64{.#.inv@[) 10
||--||--||
--||--||--
--||--||--
||--||--||
||--||--||
--||--||--
--||--||--
||--||--||
||--||--||
--||--||--

स्पष्टीकरण (दाएं से बाएं):

#.inv@[   binary representation vector of S
_64{.     padded with 0-s from the right to length 64
8 8$      reshaped in an 8 by 8 matrix
]$"1]$    tiled to a W by W size
'|-'{~    select | or - based on matrix element values

इसे यहाँ ऑनलाइन आज़माएँ।

— randomra
स्रोत
2

पायथन, 77

lambda w,s:''.join('|-'[w>>~n/s%8*8+~n%s%8&1]+'\n'[~n%s:]for n in range(s*s))

प्रत्येक के s*sमूल्यों के लिए n:

  • Divmod के माध्यम से निर्देशांक की गणना करें (i,j)=(n/s,n%s)
  • के रूप में टाइलिंग में स्थान की गणना (i%8,j%8)
  • के रूप में उपयुक्त बिट स्थिति की गणना करें 8*(i%8)+(j%8)
  • उस बिट को सही स्थान के साथ wस्थानांतरित करके उस बिट को निकालें wऔर अंतिम बिट को साथ ले जाएं&1 ।
  • उस स्थिति में '| -' में से एक को मिलाएँ
  • जब भी हर पंक्ति के अंत में नई पंक्ति जोड़ें n%s==0

दरअसल, यह सब अंत में टाइलिंग पीछे की ओर हो जाता है, क्योंकि यह wअंत से पढ़ता है। हम इसके ~nस्थान पर उपयोग करके इसे ठीक करते हैंn । मैंने इसके बजाय एक पुनरावर्ती दृष्टिकोण की कोशिश की, लेकिन यह थोड़ा लंबा हो गया।

अभिव्यक्ति w>>~n/s%8*8+~n%s%8&1ऑपरेटर पूर्वता का एक चमत्कार है।

— XNOR
स्रोत
1

पायथन 2, 132 बाइट्स

निश्चित रूप से सबसे सुरुचिपूर्ण समाधान नहीं है, और यह सी से मुश्किल से कम है, लेकिन यह एक शुरुआत है। इनपुट को अल्पविराम से अलग किया गया है।

k,n=input()
k=[`['|-'[int(x)]for x in'{0:064b}'.format(k)]`[2::5][i*8:i*8+8]*n for i in range(8)]*n
for j in range(n):print k[j][:n]
— Kade
स्रोत
1

सी, 160 135 बाइट्स

i;main(s,v)char**v;{s=atoi(v[2]);for(;i++<s*s+s;)putchar(i%(s+1)?strtoull(v[1],0,10)&1ull<<63-(i/(s+1)*8+(i%(s+1)-1)%8)%64?45:'|':10);}

कुछ और गोल्फिंग यहां की जा सकती हैं और स्पष्टीकरण की आवश्यकता है, लेकिन मेरे पास इस समय समय नहीं है :)

Ungolfed:

i;

main(s,v)
char**v;
{
    s=atoi(v[2]);
    for(;i++<s*s+s;)
        putchar(i%(s+1) ? /* print dash or pipe, unless at end of row, then print newline */
            /* Calculating which bit to check based on the position is the tough part */
            strtoull(v[1],0,10) & 1ull << 63-(i/(s+1)*8+(i%(s+1)-1)%8)%64 ? /* If bit at correct index is set, print dash, otherwise pipe */
                45 /* dash */
                : '|' /* pipe */
            : 10); /* newline */
}
— कोल कैमरन
स्रोत
क्या आप "C, 100 बाइट्स" जैसे शीर्षक को प्रारूपित कर सकते हैं? इस तरह यह लीडरबोर्ड में बेहतर दिखाई देगा।
— अनुबिन नोब जूल
हाँ, इस बारे में खेद है।
— कोल कैमरन
1
मुझे आपके कोड को मेरे वातावरण पर सही ढंग से चलाने में परेशानी हो रही है। क्या आप किसी विशिष्ट विकल्प के साथ संकलन कर रहे हैं?
— अंख-मोर्पोर्क
@ dohaqatar7 ऐसा लगता है कि कुछ लिनक्स वातावरणों stdlib.hको स्पष्ट रूप से शामिल करने की आवश्यकता है। जब मैं CentOS पर परीक्षण किया था तो मुझे इसे शामिल करने के लिए मजबूर नहीं किया गया था (मुझे विश्वास है कि मैं क्या कर रहा था)। अब उबंटू पर, मैं इसे इस तरह संकलित किए बिना नहीं चला सकता:gcc -include stdlib.h w.c
— कोल कैमरन
समझ में आता है कि मैंने Ubuntu पर परीक्षण किया
— akh-morpork
1

पायथ, 31 30 बाइट्स

L<*QbQjbyyMcs@L"|-".[Z64jvz2 8

इनपुट दो लाइनों पर होना चाहिए, डब्ल्यू फिर एस ।

इसे यहाँ आज़माएँ

व्याख्या

L                              # define y(b):
  *Qb                          #   b, repeated Q (the second input) times
 <   Q                         #   cut to length Q

                        jvz2   # convert the first input to binary
                   .[Z64       # pad with 0's to length 64
             @L"|-"            # map the digits to the appropriate character
            s                  # convert the list of characters to a string
           c                 8 # chop into 8 strings
         yM                    # extend each string to the correct size
        y                      # extend the list of strings to the correct size
      jb                       # join with newlines
— Ypnypn
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.