दृश्य लंबी गुणा

Question

कुछ भी करने के लिए और गिनती के बिना दो पूर्णांकों के लिए लंबे गुणा करने का एक अच्छा तरीका है, जिसे कभी-कभी इंटरनेट के आसपास साझा किया जाता है। आप प्रत्येक संख्या के अंकों को 90 डिग्री के कोण पर दो संख्याओं के साथ, झुकी हुई रेखाओं के एक समूह के रूप में लिखते हैं। फिर आप बस उन अलग-अलग स्तंभों में चौराहों की गिनती कर सकते हैं जो उत्पन्न होते हैं। एक आरेख संभवतः इसे स्पष्ट करेगा। यहाँ गणना के लिए एक उदाहरण है 21 * 32:

यदि आप "दृश्य / चित्रमय लंबी गुणा" के लिए Google करते हैं, तो आपको बहुत अधिक उदाहरण मिलेंगे।

इस चुनौती में, आपको ASCII कला का उपयोग करके इन आरेखों को उत्पन्न करना है। उसी उदाहरण के लिए, आउटपुट इस तरह दिखेगा:

   \ /
    X /
 \ / X /
\ X / X
 X X / \ /
/ X X   X /
 / X \ / X
  / \ X / \
     X X
    / X \
     / \

कुछ उदाहरणों (नीचे देखें) से इन के लिए निर्माण नियमों का पता लगाना सबसे आसान है, लेकिन यहां कुछ विवरण हैं:

• इंटरसेक्टिंग सेगमेंट हैं X, लाइनों के नॉन-इंटरसेक्टिंग सेगमेंट हैं /या \।
• सबसे बाहरी चौराहों के बाद ठीक एक खंड होना चाहिए।
• विभिन्न अंकों से संबंधित चौराहों के बीच बिल्कुल एक खंड होना चाहिए। यदि शून्य-अंक हैं, तो इनका परिणाम लगातार /या \खंड होगा।
• आपको किसी भी सकारात्मक इनपुट (कम से कम कुछ उचित सीमा जैसे 2 ¹⁶ या 2 ³² ), और किसी भी अंक का समर्थन 0करना होगा 9। हालाँकि, आप मान सकते हैं कि वहाँ न तो अग्रणी है और न ही अनुगामी 0।
• आपको बाहरी प्रमुख व्हाट्सएप या खाली लाइनों का नेतृत्व या अनुगामी नहीं करना चाहिए।
• आप अनुगामी व्हाट्सएप प्रिंट कर सकते हैं लेकिन यह आरेख के अक्ष-संरेखित बाउंडिंग बॉक्स से अधिक नहीं होना चाहिए।
• आप वैकल्पिक रूप से एक एकल अनुगामी न्यूलाइन प्रिंट कर सकते हैं।
• आप चुन सकते हैं कि आप किस क्रम में दो इनपुट नंबर लेंगे। हालाँकि, यह आपको या तो अभिविन्यास के लिए मनमाने ढंग से संख्याओं का समर्थन करना चाहिए, इसलिए आप कुछ ऐसा नहीं चुन सकते हैं जैसे "बड़ी संख्या पहले दी गई है"।
• यदि आप एक स्ट्रिंग के रूप में इनपुट ले रहे हैं, तो आप दो संख्याओं के बीच किसी भी गैर-अंक विभाजक का उपयोग कर सकते हैं।

आप STDIN (या निकटतम विकल्प), कमांड-लाइन तर्क या फ़ंक्शन तर्क के माध्यम से इनपुट ले रहे हैं और STDOUT (या निकटतम विकल्प), फ़ंक्शन रिटर्न मान या फ़ंक्शन (आउट) पैरामीटर के माध्यम से परिणाम लिख सकते हैं।

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

उदाहरण

1*1
\ /
 X
/ \

2*61
 \ /
\ X /
 X X /
/ X X /
 / X X /
  / X X /
   / X X
    / X \ /
     / \ X
        X \
       / \

 45*1
         \ /
        \ X
       \ X \
      \ X \
     \ X \
      X \
   \ / \
  \ X
 \ X \
