Đầu vào :

Hai số nguyên thập phân mvà ntương ứng cho số lượng hàng và cột của bảng. mvà nlớn hơn hoặc bằng 1.

Đầu ra:

Một bảng trong HTML có m hàng và n cột.

Bảng nên được hiển thị bởi một trình duyệt hiện đại bạn chọn. Hầu hết các trình duyệt sẽ hiển thị mọi thứ chính xác ngay cả khi các thẻ không được đóng. Lõm đúng cách và khoảng cách là tùy chọn.

Cần có ít nhất một ký tự có thể in (không phải khoảng trắng) trong mỗi ô.

Các ô trên dòng đầu tiên nên sử dụng <th>thẻ trong khi các ô trên các dòng sau nên sử dụng <td>thẻ.

Điều kiện thắng:

Đây là môn đánh gôn, vì vậy mã nguồn ngắn nhất cho mỗi ngôn ngữ sẽ thắng.

Ví dụ đầu vào:

2 3

Ví dụ đầu ra:

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

hoặc là : <table><tr><th>A<th>A<th>A<tr><td>A<td>A<td>A

APL (Dyalog Unicode) với MiServer 3.0 , 31 30 byte ^SBCS

Chương trình đầy đủ. Nhắc stdin cho danh sách hai thành phần [m,n]và in XHTML nghiêm ngặt ra thiết bị xuất chuẩn.

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

Phiên ví dụ:

      )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>

Hãy thử trực tuyến!

Giải trình:

(Kết xuất ).Render phần tử HTML sau:

 ⎕NEW _.Table (... ) một bảng mới với các thông số sau:

  (... ) ⍬ 1 các nội dung sau đây, không có phong cách đặc biệt, 1 tiêu đề hàng:

   ⎕⍴0 đánh giá đầu vào định hình lại số 0 (tức là ma trận m-row, n cột 0)

JavaScript (ES6), 70 byte

Đã lưu 2 byte nhờ @RickHitchcock

Đưa đầu vào theo cú pháp currying (m)(n).

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

Hãy thử trực tuyến!

Bản giới thiệu

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>

Python 2 , 57 byte

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

Hãy thử trực tuyến! Giả sử mkhông bằng không.

Canvas , 31 byte

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

Hãy thử nó ở đây! hoặc thử nó trực quan!

Sau khi sửa 2 lỗi (_ಠ) trong trình thông dịch, 30 byte cũng hoạt động

JavaScript, 65 byte

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

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

05AB1E , 30 byte

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

Hãy thử trực tuyến!

Giải trình

’<…È>’                           # 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

Stax , 28 byte

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

Chạy và gỡ lỗi nó

Giải nén, không được chỉnh sửa, và nhận xét, nó trông như thế này.

"<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"

Chạy cái này

Java 10, 139 133 102 byte

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;}

Hãy thử trực tuyến.

Giải trình:

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

APL (Dyalog Unicode) , 42 38 byte ^SBCS

-4 cảm ơn ngn.

Chương trình đầy đủ. Nhắc stdin cho danh sách hai thành phần [m, n] và in các thẻ không được tiết lộ ra thiết bị xuất chuẩn.

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

Hãy thử trực tuyến!

⊂'<th>A' kèm theo chuỗi này để coi nó như một tổng thể

⎕⍴ nhắc về kích thước và tuần hoàn r eshape ô duy nhất vào một ma trận có kích thước đó

…⍀ tích lũy chức năng sau đây giữa mỗi cặp ô dọc:

 {'d'}@3 bỏ qua tế bào trên; đặt dở vị trí thứ 3 trong ô dưới cùng

'<tr>',⍤1 thêm chuỗi này mỗi hàng

∊ ε nlist (flatten)

'<table>', thêm chuỗi này

C (gcc) , 107 99 98 97 byte

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

Hãy thử trực tuyến!

-8 byte nhờ khoai tây

-2 byte nhờ trần

Các smảng phải được khai báo là một mảng không phải là một con trỏ nếu không nó sẽ không được thay đổi (chúng tôi đặt h đầu tiên để quảng cáo). Hầu hết các trình duyệt thậm chí không quan tâm nếu thẻ đóng của bạn là chính xác, vì vậy chúng tôi chỉ cần đóng tất cả các thẻ với </t>.

R , 73 byte

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

Hãy thử trực tuyến!

Đã lưu 7 byte bằng một bản hack bẩn - thay thế "rep" bằng "<".

Haskell , 109 107 103 byte

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

Vì vậy, nhiều dấu ngoặc đơn Cảm ơn @nimi cho hai byte (và mất tính tổng quát)!

Hãy thử trực tuyến!

