Entrada :

Dois números inteiros decimais me nque respectivamente fornecem o número de linhas e colunas da tabela. me nsão maiores ou iguais a 1.

Saída:

Uma tabela em HTML que possui m linhas e n colunas.

A tabela deve ser exibida por um navegador moderno de sua escolha. A maioria dos navegadores exibirá tudo corretamente, mesmo que as tags não estejam fechadas. Recuo e espaçamento adequados são opcionais.

Deve haver pelo menos um caractere imprimível (sem espaço em branco) em cada célula.

As células na primeira linha devem usar <th>tags, enquanto as das linhas seguintes devem usar <td>tags.

Condição da vitória:

Este é o código-golfe, portanto o código-fonte mais curto para cada idioma vence.

Exemplo de entrada:

2 3

Exemplo de saída:

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

ou: <table><tr><th>A<th>A<th>A<tr><td>A<td>A<td>A

APL (Dyalog Unicode) com MiServer 3.0 , 31 ^SBCS de 30 bytes

Programa completo. Solicita ao stdin a lista de dois elementos [m,n]e imprime XHTML estrito no stdout.

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

Sessão de exemplo:

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

Experimente online!

Explicação:

(… ).Render Renderize o seguinte elemento HTML:

 ⎕NEW _.Table (… ) Uma nova tabela com os seguintes parâmetros:

  (… ) ⍬ 1 O seguinte conteúdo, sem estilo especial, 1 linha de cabeçalho:

   ⎕⍴0 a entrada avaliada redefine o zero (ou seja, uma matriz m, n coluna de zeros)

JavaScript (ES6), 70 bytes

Guardado 2 bytes graças a @RickHitchcock

Recebe entrada na sintaxe de currying (m)(n).

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

Experimente online!

Demo

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 bytes

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

Experimente online! Assume que mnão é zero.

Tela , 31 bytes

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

Experimente aqui! ou Experimente visualizado!

Depois de corrigir 2 erros (ಠ_ಠ) no intérprete, 30 bytes também funcionam

JavaScript, 65 bytes

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

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

05AB1E , 30 bytes

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

Experimente online!

Explicação

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

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

Execute e depure

Descompactado, não jogado e comentado, parece com isso.

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

Execute este

Java 10, 139 133 102 bytes

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

Experimente online.

Explicação:

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 bytes ^SBCS

-4 graças a ngn.

Programa completo. Solicita ao stdin a lista de dois elementos [m, n] e imprime tags não fechadas no stdout.

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

Experimente online!

⊂'<th>A' coloque esta sequência para tratá-la como um todo

⎕⍴ pronta para dimensões e ciclicamente r eshape a única célula de uma matriz desse tamanho

…⍀ cumulativamente, insira a seguinte função entre cada par vertical de células:

 {'d'}@3 ignorar célula superior; coloque dna 3ª posição na célula inferior

'<tr>',⍤1 Anexe esta string a cada linha

∊ ε nlist (achatar)

'<table>', precede esta sequência

C (gcc) , 107 99 98 97 bytes

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

Experimente online!

-8 bytes graças à batata

-2 bytes graças ao ceilingcat

A smatriz deve ser declarada como uma matriz, não como ponteiro, caso contrário não será editável (definimos o primeiro h como anúncio). A maioria dos navegadores nem se importa se a sua tag de fechamento está correta, então fechamos todas as tags com </t>.

R , 73 bytes

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

Experimente online!

7 bytes salvos com um hack sujo - substitua "rep" por "<".

Haskell , 109 107 103 bytes

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

Tantos parênteses… Obrigado a @nimi por dois bytes (e uma perda de genicidade)!

Experimente online!

Sem tags finais, a implementação direta ganha em 87 bytes ( Experimente on-line ):

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

APL + WIN, 68 63 56 bytes

Total de 12 bytes salvos graças a Adám

Solicita o número de linhas seguido pelo número de colunas e gera a opção de não fechamento:

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

Retina , 56 54 bytes

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

Experimente online! Editar: salvou 2 bytes graças a @CowsQuack. Explicação: O primeiro estágio usa a multiplicação de string da Retina 1 primeiro para gerar o número apropriado de células e, em seguida, para gerar o número apropriado de linhas. O segundo estágio altera a primeira linha de tds para ths.

Carvão , 33 bytes

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

Experimente online!

Explicação

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

A versão K é o que está incluído KDB+ 3.5 2017.11.30.

Porta da resposta Python acima. Ele acaba sendo 1 byte mais devido a ter que se alistar e achatar várias vezes.

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

Perl 5 -p , 65 54 bytes

-11 bytes graças ao lembrete de @ msh2108

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

Experimente online!

C # (.NET Core) , 130 bytes

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

Experimente online!

Núcleo do PowerShell , 72 68 bytes

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

Experimente online!