\ X \
 X \
/ \

21001*209
       \ /
        X /
       / X
      / / \
   \ / /   \ /
    X /     X /
 \ / X     / X /
\ X / \   / / X /
 X X   \ / / / X /
/ X \   X / / / X /
 / \ \ / X / / / X /
    \ X / X / / / X /
     X X / X / / / X /
    / X X / X / / / X
     / X X / X / / / \
      / X X / X / /
       / X X / X /
        / X X / X
         / X X / \
          / X X
           / X \
            / \

Comments

2 स्ट्रिंग पैरामीटर या सिर्फ एक स्ट्रिंग के साथ एक फ़ंक्शन और मुझे इसे अपने कोड में विभाजित करना होगा?

— edc65

@ edc65 दो तार या दो पूर्णांक पैरामीटर ठीक हैं।

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

Answer 1

पायथ - 79 बाइट्स

@ अलेक्सईबर्डिन के उत्तर का अनुवाद। शायद बहुत अधिक गोल्फ हो सकता है।

AzHmu++Gm1sH]Zd]Z,_zwK+lzlHJmm\ KK .e.eX@J+kY+-Yklz@" \/x"+byZHzjbmjk:d2_1:J1_2

इनपुट को दो नंबर के रूप में लेता है, न्यूलाइन अलग हो गया। स्पष्टीकरण जल्द ही आ रहा है।

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

Answer 2

अजगर, 303

def f(s):
    a,b=s.split('*')
    a,b=map(lambda l:reduce(lambda x,y:x+[1]*int(y)+[0],l,[0]),[reversed(a),b])
    n=sum(map(len,[a,b]))
    l=[[' ']*n for i in xrange(n)]
    for i,x in enumerate(a):
        for j,y in enumerate(b):
            l[i+j][j-i+len(a)]=r' \/x'[x+2*y]
    return '\n'.join(''.join(x[2:-1]) for x in l[1:-2])

मुझे लगता है कि यह पर्याप्त मानव-पठनीय है।
सत्यापन:

print '---'
print '\n'.join('"%s"'%x for x in f('21001*209').split('\n'))
print '---'
---
"       \ /            "
"        x /           "
"       / x            "
"      / / \           "
"   \ / /   \ /        "
"    x /     x /       "
" \ / x     / x /      "
"\ x / \   / / x /     "
" x x   \ / / / x /    "
"/ x \   x / / / x /   "
" / \ \ / x / / / x /  "
"    \ x / x / / / x / "
"     x x / x / / / x /"
"    / x x / x / / / x "
"     / x x / x / / / \"
"      / x x / x / /   "
"       / x x / x /    "
"        / x x / x     "
"         / x x / \    "
"          / x x       "
"           / x \      "
"            / \       "
---

Comments

बस कुछ त्वरित गोल्फ: reversedजैसे ही है [::-1], आप इंडेंटेशन को बचाने के लिए लूप की सामग्री को एक पंक्ति में रख सकते हैं, इससे len(a)+len(b)कम है sum(map(len,[a,b])), xrangeगोल्फिंग में उपयोग नहीं करते हैं , में जगह को ) forहटाया जा सकता है, और जब से आप हैं python2 का उपयोग करके, आप इंडेंटेशन में रिक्त स्थान और टैब को जोड़ सकते हैं।

— माल्टीसेन

बहुत धन्यवाद। ये 22 बाइट देते हैं। लेकिन मुझे नहीं लगता कि यह सबसे छोटा होगा। मैं अजगर को कोड नहीं करता, लेकिन मैंने 31-बाइट प्रोग्राम देखे हैं ... Btw, 303 की गिनती तब होती है जब हर 4-स्पेस को वास्तव में एक टैब द्वारा बदल दिया जाता है।

— एलेक्सी बर्डिन

यहाँ, मैं 276सरल वाक्य रचना गोल्फ से प्राप्त करने में सक्षम था : gist.github.com/Maltysen/e8231c0a9b585e2a4941