Không có thẻ kết thúc, việc thực hiện thẳng thắng ở 87 byte ( Dùng thử trực tuyến ):

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

APL + THẮNG, 68 63 56 byte

Tổng cộng 12 byte được lưu nhờ Adám

Nhắc số lượng hàng theo sau là số cột và đầu ra tùy chọn không đóng:

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

Võng mạc , 56 54 byte

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

Hãy thử trực tuyến! Chỉnh sửa: Đã lưu 2 byte nhờ @CowsQuack. Giải thích: Giai đoạn đầu tiên sử dụng phép nhân chuỗi của Retina 1 trước tiên để tạo số lượng ô thích hợp, sau đó tạo số lượng hàng thích hợp. Giai đoạn thứ hai sau đó thay đổi hàng đầu tiên của tds thành ths.

Than , 33 byte

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

Hãy thử trực tuyến!

Giải trình

<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

K, 58 byte

Phiên bản K là bất cứ điều gì được bao gồm trong KDB+ 3.5 2017.11.30.

Cổng của câu trả lời Python ở trên. Kết thúc là 1 byte dài hơn do phải tranh thủ và làm phẳng nhiều lần.

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

Perl 5 -p , 65 54 byte

-11 byte nhờ lời nhắc của @ msh2108

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

Hãy thử trực tuyến!

C # (.NET Core) , 130 byte

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;}

Hãy thử trực tuyến!

Lõi PowerShell , 72 68 byte

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

Hãy thử trực tuyến!

Dưới đây là các trường hợp thử nghiệm và đầu ra dự kiến ​​của tôi (Cf, TIO)

• m = 2; n = 3 <table><tr><th>A<th>A<th>A<tr><td>A<td>A<td>A
• m = 1; n = 3 <table><tr><th>A<th>A<th>A
• m = 4; n = 2 <table><tr><th>A<th>A<tr><td>A<td>A<tr><td>A<td>A<tr><td>A<td>A
• m = 2; n = 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

Cảm ơn, @ mazzy , vì -4 byte!

Bình thường , 40 byte

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

Hãy thử trực tuyến!

Phi tiêu , 45 63 byte

Giải pháp làm việc:

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

Dùng thử trực tuyến tại đây!

Chức năng Lambda / nặc danh lấy mvà nlàm tham số, hiển thị đầu ra STDOUT.

Kể từ khi bảng với không khép kín <table>, <tr>, <th>, và <td>thẻ vẫn làm trong các trình duyệt hiện đại (ví dụ., Chrome), sản lượng là hợp lệ.

Giải pháp cũ (hỏng):

Nỗ lực đầu tiên của tôi đã quên chuyển sang <td>sau hàng đầu tiên:

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

Cảm ơn @Lynn đã chỉ ra điều đó.

Google Sheets, 66 byte

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

Đầu vào là trong ô A1và B1.
Không có gì lạ mắt, thực sự; nó chỉ là các Repthàm lồng nhau .
Nó không giả m > n > 0và rằng họ đang cả hai số nguyên.

Thạch ,  33  32 byte

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

Một chương trình đầy đủ rows, columnstrong đó in kết quả.

Hãy thử trực tuyến!

hmm, 32 cũng sử dụng bảng:

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

J, 64 byte

Một cổng khác của câu trả lời Python:

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

PHP, 161 byte

Dùng thử trực tuyến

Mã

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);}

Giải trình

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 byte

Cấu trúc bảng đầy đủ quên<tfooter> <thead>, <tbody>..etc..

Hãy thử ví dụ về hàm

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);
  }

Giải trình

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

Một mảng với tất cả các thẻ cho bảng được xây dựng và sau đó với str_repeatmột số tham chiếu đến một chỉ mục trong mảng được viết, sau đó đến strtrchuỗi cộng với mảng được truyền

Yabasic , 124 byte

Một hàm ẩn danh nhận đầu vào từ số nguyên được phân tách bằng dấu cách và đầu ra cho bàn điều khiển.

?"<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>"

Hãy thử trực tuyến!

Forth (gforth) , 86 byte

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

Hãy thử trực tuyến!

Giải trình

." <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                      

Cà rốt , 77 51 byte

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

(Trong khi làm việc với điều này, tôi đã phát hiện ra một lỗi hkhông hoạt động và đã sửa nó)

Đánh gôn một số byte bằng cách rút ngắn html cũng như sử dụng "split, tham gia" thay vì "thay thế"

Hãy thử trực tuyến! , sử dụng tùy chọn dòng lệnh -dđể xem AST (Lưu ý: điều này sử dụng trình thông dịch nút mới, vì vậy phiên bản cũ hơn trên trang web không thể chạy cái này.)

