41

आपका कार्य एक जादुई 8 ट्रेपेज़ियम का उत्पादन करना है:

        1 × 8 + 1 = 9
       12 × 8 + 2 = 98
      123 × 8 + 3 = 987
     1234 × 8 + 4 = 9876
    12345 × 8 + 5 = 98765
   123456 × 8 + 6 = 987654
  1234567 × 8 + 7 = 9876543
 12345678 × 8 + 8 = 98765432
123456789 × 8 + 9 = 987654321

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

code-golf kolmogorov-complexity

— rybo111
स्रोत

1

सम्बंधित। (थोड़ा ...)

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

मध्य रिक्त स्थान की आवश्यकता है, हाँ?

— वैल्यू इंक।

@ केविनलाउ-नहीं केनी यह है, लेकिन आप हमेशा एक विकल्प पोस्ट कर सकते हैं, भले ही यह महत्वपूर्ण हो।

— rybo111

यह 6 बाइट्स है जो बीच के 6 स्थानों के अनुरूप है, इसलिए नहीं, मुझे नहीं लगता कि यह पर्याप्त महत्वपूर्ण है।

— वैल्यू इंक

15

अजगर 2, 59 बाइट्स

a=i=1
exec"print'%9d x 8 +'%a,i,'=',a*8+i;i+=1;a=a*10+i;"*9

अंक aऔर iसमीकरण a * 8 + iअंकगणितीय रूप से उत्पन्न होते हैं। प्रत्येक पंक्ति iमें वृद्धि हुई है, और aअगले अंक के माध्यम से जोड़ा गया है a=a*10+i। उदाहरण के लिए, अगर a=12345, i=5है, तो iहो जाता है 6, इसलिए नए aहै 12345*10 + 6जो 123456।

स्ट्रिंग के बजाय संख्याओं के रूप में संग्रहीत करने से हमें समीकरण द्वारा दिए गए आरएचएस की गणना करने की सुविधा मिलती है a*8+i, जो स्ट्रिंग रिवर्सलिंग से कम है।

— XNOR
स्रोत

+1 यह देखने के लिए कि यह क्या है - एक योग जो उत्पन्न किया जा सकता है

— rybo111

7

वी , 37 बाइट्स

i¸ 1 X 8 + 1 = 98ñYp|Eylp^Xf+$ylp

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

इसमें अप्राप्य शामिल है, इसलिए यहां एक हेक्सडंप है:

00000000: 69c2 b820 3120 5820 3820 2b20 3120 3d20  i.. 1 X 8 + 1 = 
00000010: 391b 38c3 b159 707c 4579 6c70 015e 5866  9.8..Yp|Eylp.^Xf
00000020: 2b01 2479 6c70 18                        +.$ylp.

— DJMcMayhem
स्रोत

5

05AB1E , 32 31 30 28 बाइट्स

कोड:

TG9N-ð×NLJðN"x8+ÿ="€ðJžmN£J,

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं! ।

— अदनान
स्रोत

.cयहाँ प्रयोग करने योग्य नहीं है?

— मैजिक ऑक्टोपस Urn

@carusocomputing यह है, लेकिन यह चुनौती का सामना करता है।

— अदनान

आह… क्या टाइमस्टैम्प नहीं देखा था।

— मैजिक ऑक्टोपस Urn

5

PHP, 105 89 60 57 बाइट्स

मेरी पहली गोल्फ यहाँ कोशिश करो (manatwork और user55641 के लिए धन्यवाद)