— माल्टीसेन

इसके अलावा, क्या आपको बुरा लगता है अगर मैं आपके प्रोग्राम को पाइथ में तब्दील कर दूं और इसे एक अलग उत्तर के रूप में पोस्ट करूं?

— माल्टसेन

आप e=enumerateशुरू में गोल्फ में 4 सेट कर सकते हैं

— sagiksp

Answer 3

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

L=a,b=[eval("+[0]+[1]*".join("0%s0"%x)[2:])for x in input().split()]
A,B=map(len,L)
for c in range(2,A+B-1):print((" "*abs(c-A)+" ".join(" \/X"[a[i-c]+2*b[i]]for i in range(max(0,c-A),min(c,B))))[1:A+B-2])

भाव काफी लंबे हैं इसलिए मुझे लगता है कि सुधार के लिए उचित मात्रा में जगह है, लेकिन फिर भी ...

एसटीडीआईएन के माध्यम से इनपुट स्पेस-अलग हो जाता है, जैसे

21 32
   \ /
    X /
 \ / X /
\ X / X  
 X X / \ /
/ X X   X /
 / X \ / X 
  / \ X / \
     X X  
    / X \
     / \

कुछ लाइनों पर एक संभावित अनुगामी स्थान है, लेकिन यह A+B-2सुनिश्चित करता है कि अनुगामी रिक्त स्थान के सभी बाउंडिंग बॉक्स के भीतर हैं।

Answer 4

सी #, 451 बाइट्स

void d(string s){var S=s.Split('*');int X=S[1].Select(c=>c-47).Sum(),Y=S[0].Select(c=>c-47).Sum(),L=9*(X+Y),A=1,B=L/3,i,j;var a=Range(0,L).Select(_=>new int[L]).ToArray();foreach(var c in S[1]){for(i=48;i<c;++i){for(j=-1;j<Y;++j)a[B-j][A+j]=1;A++;B++;}A++;B++;}A=1;B=L/3;foreach(var c in S[0]){for(i=48;i<c;++i){for(j=-1;j<X;++j)a[B+j][A+j]|=2;A++;B--;}A++;B--;}Write(Join("\n",a.Select(r=>Concat(r.Select(n=>@" /\X"[n]))).Where(r=>r.Trim().Any())));}

पठनीयता के लिए प्रारूपित, संदर्भ में कार्य:

using System.Linq;
using static System.Console;
using static System.Linq.Enumerable;
using static System.String;

class VisualMultiply
{
    static void Main(string[] args)
    {
        new VisualMultiply().d("21001*209");

        WriteLine();
    }

    void d(string s)
    {
        var S = s.Split('*');

        int X = S[1].Select(c => c - 47).Sum(), 
            Y = S[0].Select(c => c - 47).Sum(),
            L = 9 * (X + Y),
            A = 1,
            B = L / 3,
            i,
            j;

        var a = Range(0, L).Select(_ => new int[L]).ToArray();

        foreach (var c in S[1])
        {
            for (i = 48; i < c; ++i)
            {
                for (j = -1; j < Y; ++j)
                    a[B - j][A + j] = 1;
                A++;
                B++;
            }
            A++;
            B++;
        }

        A = 1;
        B = L / 3;
        foreach (var c in S[0])
        {
            for (i = 48; i < c; ++i)
            {
                for (j = -1; j < X; ++j)
                    a[B + j][A + j] |= 2;
                A++;
                B--;
            }
            A++;
            B--;
        }

        Write(Join("\n", a.Select(r => Concat(r.Select(n => @" /\X"[n]))).Where(r => r.Trim().Any())));
    }
}

बिटवाइज़ OR केवल मनोरंजन के लिए था, लेकिन इसके अलावा भी काम करेगा।

Answer 5

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

मुझे यकीन है कि एक समाधान है जो पंक्ति द्वारा आउटपुट पंक्ति बनाता है, गणित और x के साथ फ़िडलिंग, y निर्देशांक (x + y == k, xy == k ...)। लेकिन मैं अभी भी इसे कील नहीं कर सकता।

