Entrada:

Dos enteros decimales my nque respectivamente dan el número de filas y columnas de la tabla. my nson mayores o iguales a 1.

Salida:

Una tabla en HTML que tiene m filas yn columnas.

La tabla debe ser visualizable por un navegador moderno de su elección. La mayoría de los navegadores mostrarán todo correctamente incluso si las etiquetas no están cerradas. La sangría y el espaciado adecuados son opcionales.

Debe haber al menos un carácter imprimible (sin espacios en blanco) en cada celda.

Las celdas en la primera línea deben usar <th>etiquetas, mientras que las de las siguientes líneas deben usar<td> etiquetas.

Condición de victoria:

Esto es código golf por lo que gana el código fuente más corto para cada idioma.

Ejemplo de entrada:

2 3

Ejemplo de salida:

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

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

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

Programa completo Solicita stdin para la lista de dos elementos [m,n]e imprime XHTML estricto en stdout.

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

Sesión de ejemplo:

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

Pruébalo en línea!

Explicación:

(... ).Render Representa el siguiente elemento HTML:

 ⎕NEW _.Table (... ) una nueva tabla con los siguientes parámetros:

  (... ) ⍬ 1 el siguiente contenido, sin estilo especial, 1 fila de encabezado:

   ⎕⍴0 la entrada evaluada cambia la forma a cero (es decir, una matriz de ceros de n filas y columnas)

JavaScript (ES6), 70 bytes

Guardado 2 bytes gracias a @RickHitchcock

Toma entrada en la sintaxis de curry (m)(n).

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

Pruébalo en línea!

Manifestación

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

Pruébalo en línea! Asume mque no es cero.

Lienzo , 31 bytes.

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

Pruébalo aquí! o Pruébalo visualizado!

Después de corregir 2 errores (ಠ_ಠ) en el intérprete, 30 bytes también funcionan

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

Pruébalo en línea!

Explicación

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

Ejecutar y depurarlo

Desempaquetado, sin golf y comentado, se ve así.

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

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

Pruébalo en línea.

Explicación:

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 gracias a ngn.

Programa completo Solicita stdin para la lista de dos elementos [m, n] e imprime etiquetas no cerradas en stdout.

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

Pruébalo en línea!

⊂'<th>A' encierra esta cadena para tratarla como un todo

⎕⍴ símbolo para las dimensiones y cíclicamente r eshape la célula individual a una matriz de ese tamaño

…⍀ inserte acumulativamente la siguiente función entre cada par vertical de celdas:

 {'d'}@3 ignorar la celda superior; colocar den la tercera posición en la celda inferior

'<tr>',⍤1 anteponer esta cadena cada fila

∊ ϵ nlist (aplanar)

'<table>', anteponer esta cadena

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

Pruébalo en línea!

-8 bytes gracias a la papa

-2 bytes gracias a ceilingcat

La smatriz debe declararse como una matriz, no como un puntero, de lo contrario no será editable (configuramos la primera h como anuncio). A la mayoría de los navegadores ni siquiera les importa si su etiqueta de cierre es correcta, por lo que solo cerramos todas las etiquetas con </t>.

R , 73 bytes

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

Pruébalo en línea!

Guardado 7 bytes con un truco sucio - reemplace "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éntesis ... ¡Gracias a @nimi por dos bytes (y una pérdida de genérico)!

Pruébalo en línea!

Sin etiquetas finales, la implementación directa gana a 87 bytes ( Pruébelo en línea ):

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

APL + WIN, 68 63 56 bytes

12 bytes en total guardados gracias a Adám

Solicita el número de filas seguido del número de columnas y la opción de salida sin cierre:

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

Pruébalo en línea! Editar: Guardado 2 bytes gracias a @CowsQuack. Explicación: La primera etapa usa la multiplicación de cadenas de Retina 1 primero para generar el número apropiado de celdas, luego para generar el número apropiado de filas. La segunda etapa luego cambia la primera fila de tds en ths.

Carbón , 33 bytes

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

Pruébalo en línea!

Explicación

<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

La versión K es lo que está incluido en KDB+ 3.5 2017.11.30.

El puerto de la respuesta de Python arriba. Termina siendo 1 byte más debido a tener que alistarse y aplanarse varias veces.

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

Perl 5 -p , 65 54 bytes

-11 bytes gracias al recordatorio de @ msh2108

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

Pruébalo en línea!

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

Pruébalo en línea!

PowerShell Core , 72 68 bytes

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

Pruébalo en línea!

Aquí están mis casos de prueba y 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

¡Gracias, @ mazzy , por los -4 bytes!

Pyth , 40 bytes

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

Pruébalo en línea!

Dart , 45 63 bytes

Solución de trabajo:

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

Pruébelo en línea aquí!

Toma de funciones lambda / anónimas my ncomo parámetros, muestra la salida a STDOUT.

Dado que las tablas con no cerrada <table>, <tr>, <th>, y <td>las etiquetas todavía hacen en los navegadores modernos (por ej., Cromo), la salida es válida.

Solución antigua (rota):

Mi primer intento olvidó cambiar a <td>después de la primera fila:

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

Gracias a @Lynn por señalar eso.