for(;$i++<9;)printf("%9s x 8 + $i = %s
",$s.=$i,$s*8+$i);

59

for(;$i++<9;)printf("%9s x 8 + $i = %s
",$s.=$i,$t.=10-$i);

89 (मेरी अपनी कोशिश)

for(;@++$i<=9;){printf("%9s x 8 + %s = %s\n",join(range(1,$i)),$i,join(range(9,10-$i)));}

105 (पहले)

for($j='123456789';@$j[$i++];){printf("%9s x 8 + %s = %s\n",substr($j,0,$i),$i,strrev(substr($j,-$i)));}

— क्रिप्टो
स्रोत

1

एक बयान के आसपास ब्रेसिज़ की कोई आवश्यकता नहीं है। $ I अकेले बेहतर प्रारूप के बिना स्ट्रिंग में सीधे प्रक्षेपित करता है।

— मैनटवर्क

1

आप कुछ ट्रिक्स के साथ 23 और बाइट्स छोड़ सकते हैं: @ ++ $ i <= 9 से $ i ++ 9 बदलना 2 बाइट्स को बचाता है। आपको नोटिस को चुप कराने की आवश्यकता नहीं है क्योंकि वे निष्पादन को रोकते नहीं हैं और यदि आप चाहते हैं तो मानक पीपीसीजी नियमों के तहत आप stderr को अनदेखा कर सकते हैं। वास्तविक एनलाइन वर्ण में \ n को बदलने से बाइट बचती है। जॉइन (रेंज (...)) बिट्स को $ s में बदलना। = $ i और $ t। = 10- $ i 15 बाइट्स बचाता है। यह काम करता है क्योंकि असाइनमेंट असाइन किए गए मान को वापस करते हैं और गोल्फिंग php के लिए मैंने पाया सबसे मूल्यवान चाल है। अंतिम 5 बाइट्स मैनेटवर्क से ऊपर विस्तृत हैं

— user55641

1

के $t.=10-$iसाथ प्रतिस्थापित करके आप 2 और बाइट्स छोड़ सकते हैं $s*8+$i। tio.run/##K8go@G9jXwAk0/…

— 640KB

1

यह 59 बाइट्स है। और $s*8+$iइसके बजाय $t.=10-$iदो और बचाता है।

— टाइटस

5

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

VS9ss[*dK-9NSN" x 8 + "N" = "r9K

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

VS9ss[*dK-9NSN" x 8 + "N" = "r9K
VS9                                  # For N in 1..9
   s                                 # Join without delimiter
    s[                               # Reduce the array on + (flattens)
      *dK-9N                         # - Space, repeated K=(9-N) times
            SN                       # - The string sequence 1..N
              " x 8 + "              # - This string literal
                       N             # - N itself
                        " = "        # - This string literal
                             r9K     # - The string sequence 9..K

2 बाइट बचाने के लिए @FryAmTheEggman को धन्यवाद। 3 बाइट बचाने के लिए @KennyLau को धन्यवाद।

— Ven
स्रोत

sअंतरिक्ष में शामिल नहीं होता है - यह बिना परिसीमन के साथ जुड़ता है।

— isaacg

@ आइसाकग हह, और अब मैं सोच रहा हूं कि मैं एक बाइट को अंतरिक्ष के साथ जोड़कर बचा सकता हूं

— वेन

बाइट-काउंट एक ही होगा ।

— लीकेज नन

4

CJam, 39 38 36 बाइट्स

2 बाइट बचाने के लिए ऑप्टिमाइज़र का धन्यवाद।

9{)_,:)9Se[" x 8 + "@S'=S9_,fm4$<N}/

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

एक ही बाइट गिनती:

9{)_,:)9Se[]"x8+"+:\'=9_,f-Y$<]S*n}/

इसके लिए नवीनतम संस्करण की आवश्यकता है, इसे ऑनलाइन आज़माएं!

— मार्टिन एंडर
स्रोत

9

@ ऑप्टिमाइज़र उनके नाम पर रहता था, तब!

— 1963 में rybo111

4

पायथन 2, 87 84 78 75 बाइट्स

s="123456789"
n=1
exec'print"%9s"%s[:n],"x 8 + %s ="%n,s[::-1][:n];n+=1;'*9

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

पिछला संस्करण कुछ स्ट्रिंग मैजिक का उपयोग करता है।

R=range(1,10)
for n in R:print" "*(9-n)+`R`[1:n*3:3]+" x 8 + %d = "%n+`R`[-2:27-3*n:-3]

range(1,10)एक स्ट्रिंग के लिए कास्टिंग देता है [1, 2, 3, 4, 5, 6, 7, 8, 9], और यह अच्छा है क्योंकि प्रत्येक संख्या केवल एक अंक है। तो इससे स्ट्रिंग 123456789प्राप्त करना सरल है `range(1,10)`[1::3]। उलटी सीमा है `range(1,10)`[-2::-3]। फिर, केवल प्रत्येक पुनरावृत्ति को प्राप्त करने के लिए, मैं इसे उल्टा अंकों के लिए 3*nया तो 3*(9-n)( या 27-3*n) पर बंद कर देता हूं ।

— mbomb007
स्रोत

आप for n in range(1,10):print"%9s"%s[:n]+" x 8 + %s = "%n+s[::-1][:n]80 बाइट्स के लिए कर सकते हैं ।

— TheBikingViking

s="123456789";n=1;exec'print"%9s"%s[:n],"x 8 + %s ="%n,s[::-1][:n];n+=1;'*9तीन और बचाता है! डाउन टू 75.

— लिन

अच्छा, मदद के लिए धन्यवाद! बहुत बुरा मुझे दूसरी बार डबल-स्लाइस करना पड़ा ...

— mbomb007

4

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

printf"%9s x 8 + $_ = %s
",$@.=$_,$_+8*$@for 1..9

प्रयोग

perl -e 'printf"%9s x 8 + $_ = %s
",$@.=$_,$_+8*$@for 1..9'

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

4

रूबी, 77 73 65 60 बाइट्स

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

@Manatwork से मेजर की वापसी

@Xsot से एक और ओवरहाल

a=i=0;9.times{puts"%9d x 8 + %d = %d"%[a=a*10+i+=1,i,a*8+i]}

— मूल्य स्याही
स्रोत

प्रारूप स्ट्रिंग के साथ छोटा लगता है puts'%9d x 8 + %d = %d'%[k=[*1..i]*'',i,k.to_i*8+i]:।

— मैनटवर्क

(1..9).map→1.upto(9)

— मैनटवर्क

आह, मुझे पता नहीं है कि इस %9dतरह के पैड पूर्णांक के लिए एक प्रारूपण विकल्प के रूप में क्या है

— वैल्यू इंक

60:a=i=0;9.times{puts"%9d x 8 + %d = %d"%[a=a*10+i+=1,i,a*8+i]}

— xsot

@xsot यह बहुत अच्छा है! शुरुआती संख्या की गणना करने के बारे में नहीं सोचा था।

— वैल्यू इंक

4

जावा 10, 151 133 130 129 126 110 बाइट्स

v->{String p="\n",r="";for(int n=123456789,i=9;i>0;n/=10,p+=" ")r=p+n+" x 8 + "+i+" = "+(n*8+i--)+r;return r;}

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

स्पष्टीकरण:

v->{                   // Method with empty unused parameter and String return-type
  String p="\n",       //  Prefix-String, starting at a newline
         r="";         //  Result-String, starting empty
  for(int n=123456789, //  Multiply-number, starting at 123456789
      i=9;i>0          //  Loop `i` in the range [9, 0):
      ;                //    After every iteration:
       n/=10,          //     Remove the last digit from the integer
       p+=" ")         //     Append a space after the prefix
    r=...+r;           //   Prepend the following to the result-String:
      p                //    The prefix-String
      +n               //    Followed by the integer
      +" x 8 + "       //    Followed by the literal String " x 8 + "
      +i               //    Followed by the loop-index `i`
      +" = "           //    Followed by the literal String " = "
      +(n*8+i--)       //    Followed by the result of that equation
  return r;}           //  Return the result-String

— केविन क्रूज़सेन
स्रोत

1

मुझे लगता है कि आप xगुणन चिह्न के बजाय बाइट्स को बचा सकते हैं ।

— wizzwizz4

1

आप लूप से आरंभ sकरने "\n"और हटाने "\n"+से कुछ बाइट्स बचा सकते हैंfor

— क्लिफरॉट

@ wizzwizz4 धन्यवाद। पता होना चाहिए था ×1 की बजाय 2 बाइट्स x..

— केविन क्रूज़सेन

क्या आप sप्रत्येक पुनरावृत्ति पर परिणाम के साथ नहीं जोड़ रहे हैं ?

— क्लिफरॉट

मुझे पता है कि यह पुराना है, लेकिन क्या आप इसके return oबजाय नहीं कर सकते System.out.print(o)? इसके अलावा, आप जावा 10 में बदल सकते हैं varऔर लैम्बदास के साथ बचा सकते हैं

— अज्ञानता

3

सी, 74 बाइट्स

d(i,n){for(i=n=1;i<10;n=++i+n*10)printf("%9d x 8 + %d = %d\n",n,i,n*8+i);}

— anatolyg
स्रोत

3

सी #, 113 बाइट्स

void f(){for(int n=1,i=1;i<10;n=10*n+ ++i)Console.WriteLine(new string(' ',9-i)+n+" x "+"8 + "+i+" = "+(n*8+i));}

यदि आपके पास इस समाधान को सुधारने के लिए कुछ भी है तो साझा करने के लिए स्वतंत्र महसूस करें।

— ScifiDeath
स्रोत

आप किसी स्थान को हटाकर 1 बाइट बचा सकते हैं: ;n=10*n+ ++iइन-लूप को बदला जा सकता है ;n=++i+10*n। साथ ही +" x "+"8 + "+इसे बदला जा सकता है +" x 8 + "+। 3 बाइट्स बचाने के लिए।

— केविन क्रूज़सेन

void f () {के लिए (int n = 1, i = 1; मैं <10; n = ++ i + 10 * n) कंसोल। क्राइटलाइन ($ "{नया स्ट्रिंग ('', 9-आई)} {n } x 8 + {i} = {(n * 8 + i)} ");} ------------ आपको बाइट से बचाया!

— downrep_nation

3

बैच, 117 बाइट्स

@echo off
set a=         12345678987654321
for /l %%i in (1,1,9)do call echo %%a:~%%i,9%% x 8 + %%i = %%a:~17,%%i%%

हां, यह कि एक पंक्ति पर 16% संकेत हैं; यह आपके लिए बैच है!

— नील
स्रोत

2

हास्केल, 92 बाइट्स

s=(show=<<)
[1..9]>>= \x->([x..8]>>" ")++s[1..x]++" x 8 + "++s[x]++" = "++s[9,8..10-x]++"\n"

यह काम किस प्रकार करता है:

s=(show=<<)                   -- helper function that turns a list of numbers into
                              -- a string without delimiters, e.g. [1,2] -> "12"

[1..9]>>=                     -- for each number 1 to 9
     ([x..8]>>" ")            -- take length of [x..8] copies of a space
     s[1..x]                  -- the digits from 1 to x
     " x 8 + "                -- a string literal
     s[x]                     -- the digit of x
     " = "                    -- another string literal
     s[9,8..10-x]             -- the digits from 9 down to 10-x
     "\n"                     -- an a newline

— nimi
स्रोत

2

रेटिना , 66 बाइट्स

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है। अग्रणी लाइनफीड महत्वपूर्ण है।


123456789!9 = 987654321
+`^((.)+)\B.!.(.+).
 $1!$2$3¶$&
!
 x 8 +

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

— मार्टिन एंडर
स्रोत

2

Pyke, 30 29 बाइट्स

9Fd*~utj+9<\x8\+9i-\=ji>_dJ)X

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

9F                         )  -  for i in range(9):
  d*                          -       " " * i
        +                     -      ^ + V
       j                      -       j = V
    ~ut                       -        "123456789"
         9<                   -     ^[:9]
           \x8\+9i-\=         -    [^, "x", 8, "+", (9-i), "=", V]
                        _     -     reversed(V)
                     ji>      -      j[i:]
                         dJ   -   " ".join(^)
                            X - print(reversed(^))

— नीला
स्रोत

2

PowerShell v2 +, 85 64 58 57 52 बाइट्स

8..0|%{" "*$_+-join(1..++$i+" x 8 + $i = "+9..++$_)}

8..0|%{...}रेंज ऑपरेटर के माध्यम से 8 से 0 तक लूप । प्रत्येक पुनरावृत्ति, हम एक स्ट्रिंग संघनन (रिक्त स्थान की उचित संख्या " "*$_) से मिलकर आउटपुट करते हैं , साथ ही एक -joinएड स्ट्रिंग ( 1पूर्व-वृद्धि किए गए हेल्पर संख्या से एक सीमा ++$i, प्लस मध्य बिट " x 8 + $i = ", प्लस अंतिम 9संख्या से वर्तमान संख्या $_पूर्व तक -incremented)।

यहां एक बड़ी चाल यह है कि हम टाइपकास्टिंग के लिए "बाएं-वरीयता" का लाभ उठाते हैं, जो हमें -joinपरेंस के अंदर एक साथ "एड" जोड़ने की अनुमति देता है , जिसका अर्थ है कि हम केवल एक -joinऑपरेटर का उपयोग करते हैं ।

उदाहरण

PS C:\Tools\Scripts\golfing> .\magical-8-trapezium.ps1
        1 x 8 + 1 = 9
       12 x 8 + 2 = 98
      123 x 8 + 3 = 987
     1234 x 8 + 4 = 9876
    12345 x 8 + 5 = 98765
   123456 x 8 + 6 = 987654
  1234567 x 8 + 7 = 9876543
 12345678 x 8 + 8 = 98765432
123456789 x 8 + 9 = 987654321

— AdmBorkBork
स्रोत

4

%{क्या आपकी आंखें ठीक हैं?

— 19amp में gcampbell

@gcampbell यदि आपकी आंखें ऐसी दिखती हैं, तो आप भी डूब जाएंगे।

— AdmBorkBork

इस बात पर निर्भर करता है कि आपका फ़ॉन्ट कैसे पेरेंट को प्रस्तुत करता है

— 19amp में gcampbell

2

MATL , 38 36 35 बाइट्स

9:"9@-Z"@:!V' x 8 + '@VO61O58@:-v!D

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

— लुइस मेंडो
स्रोत

2

जे, 51 बाइट्स

(|."1|.\p),.' x 8 + ',"1]p,.' = ',"1]\|.p=:u:49+i.9

स्ट्रिंग बनाता है 123456789और फिर आउटपुट बनाने के लिए उपसर्गों और प्रत्ययों पर काम करता है।

प्रयोग

   (|."1|.\p),.' x 8 + ',"1]p,.' = ',"1]\|.p=:u:49+i.9
        1 x 8 + 1 = 9        
       12 x 8 + 2 = 98       
      123 x 8 + 3 = 987      
     1234 x 8 + 4 = 9876     
    12345 x 8 + 5 = 98765    
   123456 x 8 + 6 = 987654   
  1234567 x 8 + 7 = 9876543  
 12345678 x 8 + 8 = 98765432 
123456789 x 8 + 9 = 987654321

— मील की दूरी पर
स्रोत

2

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

नई repeatपद्धति का लाभ उठाते हुए , बैकटिक्स और टेंपलेटिंग ...

i=10;for(y="";--i;)console.log(`${" ".repeat(i)+(y+=(x=10-i))} x 8 + ${x} = ${y*8+x}\n`)

— WallyWest
स्रोत

अच्छा काम भाई, आप कुछ खाली स्थान हटाएं और उपयोग करने के लिए विचार करना चाहिए alertबजाय console.log, यह कुछ बाइट्स बचा सकता है!

— चाऊ गिएंग

यह देखते हुए कि मैंने आधी रात से पहले ही यह उत्तर दे दिया था कि मैं आधी नींद के करीब था ... मैं जल्द ही इस पर अपडेट पोस्ट करूंगा। LOL

— वैलीवेस्ट

2

आर, 107 103 बाइट्स

a=1;for(i in 2:10){cat(rep("",11-i),paste(a,"x",8,"+",(i-1),"=",strtoi(a)*8+(i-1)),"\n");a=paste0(a,i)}

अघोषित:

a=1

for(i in 2:10)
    cat(rep("",11-i),paste(a,"x",8,"+",(i-1),"=",strtoi(a)*8+(i-1)),"\n")
    a=paste0(a,i)

परिणाम :

        1 x 8 + 1 = 9 
       12 x 8 + 2 = 98 
      123 x 8 + 3 = 987 
     1234 x 8 + 4 = 9876 
    12345 x 8 + 5 = 98765 
   123456 x 8 + 6 = 987654   
  1234567 x 8 + 7 = 9876543 
 12345678 x 8 + 8 = 98765432 
123456789 x 8 + 9 = 987654321

— फ़्रेडरिक
स्रोत

96 बाइट्स

— Giuseppe

2

एपीएल (डायलॉग यूनिकोड) , 61 52 39 बाइट्स ^{एसबीसीएस}

↑(⍳9)((¯9↑↑),' x 8 +',⊣,'= ',↑∘⌽)¨⊂1↓⎕D

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

-9 बाइट्स में 10⊥कटौती के बजाय संख्या को पार्स करने के लिए चाल का उपयोग करके । -13 के लिए @ Adám को धन्यवाद!

स्पष्टीकरण:

↑    ((¯9↑↑),' x 8 +',⊣,'= ',↑∘⌽)¨⊂1↓⎕D
                                     ⎕D  ⍝ Numbers from 0 to 9
                                   1↓    ⍝ Drop the 0
 (⍳9)(                          )¨⊂      ⍝ Do 9 times, N=current
                             ↑∘⌽         ⍝ Reverse the string (9..1) and cut off N elements
                      ⊣                  ⍝ N itself
      (   ↑)                             ⍝ Drop N elements off the 1..9 string...
      (¯9↑ )                             ⍝ ...then pad it back with spaces
            ,' x 8 +', ,'= ',            ⍝ Join with a few constant strings
↑                                        ⍝ Format

— Ven
स्रोत

1

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

_=>[...Array(9)].map((n,i)=>`${n="        123456789".substr(i,9)} x 8 + ${++i} = ${n*8+i}`).join`\n`
_=>".........".replace(/./g,(n,i)=>`${n="        123456789".substr(i,9)} x 8 + ${++i) = ${n*8+i}\n`)

जहां \nएक शाब्दिक न्यूलाइन चरित्र का प्रतिनिधित्व करता है। दूसरा संस्करण एक अनुगामी न्यूलाइन को आउटपुट करता है। मैं संख्याओं के लिए एक सूत्र के साथ आया ('1'.repeat(9-i)+0+i)/9था लेकिन पैडिंग इस तरह से करना आसान था।

— नील
स्रोत

1

ब्रेनफक , 232 बाइट्स

++++++++[->+>+>+++++[->+>+>+>+>+>+++<<<<<<]>->>+>++>+++<<<<<<<<]>++>+>>>+++>>>---<<<<<<[-[-<<+>>>>.<<]>+[-<+>>>>+.<<<]>.>>>>>.<<<<<.>>>.<<<.>.<.>>.<<.>>>>.<<<<.<<<<[->>>+>>>+<<<<<<]>>[-<<+>>>>>>.-<<<<]>[->>>-<<<<+>]<<<[->>>+<<<]>.>]

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

बहुत आगे गोल्फ हो सकता है ...

— लीक नन
स्रोत

1

जावास्क्रिप्ट (बाहरी पुस्तकालय का उपयोग करके) (143 बाइट्स)

n=>_.Range(1,9).WriteLine(v=>_.Range(0,10-v).Write("",x=>" ")+_.Range(1,v).Write("")+" x 8 + " + v + " = "+_.Range(10-v,v).Reverse().Write(""))

लिंक ऑफ लिब: https://github.com/mvegh1/Enumerable/

कोड की व्याख्या: रेंज 1 से 9 बनाएं, और प्रत्येक मान के लिए, जटिल विधेय के अनुरूप एक पंक्ति लिखें। विधेय को वर्तमान पूर्णांक मान पारित किया जाता है, और कई रिक्त स्थान बनाने के लिए 10-currentValue तत्वों की एक सीमा बनाता है। उन रिक्त स्थान को रेखा के सूत्र भाग के साथ समतल किया जाता है, और फिर सीमा के तत्वों की संख्या को उल्टे क्रम में, दृश्यपटल के रूप में मिलान करने वाले सीमा के साथ जोड़ा जाता है।

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

— applejacks01
स्रोत

1

05AB1E , 24 बाइट्स

9Lε©LJ'x8'+®'=T®L-Jðý}.c

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

चुनौती से एक नए संस्करण का उपयोग करता है, जिसे अब अनुमति है।

— आउटगोल्फर को एरिक करें
स्रोत

— केविन क्रूज़सेन

@ केविनक्रूजसेन एह, मैं आम तौर पर उस तरह के पुराने उत्तरों को "अपडेट" नहीं करता। इसके अलावा, "नया संस्करण" पूरी तरह से अलग भाषा (अलग कार्यान्वयन) है।

— आउटगोल्फर

1

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

９｛Ｒ⤢x∙8∙+¹=¹◂±ｍ） ＊］ｒ

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

— dzaima
स्रोत

1

VBA (एक्सेल), 51 बाइट्स

तत्काल विंडो का उपयोग करना

For z=1To 9:a=a &z:?Spc(9-z)a" x 8 +"z"="a*8+z:Next

— remoel
स्रोत

0

k (77 बाइट्स)

शायद थोड़ा और छोटा किया जा सकता था

-1@'((|t)#\:" "),'(t#\:n),'" x 8 + ",/:n,'" = ",/:(t:"I"$'n)#\:|n:"123456789";

उदाहरण:

k)-1@'((|t)#\:" "),'(t#\:n),'" x 8 + ",/:n,'" = ",/:(t:"I"$'n)#\:|n:"123456789";
         1 x 8 + 1 = 9
        12 x 8 + 2 = 98
       123 x 8 + 3 = 987
      1234 x 8 + 4 = 9876
     12345 x 8 + 5 = 98765
    123456 x 8 + 6 = 987654
   1234567 x 8 + 7 = 9876543
  12345678 x 8 + 8 = 98765432
 123456789 x 8 + 9 = 987654321

— skeevey
स्रोत

0

गोल्फलुआ, 56 वर्ण

p=""~@i=1,9p=p..i; w(S.q("%9s x 8 + %d = "..p*8+i,p,i))$

नमूना रन:

bash-4.3$ golflua -e 'p=""~@i=1,9p=p..i; w(S.q("%9s x 8 + %d = "..p*8+i,p,i))$'
        1 x 8 + 1 = 9
       12 x 8 + 2 = 98
      123 x 8 + 3 = 987
     1234 x 8 + 4 = 9876
    12345 x 8 + 5 = 98765
   123456 x 8 + 6 = 987654
  1234567 x 8 + 7 = 9876543
 12345678 x 8 + 8 = 98765432
123456789 x 8 + 9 = 987654321

— आदमी काम पर है
स्रोत

एक जादुई 8 ट्रेपेज़ियम आउटपुट

अजगर 2, 59 बाइट्स

वी , 37 बाइट्स

05AB1E , 32 31 30 28 बाइट्स

PHP, 105 89 60 57 बाइट्स

59

89 (मेरी अपनी कोशिश)

105 (पहले)

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

CJam, 39 38 36 बाइट्स

पायथन 2, 87 84 78 75 बाइट्स

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

प्रयोग

रूबी, 77 73 65 60 बाइट्स

जावा 10, 151 133 130 129 126 110 बाइट्स

सी, 74 बाइट्स

सी #, 113 बाइट्स

बैच, 117 बाइट्स

हास्केल, 92 बाइट्स

रेटिना , 66 बाइट्स

Pyke, 30 29 बाइट्स

PowerShell v2 +, 85 64 58 57 52 बाइट्स

उदाहरण

MATL , 38 36 35 बाइट्स

जे, 51 बाइट्स

प्रयोग

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

आर, 107 103 बाइट्स

एपीएल (डायलॉग यूनिकोड) , 61 52 39 बाइट्स एसबीसीएस

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

ब्रेनफक , 232 बाइट्स

जावास्क्रिप्ट (बाहरी पुस्तकालय का उपयोग करके) (143 बाइट्स)

05AB1E , 24 बाइट्स

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

VBA (एक्सेल), 51 बाइट्स

k (77 बाइट्स)

गोल्फलुआ, 56 वर्ण

एपीएल (डायलॉग यूनिकोड) , 61 52 39 बाइट्स ^{एसबीसीएस}