Aqui estão meus casos de teste e resultados esperados (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

Obrigado, @ mazzy , pelos -4 bytes!

Pitão , 40 bytes

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

Experimente online!

Dardo , 45 63 bytes

Solução de trabalho:

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

Experimente online aqui!

Tomando a função Lambda / anônima me, ncomo parâmetros, exibe a saída para STDOUT.

Desde tabelas com unclosed <table>, <tr>, <th>, e <td>etiquetas ainda rende em navegadores modernos (ex., Chrome), a saída é válido.

Solução antiga (quebrada):

Minha primeira tentativa esqueceu de mudar para <td>após a primeira linha:

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

Obrigado a @Lynn por apontar isso.

Planilhas Google, 66 bytes

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

A entrada está na célula A1e B1.
Não há nada chique, realmente; são apenas Reptfunções aninhadas .
Ele não assumem m > n > 0e que eles são ambos inteiros.

Geléia ,  33  32 bytes

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

Um programa completo rows, columnsque imprime o resultado.

Experimente online!

hmm, também 32 usando uma tabela:

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

J, 64 bytes

Outra porta da resposta do Python:

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

PHP, 161 bytes

Experimente online

Código

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

Explicação

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 bytes

Esqueci a estrutura da tabela<tfooter> <thead>, <tbody>..etc..

Experimente o exemplo da função

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

Explicação

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

Uma matriz com todas as tags para a mesa é edificada e depois com str_repeatum número referindo-se a um índice na matriz está escrito, então a strtrcorda mais a matriz é passado

Yabasic , 124 bytes

Uma função anônima que recebe entradas como números inteiros delimitados por espaço e sai para o console.

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

Experimente online!

Quarto (gforth) , 86 bytes

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

Experimente online!

Explicação

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

Cenoura , 77 51 bytes

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

(Enquanto trabalhava nisso, descobri um bug que hnão funcionava e o corrigi)

Golpeou alguns bytes encurtando o html e usando "split, join" em vez de "replace"

Experimente online! , use a opção de linha de comando -dpara ver o AST (Observação: isso usa o novo interpretador de nó, portanto, a versão mais antiga no site não pode executar isso.)

Este programa pega a entrada indexada em 0 e em ordem inversa, devido à natureza estranha de Cenoura, 3 2imprimindo assim uma tabela 3 × 4.

Execute o programa assim, ./carrot -f prog.carrot input.txt

Cria basicamente a linha do cabeçalho, depois as linhas de dados em outra célula do jardim (fita 2D) e as concatena.

Cenoura trabalha em uma fita 2D, chamada de jardim. Cada célula do jardim é composta de três modos de pilha, string, float, array. Há um valor para cada modo, chamado de "pilha" (nota: nome impróprio). Essas pilhas começam vazias. Quando uma célula está em um modo específico, os seguintes comandos afetam a pilha que corresponde a esse modo, por exemplo, no modo de flutuação, as operações afetam a flutuação da pilha. E, claro, existem comandos para alternar entre os modos. Os modos são importantes porque cada operador pode ser sobrecarregado para cada modo e cada tipo de argumento.

Além disso, existem dois modos adicionais (eles afetam apenas os comandos, não a pilha diretamente), modo normal e modo de interpolação. O modo normal funciona normalmente, onde há operadores recebendo argumentos e afetando diretamente a pilha. No modo de sinal de intercalação, (quase) todo caractere é interpretado literalmente como uma sequência e, posteriormente, é anexado / anexado de acordo com a pilha. O modo de intercalação é iniciado / finalizado com intercalação (anexar) ou intercalar (intercalar).

A cenoura começa em uma célula no jardim, no modo de pilha e no modo de sinal de intercalação.

Começando no modo de sinal de intercalação, a string <th>Aé adicionada à string de pilha inicialmente vazia. Em seguida, segue o *comando que duplica $, a entrada, os tempos. Em seguida, <tr>é anexado à string da pilha pelo uso do sinal de intercalação v. Isso cria a linha do cabeçalho da tabela.

Para criar as linhas de dados, duplicamos o cabeçalho para outra célula. lmove o IP para a célula vazia direita e +anexa (^h)a sequência na célula à esquerda (essencialmente copiando-a para a célula à direita). ()inicia um subshell, um novo programa Carrot com quase a mesma fita e ^sai do modo de sinal de intercalação para que possamos hobter a string na célula esquerda. Isso é *duplicado pela ($^F- 1)próxima entrada menos 1, vezes.

Ainda na célula certa, Adefine a matriz dessa célula para seu empilhamento dividido por "h". Sjunta-se à matriz da pilha "d"e define a cadeia de caracteres da pilha para esse valor. A"h"S"d"realmente substitui hs por ds para formar as linhas de dados. Agora hvamos para a célula inicial esquerda.

Agora, anexamos a string de pilha da célula à direita dessa célula usando +(^l). Tudo o que resta é adicionar a <table>tag, então fazemos isso vanexando-a.

K (ngn / k) , 51 bytes

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

Experimente online!

Powershell, 63 bytes

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

salve-o como new-mntable.ps1. Script de teste:

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

saída (espaços extras são opcionais):

<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 bytes, -replace

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

salve-o como new-mntable.ps1. Script de teste:

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

saída:

<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

Como isso funciona:

1. '<table>h'+'d'*--$args[0] - crie uma string como <table>hddd...
2. 'h|d'- pesquisa hou dcaracteres na string para substituição
3. '<tr>'+'<t$0>A'*$args[1] - substitua cada caractere por string como <tr><t$0>A<t$0>A...
4. onde $0é capturado group[0]- o caractere no -replace.

PowerShell, 65 bytes, scriptblock

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

salve-o como new-mntable.ps1. Script de teste:

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

saída:

<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