इनपुट:

दो दशमलव पूर्णांक mऔर nवह क्रमशः तालिका की पंक्तियों और स्तंभों की संख्या देते हैं। mऔर n1 से अधिक या बराबर हैं।

आउटपुट:

HTML में एक तालिका जिसमें m रो और n कॉलम हैं।

तालिका को आपकी पसंद के आधुनिक ब्राउज़र द्वारा प्रदर्शित किया जाना चाहिए। अधिकांश ब्राउज़र सब कुछ ठीक से प्रदर्शित करेंगे भले ही टैग बंद न हों। उचित इंडेंटेशन और रिक्ति वैकल्पिक है।

प्रत्येक सेल में कम से कम एक (गैर-व्हाट्सएप) प्रिंट करने योग्य चरित्र होना चाहिए।

पहली पंक्ति के सेल को <th>टैग का उपयोग करना चाहिए, जबकि निम्नलिखित लाइनों के लोगों को <td>टैग का उपयोग करना चाहिए ।

जीत की स्थिति:

यह कोड-गोल्फ है इसलिए प्रत्येक भाषा की जीत के लिए सबसे छोटा स्रोत-कोड है।

इनपुट उदाहरण:

2 3

आउटपुट उदाहरण:

<table>
 <tr>
   <th>A</th>
   <th>A</th>
   <th>A</th>
 </tr>
 <tr>
   <td>A</td>
   <td>A</td>
   <td>A</td>
 </tr>
</table>

या: <table><tr><th>A<th>A<th>A<tr><td>A<td>A<td>A

code-golf code-generation

— आलू
स्रोत

टिप्पणियाँ विस्तारित चर्चा के लिए नहीं हैं; इस वार्तालाप को बातचीत में स्थानांतरित कर दिया गया है ।

— मेगो

7

एपीएल (Dyalog यूनिकोड) के साथ MiServer 3.0 , 31 30 बाइट्स ^SBCS

पूरा कार्यक्रम। दो-तत्व सूची के लिए संकेत स्टड [m,n]और सख्त XHTML को stdout में प्रिंट करता है।

(⎕NEW _.Table((⎕⍴0)⍬1)).Render

उदाहरण सत्र:

      )xload C:\Users\Adam.DYALOG\Documents\MiServer\miserver.dws
C:\Users\Adam.DYALOG\Documents\MiServer\miserver.dws saved Wed Mar  7 17:19:40 2018
      Load ''
Development environment loaded
MiSite "C:/Users/Adam.DYALOG/Documents/MiServer/MS3/" loaded
      (⎕NEW _.Table((⎕⍴0)⍬1)).Render
⎕:
      2 3
<table id="id691498143"><thead><tr><th>0</th><th>0</th><th>0</th></tr></thead><tbody><tr><td>0</td><td>0</td><td>0</td></tr></tbody></table>

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

स्पष्टीकरण:

(… ).Render निम्न HTML तत्व प्रदान करें:

⎕NEW _.Table (... ) निम्नलिखित मापदंडों के साथ एक नई तालिका:

(... ) ⍬ 1 निम्नलिखित सामग्री, कोई विशेष स्टाइल नहीं, 1 हेडर पंक्ति:

⎕⍴0 मूल्यांकन किया गया इनपुट जीरो शून्य (यानी एक एम-पंक्ति, शून्य स्तंभ मैट्रिक्स)

— एडम
स्रोत

6

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

2 बाइट्स @RickHitchcock की बदौलत सहेजे गए

करी सिंटैक्स में इनपुट लेता है (m)(n)।

m=>n=>'<table>'+(g=c=>'<tr>'+`<t${c}>A`.repeat(n))`h`+g`d`.repeat(m-1)

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

डेमो

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

f=

m=>n=>'<table>'+(g=c=>'<tr>'+`<t${c}>A`.repeat(n))`h`+g`d`.repeat(m-1)

O.innerHTML = f(2)(3)

<div id=O></div>

स्निपेट का विस्तार करें

— Arnauld
स्रोत

5

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

lambda m,n:'<table><tr>'+'<th>A'*n+('<tr>'+'<td>A'*n)*~-m

इसे ऑनलाइन आज़माएं! मान लिया गया mकि शून्य नहीं है।

— लिन
स्रोत

5

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