Hojas de cálculo de Google, 66 bytes

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

La entrada está en la celda A1y B1.
No hay nada lujoso, en realidad; son solo Reptfunciones anidadas .
Que no asumen m > n > 0y que los dos son números enteros.

Jalea ,  33  32 bytes

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

Una toma completa del programa rows, columnsque imprime el resultado.

Pruébalo en línea!

hmm, también 32 usando una tabla:

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

J 64 bytes

Otro puerto de la respuesta de Python:

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

PHP, 161 bytes

Pruébalo en línea

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

Explicación

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

Estructura completa de la mesa olvidada<tfooter> <thead>, <tbody>..etc..

Pruebe el ejemplo de la función

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

Explicación

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

Se construye una matriz con todas las etiquetas para la tabla y luego con str_repeatun número que hace referencia a un índice en la matriz, luegostrtr se pasa a la cadena más la matriz.

Yabasic , 124 bytes

Una función anónima que toma entradas de enteros delimitados por espacios y salidas a la consola.

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

Pruébalo en línea!

Adelante (gforth) , 86 bytes

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

Pruébalo en línea!

Explicación

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

Zanahoria , 77 51 bytes

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

(Mientras trabajaba en esto, descubrí un error con h no funcionaba y lo solucioné)

Golfé algunos bytes acortando el html y usando "dividir, unir" en lugar de "reemplazar"

Pruébalo en línea! , use la opción de línea de comandos-d para ver el AST (Nota: esto usa el nuevo intérprete de nodo, por lo que la versión anterior en el sitio web no puede ejecutar esto).

Este programa toma la entrada indexada en 0 y en orden inverso, debido a la naturaleza extraña de Carrot, 3 2imprimiendo así una tabla de 3 × 4.

Ejecute el programa así, ./carrot -f prog.carrot input.txt

Básicamente crea la fila del encabezado, luego las filas de datos en otra celda del jardín (cinta 2D) y las concatena juntas.

La zanahoria funciona en una cinta 2D, llamada jardín. Cada celda en el jardín se compone de tres modos de pila, cadena, flotador, matriz. Hay un valor para cada modo, llamado "pila" (nota: nombre incorrecto). Estas pilas comienzan vacías. Cuando una celda está en un modo particular, los siguientes comandos afectarán a la pila que corresponde a este modo, por ejemplo, en modo flotante, las operaciones afectarán a la pila flotante. Y, por supuesto, hay comandos para cambiar entre modos. Los modos son importantes porque cada operador puede sobrecargarse para cada modo y cada tipo de argumento.

Además, hay dos modos adicionales (estos solo afectan a los comandos, no a la pila directamente), el modo normal y el modo de detención. El modo normal funciona normalmente, donde hay operadores que toman argumentos y afectan directamente a la pila. En el modo de intercalación, (casi) cada carácter se interpreta literalmente como una cadena, y luego se antepone / agrega en consecuencia a la pila. El modo Caret se inicia / finaliza con carets (agregar) o down-carets (anteponer).

La zanahoria comienza en una celda en el jardín, en modo de cadena de apilamiento y en modo de cuidado.

Comenzando en modo caret, la cadena <th>Ase agrega a la cadena de pila inicialmente vacía. Luego sigue el *comando que lo duplica $, la entrada, los tiempos. Luego <tr>se antepone a la cadena de la pila mediante el uso de down-caret v. Esto crea la fila de encabezado de la tabla.

Para crear las filas de datos, duplicamos el encabezado a otra celda. lmueve la IP a la celda vacía derecha y +agrega (^h)la cadena en la celda a la izquierda (esencialmente copiándola a la celda a la derecha). ()inicia una subshell, un nuevo programa Carrot con casi la misma cinta, y ^sale del modo intercalado para que podamos hobtener la cadena en la celda izquierda. Esto se *duplica por ($^F- 1), la siguiente entrada menos 1, veces.

Aún en la celda derecha, Aestablece la matriz de esta celda en su apilamiento dividido por "h". Sune la matriz de la pila "d"y establece la cadena de la pila en este valor. A"h"S"d"Realmente reemplaza hs con ds para formar las filas de datos. Ahora hnos movemos a la celda inicial izquierda.

Ahora agregamos la cadena de pila de la celda a la derecha de esta celda usando +(^l). Todo lo que queda es agregar la <table>etiqueta, por lo que lo hacemos vanteponiéndola.

K (ngn / k) , 51 bytes

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

Pruébalo en línea!

Powershell, 63 bytes

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

guárdelo como new-mntable.ps1. Script de prueba:

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

salida (los espacios adicionales son opcionales):

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

guárdelo como new-mntable.ps1. Script de prueba:

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

salida:

<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 funciona:

1. '<table>h'+'d'*--$args[0] - crear una cadena como <table>hddd...
2. 'h|d'- búsqueda ho dcaracteres en la cadena para reemplazar
3. '<tr>'+'<t$0>A'*$args[1] - reemplace cada char con una cadena como <tr><t$0>A<t$0>A...
4. donde $0es capturado group[0]- el char en el -replace.

Powershell, 65 bytes, scriptblock

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

guárdelo como new-mntable.ps1. Script de prueba:

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

salida:

<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