Chương trình này lấy đầu vào 0 được lập chỉ mục và theo thứ tự đảo ngược, vì bản chất kỳ lạ của Carrot, do đó 3 2in bảng 3 × 4.

Chạy chương trình như vậy, ./carrot -f prog.carrot input.txt

Về cơ bản tạo hàng tiêu đề, sau đó các hàng dữ liệu trên một ô khác của khu vườn (băng 2D) và nối chúng lại với nhau.

Cà rốt hoạt động trên băng 2D, được gọi là vườn. Mỗi ô trên vườn được tạo thành từ ba chế độ ngăn xếp, chuỗi, float, mảng. Có một giá trị cho mỗi chế độ, được gọi là "ngăn xếp" (lưu ý: viết sai). Những ngăn xếp này bắt đầu trống rỗng. Khi một ô ở chế độ cụ thể, các lệnh sau sẽ ảnh hưởng đến ngăn xếp tương ứng với chế độ này, ví dụ ở chế độ float, các hoạt động sẽ ảnh hưởng đến float float. Và tất nhiên, có các lệnh để chuyển đổi giữa các chế độ. Các chế độ rất quan trọng vì mỗi toán tử có thể bị quá tải cho từng chế độ và từng loại đối số.

Ngoài ra, có hai chế độ bổ sung (những chế độ này chỉ ảnh hưởng đến các lệnh chứ không ảnh hưởng trực tiếp đến ngăn xếp), chế độ bình thường và chế độ caret. Chế độ bình thường hoạt động bình thường, trong đó có các toán tử tham gia vào các đối số và ảnh hưởng trực tiếp đến ngăn xếp. Trong chế độ caret, (hầu hết) mọi ký tự được hiểu theo nghĩa đen là một chuỗi và sau đó được thêm vào / nối thêm vào ngăn xếp. Chế độ caret được bắt đầu / kết thúc bằng dấu mũ (nối thêm) hoặc dấu mũ xuống (trả trước).

Cà rốt bắt đầu trong một tế bào trong vườn, ở chế độ chuỗi ngăn xếp và ở chế độ caret.

Bắt đầu ở chế độ caret, chuỗi <th>Ađược thêm vào chuỗi stack trống ban đầu. Sau đó, theo *lệnh sao chép nó $, đầu vào, thời gian. Sau đó <tr>được thêm vào chuỗi ngăn xếp bằng cách sử dụng dấu mũ v. Điều này tạo ra hàng tiêu đề của bảng.

Để tạo các hàng dữ liệu, chúng tôi nhân đôi tiêu đề sang một ô khác. ldi chuyển IP sang ô trống bên phải và +nối (^h)chuỗi trong ô bên trái (về cơ bản sao chép nó vào ô bên phải). ()bắt đầu một subshell, một chương trình Carrot mới với gần như cùng một băng và ^thoát ra khỏi chế độ caret để chúng ta có thể hlấy chuỗi trong ô bên trái. Điều này sau đó được *nhân đôi bởi ($^F- 1), đầu vào tiếp theo trừ đi 1 lần.

Vẫn ở ô bên phải, Ađặt mảng của ô này thành ngăn xếp của nó được phân chia theo "h". Snối mảng stack bằng cách "d"và đặt chuỗi stack thành giá trị này. A"h"S"d"thực sự chỉ thay thế hs bằng ds để tạo thành các hàng dữ liệu. Bây giờ hchúng ta di chuyển đến ô bắt đầu bên trái.

Bây giờ chúng ta nối chuỗi ngăn xếp của ô vào bên phải ô này bằng cách sử dụng +(^l). Tất cả những gì còn lại là thêm <table>thẻ, vì vậy chúng tôi thực hiện điều này bằng cách đăng ký vtrước.

K (ngn / k) , 51 byte

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

Hãy thử trực tuyến!

Powershell, 63 byte

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

lưu nó như là new-mntable.ps1. Kịch bản thử nghiệm:

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

đầu ra (không gian thêm là tùy chọn):

<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

Powershell, 65 byte, -replace

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

lưu nó như là new-mntable.ps1. Kịch bản thử nghiệm:

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

đầu ra:

<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

Cách thức hoạt động:

1. '<table>h'+'d'*--$args[0] - tạo một chuỗi như <table>hddd...
2. 'h|d'- tìm kiếm hhoặc dký tự trong chuỗi để thay thế
3. '<tr>'+'<t$0>A'*$args[1] - thay thế mỗi char bằng chuỗi như <tr><t$0>A<t$0>A...
4. nơi $0bị bắt group[0]- char trong -replace.

Powershell, 65 byte, scriptblock

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

lưu nó như là new-mntable.ps1. Kịch bản thử nghiệm:

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

đầu ra:

<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