<ŗ>
table⁸ｏ╶［tr⁸⁶｛¹１≡╵dh＠t×⁸；｝］

यहाँ कोशिश करो! या यह कल्पना की कोशिश करो!

दुभाषिया में 2 कीड़े (ಠ_ಠ) को ठीक करने के बाद, 30 बाइट्स भी काम करते हैं

— dzaima
स्रोत

3

जावास्क्रिप्ट, 65 बाइट्स

f=(m,n)=>m?f(--m,n)+'<tr>'+`<t${m?'d':'h'}>x`.repeat(n):'<table>'

document.write(f(4,3));

स्निपेट का विस्तार करें

— l4m2
स्रोत

प्रत्यावर्तन। अच्छा!

— माज़ी

2

05AB1E , 30 बाइट्स

’<…È>’sF"<tr>"„hdNĀè"<tÿ>A"I×J

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

व्याख्या

’<…È>’                           # push "<table>"
      sF                         # no-of-rows times do:
        "<tr>"                   # push "<tr>"
              „hd                # push "hd"
                 NĀ              # push the iteration counter truthified
                   è             # index into the 2-char string with this
                    "<tÿ>A"      # insert the result into the string "<tÿ>A" instead of ÿ
                           I×    # repeat this string no-of-columns times
                             J   # join the stack to a single string

— Emigna
स्रोत

2

स्टेक्स , 28 बाइट्स

üÉ$♠═?S┼╪├8°‼←sí☼←T≡┴╜ô‼\↑0ⁿ

इसे चलाएं और डीबग करें

अनपैक्ड, अनगुल्फेड और टिप्पणी की गई, यह इस तरह दिखता है।

"<table>"P  print "table"
"<th>A"*    "<th>A" repeated specified number of times
,D          repeat the rest of the program specified number of times
  "<tr>"p   print "<tr>" with no newline
  Q         print top of stack without popping
  .hd|t     replace "h" with "d"

इसको चलाओ

— पुनरावर्ती
स्रोत

2

जावा 10, 139 133 102 बाइट्स

m->n->{var r="<table>";for(int j=0,i;j++<m;)for(r+="<tr>",i=n;i-->0;r+=j<2?"<th>A":"<td>B");return r;}

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

स्पष्टीकरण:

n->m->{                  // Method with two integer parameters and String return-type
  var r="<table>";       //  Result-String, starting at "<table>"
  for(int j=0,i;j++<m;)  //  Loop `j` over the rows in the range [0, `m`)
    for(r+="<tr>",       //   Append "<tr>" to the result
        i=n;i-->0;       //   Inner loop `i` over the columns in the range [`n`, 0)
      r+=j<2?            //    If `j` is 1 (first iteration):
          "<th>A"        //     Append "<th>A" to the result
         :               //    Else:
          "<td>B");      //     Append "<td>B" to the result
  return r;}             //  Return the result

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

मुझे लगता है कि थोड़ा टाइपो है, आपने दो बार "वें" लिखा।

— आलू

@ आलू आह, आप सही कह रहे हैं। कोड स्वयं और TIO- लिंक सही थे, लेकिन मेरे स्पष्टीकरण में एक टाइपो था। अभी तय होना चाहिए, धन्यवाद।

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

(m,n)->{var l="<tr>";for(;n-->0;)l+="<td>A";var s="<table>"+l.replace('d','h');for(;--m>0;)s+=l;return s;}(106 बाइट्स) मुझे यह एक दिलचस्प लगा, लेकिन इसके लायक नहीं कि आपने अपना वर्तमान स्कोर दिया। तुम शायद यहाँ अपने विचारों का उपयोग कर थोड़ा जवाब दे सकते हो जैसे कि परिवर्तनशील m।

— ओलिवियर ग्रेजायर

@ ओलिवियरग्रॉइगर मैं शुरू में एक परिवर्तनीय था m, लेकिन <th>/ <td>मतभेदों के कारण यह बात नहीं होगी। मुझे अभी भी यह जांचने की आवश्यकता है कि क्या यह बाहरी लूप का पहला पुनरावृत्ति है, जिस स्थिति में मुझे दोनों की आवश्यकता है jऔर m, और मुझे आंतरिक लूप को कई बार करने की आवश्यकता है, जिस स्थिति में मुझे ज़रूरत है iऔर n। इसके बजाय 0 से ऊपर जाने और जाँच करने के बाद j<2मैं पीछे की ओर जा सकता था और जाँच कर सकता था i>m-2, लेकिन यह -1 के बजाय +1 बाइट होगा। हालांकि, दो अलग-अलग छोरों का उपयोग करने का आपका तरीका परिवर्तनीय है mऔर nवास्तव में दिलचस्प है। :)

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