तो यहाँ एक समाधान है जो बस एक-एक करके रेखाएँ खींचता है।

परीक्षण करने के लिए फ़ायरफ़ॉक्स में स्निपेट चलाएँ।

F=(a,b)=>( // string parameters
  t=u=0,[for(v of a)t-=~v],[for(v of b)u-=~v],
  r=t+u,o=[...' '.repeat(r*r-r)],
  L=(x,y,n,z,m,c)=>{
    for(i=0;d=n[i++];)
      for(j=0;++x,y+=z,j++<d;)
        for(l=m+1,p=x+y*r-1-r;l--;p+=r-z,o[p-p%r-1]='\n')
          o[p]=o[p]>' '&&o[p]!=c?'X':c
  },
  L(u,0,a,1,u,'/'),
  L(0,u,b,-1,t,'\\'),
  o.join('')
)

// TEST

function test()
{
  O.innerHTML= F(A.value, B.value);
}

test();

<input id=A value=21001> * <input id=B value=209> <button onclick='test()'>-></button>
<pre id=O></pre>

Answer 6

कुलपति ++ (289)280

t(char*a){int i,j,k,r,c=1,e,A=0,B=0,*C,G[99],f,u;for(C=&A;c+48|(k=(c=(*(a+=c<1))---48)>0);G[2**(C=!(c+6)?&(B+=A):&(++*C))]=k**C);for(i=0;i<B*B;printf("\n%c"+!!j,32+15*((k=(c<(f=G[(c=i/B)+(j=i%B)+A+2]))*(j<f)*(f>A))+4*(r=(!!e*B>c+(e=G[A+j-c]))*(!!e*c>A-e-2)*(e<A)))+13*k*r),i++);

प्रयोग

#include  <stdio.h>
#include  <conio.h>

int t(char*);

int main(void)
{   char a[]="123*45";
    t((char*)a);
    getch();
    return 0;
}

int 
//-------- padded code ------
t(char*a){int i,j,k,r,c=1,e,A=0,B=0,*C,G[99],f,u;memset(G,0,396);for(C=&A;c+48|(k=(c=(*(a+=c<1))---48)>0);G[2**(C=!(c+6)?&(B+=A):&(++*C))]=k**C);for(i=0;i<B*B;printf("\n%c"+!!j,32+15*((k=(c<(f=G[(c=i/B)+(j=i%B)+A+2]))*(j<f)*(f>A))+4*(r=(!!e*B>c+(e=G[A+j-c]))*(!!e*c>A-e-2)*(e<A)))+13*k*r),i++);

//---------------------------
return 0;}

परिणाम

       \ /
      \ x /
     \ x x /
      x x x /
   \ / x x x
  \ x / x x \ /
   x x / x \ x /
\ / x x / \ x x /
 x / x x   x x x /
/ x / x \ / x x x /
 / x / \ x / x x x
  / x   x x / x x \
   / \ / x x / x \
      x / x x / \
     / x / x x
      / x / x \
       / x / \
        / x
         / \

• फ़ंक्शन एक एकल लूप को पुनरावृत्त करता है, और कुछ ज्यामितीय और एससीआई ट्रिफ़लिंग का उपयोग करता है।

Comments

किस ---48लिए है?

— लीजनमोनमल 978

@ LegionMammal978 कभी-कभी मैं चीजें लिखता हूं तो मैं यह भी भूल जाता हूं कि मैंने इसे वहां क्यों रखा था: डी वैसे भी कुछ और करने में व्यस्त है, जब मैं खत्म करता हूं, तो आपके लिए याद रखना; (क्या यह कोड आपके कंपाइलर में ठीक है)?

— अब्रिजम

@ LegionMammal978 यहां, विशिष्ट (वास्तविक) इंडेक्स पर एरेस कंटेंट को घटने से पहले 48 तक घटाया जाता है , आने वाले 48 वर्णों को घटाते हुए, फिर लूप (या

— एससीआई

४ representation "०" का

— अस्की

मैं अब देखता हूं, यह काम करता है ...)-- - 48)...।