2

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

-4 ngn के लिए धन्यवाद।

पूरा कार्यक्रम। दो-तत्व सूची [एम, एन] के लिए स्टड को संकेत देता है और स्टडआउट को अशुद्ध टैग प्रिंट करता है।

'<table>',∊'<tr>',⍤1{'d'}@3⍀⎕⍴⊂'<th>A'

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

⊂'<th>A' इसे पूरी तरह से व्यवहार करने के लिए इस स्ट्रिंग को संलग्न करें

⎕⍴ आयामों के लिए त्वरित और चक्रीय r है कि आकार के एक मैट्रिक्स के लिए एकल कक्ष eshape

…⍀ संचयी रूप से प्रत्येक ऊर्ध्वाधर जोड़ी कोशिकाओं के बीच निम्न फ़ंक्शन डालें:

{'d'}@3 ऊपरी सेल की उपेक्षा करें; dबॉटम सेल में तीसरे स्थान पर जगह

'<tr>',⍤1 इस पंक्ति को प्रत्येक पंक्ति में प्रस्तुत करें

∊ ϵ nlist (समतल)

'<table>', इस स्ट्रिंग को रोकें

— एडम
स्रोत

'd'⎕R'h'->'h'@3

— ngn

(⊂'<tr>'),-> '<tr>',⍤1और ...@1->...⍀

— ngn

@ सभी किया। धन्यवाद। प्रासंगिक ।

— शाम

2

सी (जीसीसी) , 107 99 98 97 बाइट्स

i;f(x,y){char s[]="<th>A";for(puts("<table><tr>");x--;s[2]=96+puts("<tr>"))for(i=y;i--;)puts(s);}

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

-8 बाइट्स आलू के लिए धन्यवाद

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

sसरणी के रूप में एक नहीं सरणी एक सूचक अन्यथा यह संपादन योग्य नहीं होगा (तो हम विज्ञापन में पहले ज सेट) घोषित किया जाना है। यदि आपका क्लोजिंग टैग सही है, तो अधिकांश ब्राउज़र भी परवाह नहीं करते हैं, इसलिए हम सभी टैगों को बंद कर देते हैं </t>।

— LambdaBeta
स्रोत

यदि आप </t>दो बार और -8 बाइट्स को हटाते हैं तो भी ठीक काम करता है ।

— आलू

यदि आप नई पंक्ति को आंतरिक लूप में आउटपुट करना स्थानांतरित करते हैं, तो आप 4 और बाइट्स को बंद कर सकते हैं (साथ ही, यह एक खाली पंक्ति से बचा जाता है): इसे ऑनलाइन आज़माएं!

— एरिकएफ

2

आर , 73 बाइट्स

function(n,m)cat("<table><tr>","<th>A"<m,c("<tr>","<td>A"<m)<n-1)
"<"=rep

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

एक गंदे हैक के साथ 7 बाइट्स सहेजे गए - "रेप" को "<" द्वारा बदलें।

— Jayce
स्रोत

1

हास्केल , 109 107 103 बाइट्स

n!i="<t"++n++'>':i++"</t"++n++">"
r#c="able"!("r"!([1..c]*>"h"!"H")++([2..r]*>("r"!([1..c]*>"d"!"A"))))

इतने सारे कोष्ठक… दो बाइट्स के लिए @nimi के लिए धन्यवाद (और सामान्यता का नुकसान)!

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

अंत टैग के बिना 87 बाइट्स पर सीधे कार्यान्वयन जीतता है ( इसे ऑनलाइन प्रयास करें ):

r?c="<table><tr>"++([1..c]*>"<th>H")++([2..r]*>("<tr>"++([1..c]*>"<td>A")))++"</table>"

— Angs
स्रोत

1

एपीएल + विन, 68 63 56 बाइट्स

कुल 12 बाइट्स Adám की बदौलत