— लीजनमोनमाल 978

Answer 7

कैनवस , 41 बाइट्स

（Ａ┬｛［１｝０｝┐）
⁷Ｌ├Ｘ⁷ｌＹø；｛³×？³ｙ³－╵ｘ＼╋
⁸⤢↔╶╶⁸ｎ

यहाँ यह कोशिश करो!

Answer 8

सी (329 बी)

int f(char*a){int i,j,r,k,c,h,o,e=15,m=99,A=0,B=0,*C,L[m][m],G[m],*g=G;for(C=&A;(c=*a-48)+48;C=!(c+6)?&B:&(*C+=(*g++=c+1)),a++);for(i=B-1,j=0;j<(r=A+B-1);i--,j++)for(k=0,o=4*!!((*(g-=!*g))---1);k<=*(C=(h=i<0)?&B:&A);k++)L[abs(i)+k][j+k-2*k*h]+=o/(3*h+1)*e;for(i=0;i<r*r;i++)printf("\n%c"+!!(i%r),((h=L[i/r][i%r])>e*4)?120:h+32);}

कोशिश करो

Comments

ऐसा लगता है कि हर वर्ण के बाद रिक्त स्थान के स्तंभ हैं, और नीचे के छोर पर अंतिम गैर-प्रतिच्छेद खंड गायब हैं। आप उल्टे क्रम में अंकों का भी उपयोग कर रहे हैं।

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

@ मार्टिनबटनर ने कल्पना की कि कोई इसे चंद्रमा पर कर रहा है और आप इसे दूरबीन द्वारा देख रहे हैं, जिस तरह से आपको आरेख का अनुभव करना चाहिए (-जोकिंग-मैं बाद में इसे समायोजित करूँगा)

— Abr001am

Answer 9

आर , 294 बाइट्स

d=do.call;r=outer;m=d(r,c(Map(function(y,w)d(c,c(lapply(y%/%10^rev(0:log10(y))%%10,function(z)c(0,rep(w,z))),0)),scan(),1:2),`+`))+1;p=matrix(" ",u<-sum(dim(m)),u);p[d(r,c(lapply(dim(m),seq),function(a,b)nrow(m)-a+b+u*(a+b-2)))]=c(" ","\\","/","X")[m];cat(apply(p,1,paste,collapse=""),sep="\n")

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

Answer 10

जेली , 58 बाइट्स

ŒDṙLN‘ƊṚị“\/X ”K€
L‘0xż1xⱮ$F
DÇ€Ḥ2¦+þ/µZJUṖ;J’⁶xⱮżÑṖḊẎḊ$€Y

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

व्याख्या

एक पूर्ण प्रोग्राम जो दो संख्याओं को दो पूर्णांकों की सूची के रूप में लेता है और एक स्ट्रिंग लौटाता है।

हेल्पर लिंक 1: मैट्रिक्स को घुमाएं

ŒD                        | get the diagonals
  ṙ                       | rotate left by
   LN‘Ɗ                   | minus num columns +1
       Ṛ                  | reverse order
        ị“\/X ”           | index into \/X
               K€         | join each with spaces

हेल्पर लिंक 2: पंक्ति और स्तंभ टेम्पलेट उत्पन्न करते हैं

L‘0x                      | 0 copied (num digits + 1) times
    ż                     | interleaved with
     1xⱮ$                 | 1 copied as specified by the digits
         F                | flattened

मुख्य लिंक

D                         | convert to decimal digits
 ǀ                       | call above link for each number
   Ḥ2¦                    | double the second one
      +þ/                 | outer product using +
         µ                | start a new monadic chain
          ZJUṖ;J’         | reversed range counting down
                          | the columns, followed by range
                            counting up the rows (without
                            duplicating 0 in the middle)
                   ⁶xⱮ    | that many spaces (to provide indents)
                      ż   | interleaved with
                       Ñ  | rotated matrix
                        ṖḊẎḊ$€ Y | remove blank rows and columns and join with newlines