स्तंभों की संख्या के बाद पंक्तियों की संख्या और गैर-क्लोजर विकल्प आउटपुट के लिए संकेत:

t←⊂'<tr>'⋄'<table>'t(n⍴⊂'<th>A'),,t,((⎕-1),n←⎕)⍴⊂'<td>A'

— ग्राहम
स्रोत

@ Adám बहुत खुश हूं मुझे डर है। अब ठीक लग रहा है?

— ग्राहम

हां, लेकिन आपको ∊या पीछे आने वाले परेंस की जरूरत नहीं है : t,,((⎕-1),n←⎕)⍴rया पहले दो कॉमा।

— 18'18

@ Adám धन्यवाद इसका दिन मेरा ताप (28C) नहीं होना चाहिए!

— ग्राहम

मर्ज hऔर rमुख्य अभिव्यक्ति में:'<table>'t(n⍴⊂'<th>A')t,,((⎕-1),n←⎕)⍴⊂'<td>A'

— एडम

कुछ सही नहीं है। आप केवल <tr>शरीर के लिए एक सम्मिलित करते हैं। प्रत्येक पंक्ति की जरूरत है <tr>।

— एडम

1

रेटिना , 56 54 बाइट्स

(.+) (.+)
<table>$1*$(<tr>$2*$(<td>@
T`\d`\h`^.*?r.*?r

इसे ऑनलाइन आज़माएं! संपादित करें: @CowsQuack के लिए 2 बाइट्स सहेजे गए। व्याख्या: पहले चरण में रेटिना 1 के स्ट्रिंग गुणन का उपयोग किया जाता है, ताकि उचित संख्या में कोशिकाओं को उत्पन्न किया जा सके, फिर उचित संख्या में पंक्तियों को उत्पन्न किया जा सके। दूसरा चरण तब tds की पहली पंक्ति को s में बदलता है th।

— नील
स्रोत

यदि आप जानते हैं कि इनपुट रिक्त स्थान से विभाजित होने जा रहा है, तो आपको .इसके बजाय उपयोग करने में सक्षम होना चाहिए\d

— क्रिति लिथोस

1

चारकोल , 33 बाइट्स

<table><tr>×<th>AηＦ⊖θ«<tr>×<td>Aη

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

व्याख्या

<table><tr>                         Print "<table><tr>"
           ×<th>Aη                  Print "<th>A" * second input
                  Ｆ⊖θ«            For i in (implicit) range over first input
                        <tr>        Print("<tr>")
                            ×<td>Aη Print("<td>A") * second input

— ASCII-केवल
स्रोत

1

के, 58 बाइट्स

K संस्करण जो कुछ भी इसमें शामिल है KDB+ 3.5 2017.11.30।

पोर्ट ऑफ पायथन जवाब ऊपर। कई बार enlist और समतल करने के कारण 1 बाइट होने पर समाप्त होता है।

{,/"<table><tr>",(y#,"<th>A"),(x-1)#,("<tr>",/y#,"<td>A")}

— hoosierEE
स्रोत

1

पर्ल 5 `-p` , 65 54 बाइट्स

-11 बाइट्स @ msh2108 के अनुस्मारक के लिए धन्यवाद

/ /;$_="<table><tr>"."<th>A"x$'.('<tr>'.'<td>B'x$')x$`

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

— Xcali
स्रोत

अपने आप को कुछ बाइट्स बचाओ। चुनौती में एक उदाहरण के अनुसार, आप ड्रॉप कर सकते हैं .'</table>'।

— msh210

1

सी # (.NET कोर) , 130 बाइट्स

m=>n=>{var r="<table>";for(int i=0;i++<m;)r+="<tr>"+string.Concat(System.Linq.Enumerable.Repeat(i<2?"<th>H":"<td>D",n));return r;}

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

— एमानुएल विंटिलो
स्रोत

1

पॉवरशेल कोर , 72 68 बाइट्स

Function F($m,$n){'<table><tr>'+'<th>A'*$n+('<tr>'+'<td>A'*$n)*--$m}

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

यहाँ मेरे परीक्षण के मामले और अपेक्षित आउटपुट हैं (Cf, TIO)

मीटर = 2; n = 3 <table><tr><th>A<th>A<th>A<tr><td>A<td>A<td>A
मीटर = 1; n = 3 <table><tr><th>A<th>A<th>A
मीटर = 4; n = 2 <table><tr><th>A<th>A<tr><td>A<td>A<tr><td>A<td>A<tr><td>A<td>A
मीटर = 2; एन = 8 <table><tr><th>A<th>A<th>A<th>A<th>A<th>A<th>A<th>A<tr><td>A<td>A<td>A<td>A<td>A<td>A<td>A<td>A

धन्यवाद, @ बाइट , -4 बाइट्स के लिए!

— जेफ फ्रीमैन
स्रोत

1

ब्रैकेट वैकल्पिक हैं। कोशिश करो Function F($m,$n){'<table><tr>'+'<th>A'*$n+('<tr>'+'<td>A'*$n)*--$m}।

— माज़ी

0

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

J"<tr>"AQ"<table>"J*H"<th>A"*tGJ*H"<td>A

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

— hakr14
स्रोत

0

डार्ट , 45 63 बाइट्स

काम कर समाधान:

(m,n){print('<table><tr>'+'<th>A'*n+('<tr>'+'<td>A'*n)*(m-1));}

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

लैम्ब्डा / अनाम फ़ंक्शन लेने mऔर nमापदंडों के रूप में, आउटपुट प्रदर्शित करता है STDOUT।

साथ खुली हुई तालिकाओं के बाद से <table>, <tr>, <th>, और <td>टैग अभी भी आधुनिक ब्राउज़रों में प्रस्तुत करना (उदा।, क्रोम), उत्पादन वैध है।

पुराना (टूटा हुआ) समाधान:

मेरा पहला प्रयास <td>पहली पंक्ति के बाद स्विच करना भूल गया :

(m,n){print('<table><tr>'+'<th>A'*n+('<tr>'+'<th>A'*n)*(m-1));}

यह इंगित करने के लिए @Lynn का धन्यवाद।

— vasilescur
स्रोत

0

Google शीट, 66 बाइट्स

="<table><tr>"&Rept("<th>A",B1)&Rept("<tr>"&Rept("<td>A",B1),A1-1)

इनपुट सेल में है A1और B1।
वहाँ कुछ भी नहीं फैंसी है, वास्तव में; यह सिर्फ नेस्टेड Reptकार्य है।
यह मानता है m > n > 0और वे दोनों पूर्णांक हैं।

— इंजीनियर टोस्ट
स्रोत

0

जेली , 33 32 बाइट्स

“<td>A”ẋ”h3¦s5ẋ€ṭ€“<tr>”ṭ“¢ssɱU»

एक पूर्ण कार्यक्रम ले रहा है rows , columnsजो परिणाम प्रिंट करता है।

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

हम्म, 32 भी एक तालिका का उपयोग कर:

Ịị⁾hdṭ”t⁾<>j;ðþZṭ€“<tr>”ṭ“¢ssɱU»

— जोनाथन एलन
स्रोत

0

जे, 64 बाइट्स

पायथन जवाब का एक और बंदरगाह:

4 :0
'<table><tr>',(;y#<'<th>A'),;(<:x)#<('<tr>',(;y#<'<td>A'))
)

— hoosierEE
स्रोत

0

PHP, 161 बाइट्स

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

कोड

function f($m,$n){$t=["table>","th>","td>","tr>","</"];echo strtr("
<0<3".str_repeat("<1A41",$n)."43".str_repeat("<3".str_repeat("
<2A42",$n)."43",$m-1)."40",$t);}

व्याख्या

function f($m,$n){
  $t=["table>","th>","td>","tr>","</"];           //array representing the tags its created
  echo strtr("<0<3".str_repeat("<1A41",$n)."43"   //strtr it's called and uses 
                                                  //the array to replace values
           .str_repeat("<3".                      //repeat the tags
                         str_repeat("<2A42",$n)   //repeat the tags again
                            ."43",$m-1)."40",$t); 
   //its repeated m-1 times because head is counted as one row
  }

PHP, 193 बाइट्स

पूर्ण तालिका संरचना ~~भूल गए<tfooter>~~ <thead>, <tbody>..etc..

फ़ंक्शन का उदाहरण आज़माएं

function f($m,$n)   {$t=["table>","thead>","tbody>","th>","td>","tbody>","tr>"];
echo strtr(
      "<0<1".str_repeat("<3A</3",$n).
      "</1<2".str_repeat(
                  "<6".str_repeat("<4A</4",$n)
                       ."</6",$m-1)."</2</0",
  $t);
  }

व्याख्या

$t=["table>","thead>","tbody>","th>","td>","tbody>","tr>"];

तालिका के लिए सभी टैग के साथ एक सरणी यह builded है और फिर से str_repeatएक नंबर सरणी में एक सूचकांक की चर्चा करते हुए लिखा है, तो करने के लिए strtrस्ट्रिंग प्लस सरणी पारित हो जाता है

— फ्रांसिस्को हैन
स्रोत

0

याबेसिक , 124 बाइट्स

एक अनाम फ़ंक्शन जो इनपुट को स्पेस सीमांकित पूर्णांक और कंसोल से आउटपुट के रूप में लेता है।

?"<table>"
input""i,j
For c=1To i
?"<tr>"
For r=1To j
If c=1?"<th>H</th>"
If c>1?"<td>D</td>"
Next
?"</tr>"
Next
?"</table>"

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

— टेलर स्कॉट
स्रोत

यह <td> टैग का उत्पादन नहीं करता है।

— आलू

@ आलू - आह, मैंने ऐसा नहीं देखा था। इसे सुधारा गया है।

— टेलर स्कॉट

0

फोर्थ (gforth) , 86 बाइट्स

: f ." <table>" 0 do ." <tr>" dup 0 do j if ." <td>A" else ." <th>A" then loop loop ;

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

व्याख्या

." <table>"         \ output <table>
0 do                \ start loop from 0 to m-1
   ." <tr>"         \ output <tr>
   dup 0 do         \ duplicate n and loop from 0 to n-1
      j if          \ if the outer loop index is true (not 0)
         ." <td>A"  \ output <td>A
      else          \ if outer loop index is false (0)
         ." <th>A"  \ output <th>A
      then          \ end if-else
   loop             \ end inner loop
loop                \ end outer loop

— reffu
स्रोत

0

गाजर , 77 51 बाइट्स

<th>A^*$v<tr>vl+(^h)*($^F- 1)A"h"S"d"h+(^l)v<table>

(इस पर काम करते समय, मैंने hकाम न करने के साथ एक बग की खोज की और इसे ठीक किया)

HTML को छोटा करने के साथ-साथ "स्प्लिट" के बजाय "स्प्लिट, ज्वाइन" का उपयोग करके कुछ बाइट्स को गोल्फ में शामिल करें

इसे ऑनलाइन आज़माएं! कमांड लाइन विकल्प का उपयोग करें-dएएसटी देखने के लिए का उपयोग करें (नोट: यह नए नोड दुभाषिया का उपयोग करता है, इसलिए वेबसाइट पर पुराना संस्करण इसे नहीं चला सकता है।)

यह कार्यक्रम गाजर की अजीब प्रकृति के कारण इनपुट 0-अनुक्रमित और उलटा क्रम में लेता है, इस प्रकार 3 23 × 4 तालिका को प्रिंट करता है।

प्रोग्राम को ऐसे चलाएं, ./carrot -f prog.carrot input.txt

मूल रूप से हेडर पंक्ति बनाता है, फिर बगीचे के एक और सेल (2 डी टेप) पर डेटा पंक्तियाँ, और उन्हें एक साथ मिलाता है।

गाजर एक 2 डी टेप पर काम करता है, जिसे एक बगीचे कहा जाता है। बगीचे की प्रत्येक कोशिका तीन स्टैक मोड्स, स्ट्रिंग, फ्लोट, ऐरे से बनी है। प्रत्येक मोड के लिए एक मूल्य है, जिसे "स्टैक" (नोट: मिसनोमर) कहा जाता है। ये ढेर खाली होने लगते हैं। जब एक सेल एक विशेष मोड पर होता है, तो निम्न कमांड इस मोड से मेल खाते स्टैक को प्रभावित करेगा, उदाहरण के लिए फ्लोट मोड में, संचालन स्टैक फ्लोट को प्रभावित करेगा। और हां, मोड के बीच स्विच करने के लिए कमांड हैं। मोड महत्वपूर्ण हैं क्योंकि प्रत्येक ऑपरेटर प्रत्येक मोड और प्रत्येक तर्क प्रकार के लिए अतिभारित हो सकता है।

इसके अलावा, दो अतिरिक्त मोड हैं (ये केवल कमांड को प्रभावित करते हैं, सीधे स्टैक को नहीं), सामान्य मोड और कैरेट मोड। सामान्य मोड सामान्य रूप से काम करता है, जहां ऑपरेटर तर्क में लेते हैं और स्टैक को सीधे प्रभावित करते हैं। कैरेट मोड में, (लगभग) प्रत्येक वर्ण की शाब्दिक रूप से एक स्ट्रिंग के रूप में व्याख्या की जाती है, और बाद में स्टैक के अनुसार पूर्वनिर्मित / जोड़ा जाता है। कैरेट मोड को शुरू किया गया है / करियर (एपेंड) या डाउन-केयर (प्रीपेन्ड) के साथ समाप्त किया गया है।

गाजर बगीचे में एक सेल में, स्टैक-स्ट्रिंग मोड में और कैरेट मोड में शुरू होता है।

कैरेट-मोड में शुरुआत, स्ट्रिंग <th>Aको शुरू में खाली स्टैक-स्ट्रिंग में जोड़ा जाता है। फिर उस *आदेश का अनुसरण करता है जो इसे डुप्लिकेट करता है $, इनपुट, समय। फिर <tr>डाउन-कैरेट के उपयोग से स्टैक-स्ट्रिंग को तैयार किया जाता है v। यह तालिका की हेडर पंक्ति बनाता है।

डेटा पंक्तियों को बनाने के लिए, हम हेडर को किसी अन्य सेल में डुप्लिकेट करते हैं। lIP को दाईं ओर खाली सेल में ले जाता है, और सेल में स्ट्रिंग को बाईं ओर +जोड़ता (^h)है (अनिवार्य रूप से इसे दाईं ओर सेल में कॉपी करता है)। ()एक उपखंड, लगभग एक ही टेप के साथ एक नया गाजर कार्यक्रम शुरू करता है, और ^कैरट-मोड से बाहर निकलता है ताकि हम hबाएं सेल में स्ट्रिंग प्राप्त कर सकें। इसके बाद , अगले इनपुट माइनस 1, बार *द्वारा डुप्लिकेट किया जाता ($^F- 1)है।

अभी भी सही सेल में, Aइस सेल के एरे को इसके स्टैक- ट्रिंग स्प्लिट द्वारा सेट करता है "h"। Sस्टैक ऐरे से जुड़ता है "d"और स्टैक स्ट्रिंग को इस मान पर सेट करता है। A"h"S"d"वास्तव में सिर्फ डेटा पंक्तियों को बनाने के लिए hs के साथ ds को प्रतिस्थापित करता है । अब hहम बाईं ओर के आरंभिक कक्ष में जाते हैं।

अब हम सेल के स्टैक स्ट्रिंग को इस सेल के दाईं ओर प्रयोग करते हैं +(^l)। जो कुछ शेष है वह <table>टैग जोड़ने के लिए है, इसलिए हम vइसे पहले से बताकर करते हैं।

— क्रिकटी लिथोस
स्रोत

0

के (ngn / k) , 51 बाइट्स

{"<table>",/"<tr>",//:y#'(,,"<th>A"),1_x#,,"<td>A"}

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

— NGN
स्रोत

0

पॉवरशेल, 63 बाइट्स

$m,$n=$args;$t='h';'<table>';1..$m|%{'<tr>'+"<t$t>A"*$n;$t='d'}

इसे सहेजें new-mntable.ps1। टेस्ट स्क्रिप्ट:

.\new-mntable.ps1 2 3
.\new-mntable.ps1 1 3
.\new-mntable.ps1 4 2
.\new-mntable.ps1 2 8

आउटपुट (अतिरिक्त स्थान वैकल्पिक हैं):

<table>
<tr><th>A<th>A<th>A
<tr><td>A<td>A<td>A
<table>
<tr><th>A<th>A<th>A
<table>
<tr><th>A<th>A
<tr><td>A<td>A
<tr><td>A<td>A
<tr><td>A<td>A
<table>
<tr><th>A<th>A<th>A<th>A<th>A<th>A<th>A<th>A
<tr><td>A<td>A<td>A<td>A<td>A<td>A<td>A<td>A

पॉवरशेल, 65 बाइट्स, `-replace`

'<table>h'+'d'*--$args[0]-replace'h|d',('<tr>'+'<t$0>A'*$args[1])

इसे सहेजें new-mntable.ps1। टेस्ट स्क्रिप्ट:

.\new-mntable.ps1 2 3
.\new-mntable.ps1 1 3
.\new-mntable.ps1 4 2
.\new-mntable.ps1 2 8

उत्पादन:

<table><tr><th>A<th>A<th>A<tr><td>A<td>A<td>A
<table><tr><th>A<th>A<th>A
<table><tr><th>A<th>A<tr><td>A<td>A<tr><td>A<td>A<tr><td>A<td>A
<table><tr><th>A<th>A<th>A<th>A<th>A<th>A<th>A<th>A<tr><td>A<td>A<td>A<td>A<td>A<td>A<td>A<td>A

यह कैसे कार्य करता है:

'<table>h'+'d'*--$args[0] - जैसे एक स्ट्रिंग बनाएँ <table>hddd...
'h|d'- बदलने hया dस्ट्रिंग में बदलने के लिए तार
'<tr>'+'<t$0>A'*$args[1] - स्ट्रिंग की तरह प्रत्येक चार को बदलें <tr><t$0>A<t$0>A...
जहां $0एक कब्जा कर लिया है group[0]- में चार -replace।

पॉवरशेल, 65 बाइट्स, `scriptblock`

$m,$n=$args;'<table>';&($r={'<tr>'+"<t$args>A"*$n})h;(&$r d)*--$m

इसे सहेजें new-mntable.ps1। टेस्ट स्क्रिप्ट:

.\new-mntable.ps1 2 3
.\new-mntable.ps1 1 3
.\new-mntable.ps1 4 2
.\new-mntable.ps1 2 8

उत्पादन:

<table>
<tr><th>A<th>A<th>A
<tr><td>A<td>A<td>A
<table>
<tr><th>A<th>A<th>A

<table>
<tr><th>A<th>A
<tr><td>A<td>A<tr><td>A<td>A<tr><td>A<td>A
<table>
<tr><th>A<th>A<th>A<th>A<th>A<th>A<th>A<th>A
<tr><td>A<td>A<td>A<td>A<td>A<td>A<td>A<td>A

— Mazzy
स्रोत

HTML में * n तालिका का निर्माण करें

इनपुट:

आउटपुट:

जीत की स्थिति:

इनपुट उदाहरण:

आउटपुट उदाहरण:

एपीएल (Dyalog यूनिकोड) के साथ MiServer 3.0 , 31 30 बाइट्स SBCS

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

डेमो

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

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

जावास्क्रिप्ट, 65 बाइट्स

05AB1E , 30 बाइट्स

स्टेक्स , 28 बाइट्स

जावा 10, 139 133 102 बाइट्स

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

सी (जीसीसी) , 107 99 98 97 बाइट्स

आर , 73 बाइट्स

हास्केल , 109 107 103 बाइट्स

एपीएल + विन, 68 63 56 बाइट्स

रेटिना , 56 54 बाइट्स

चारकोल , 33 बाइट्स

व्याख्या

के, 58 बाइट्स

पर्ल 5 -p , 65 54 बाइट्स

सी # (.NET कोर) , 130 बाइट्स

पॉवरशेल कोर , 72 68 बाइट्स

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

डार्ट , 45 63 बाइट्स

काम कर समाधान:

पुराना (टूटा हुआ) समाधान:

Google शीट, 66 बाइट्स

जेली , 33 32 बाइट्स

जे, 64 बाइट्स

PHP, 161 बाइट्स

PHP, 193 बाइट्स

याबेसिक , 124 बाइट्स

फोर्थ (gforth) , 86 बाइट्स

व्याख्या

गाजर , 77 51 बाइट्स

के (ngn / k) , 51 बाइट्स

पॉवरशेल, 63 बाइट्स

पॉवरशेल, 65 बाइट्स, -replace

पॉवरशेल, 65 बाइट्स, scriptblock

एपीएल (Dyalog यूनिकोड) के साथ MiServer 3.0 , 31 30 बाइट्स ^SBCS

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

पर्ल 5 `-p` , 65 54 बाइट्स

पॉवरशेल, 65 बाइट्स, `-replace`

पॉवरशेल, 65 बाइट्स, `scriptblock`