Producir una tabla am * n en HTML

22

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

patata
fuente
Los comentarios no son para discusión extendida; Esta conversación se ha movido al chat .
Mego

Respuestas:

7

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)

Adán
fuente
6

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

Arnauld
fuente
3

JavaScript, 65 bytes

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

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

l4m2
fuente
recursividad ¡bonito!
mazzy
2

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
Emigna
fuente
2

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

recursivo
fuente
2

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
Kevin Cruijssen
fuente
Creo que hay un pequeño error tipográfico, escribiste "th" dos veces.
papa
@ patata Ah, tienes razón. El código en sí y el enlace TIO eran correctos, pero mi explicación tenía un error tipográfico. Debería arreglarse ahora, gracias.
Kevin Cruijssen
(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 bytes) Me pareció interesante, pero no valió la pena dada su puntuación actual. Probablemente puedas jugar un poco tu respuesta usando ideas como la mutable m.
Olivier Grégoire
@ OlivierGrégoire Inicialmente tuve una modificable m, pero debido a las <th>/ <td>diferencias no importaría. Todavía necesito verificar si es la primera iteración del bucle externo, en cuyo caso necesito ambos jy m, y necesito hacer el bucle interno varias veces, en cuyo caso necesito iy n. En lugar de ir hacia arriba desde 0 y verificar j<2, podría ir hacia atrás y verificar i>m-2, pero sería +1 byte en lugar de -1. Sin embargo, su enfoque de usar dos bucles separados con modificables my de nhecho es interesante. :)
Kevin Cruijssen
2

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

Adán
fuente
@ngn Todo listo. Gracias. Relevante .
Adám
2

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

LambdaBeta
fuente
Todavía funciona bien si elimina el </t>que aparece dos veces y -8 bytes.
papa
Puede eliminar 4 bytes más si mueve la salida de la nueva fila al bucle interno (también, evita una fila vacía): ¡ Pruébelo en línea!
ErikF
2

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

JayCe
fuente
1

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>"
Angs
fuente
1

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'
Graham
fuente
@ Adám Demasiado gatillo feliz, me temo. Se ve bien ahora?
Graham
Sí, pero no necesita los parens finales t,,((⎕-1),n←⎕)⍴ro las dos primeras comas.
Adám
@ Adám Gracias. No es mi día debe ser el calor (28C)!
Graham
Fusión hy ren la expresión principal:'<table>'t(n⍴⊂'<th>A')t,,((⎕-1),n←⎕)⍴⊂'<td>A'
Adám
Algo no está bien. Solo inserta uno <tr>para el cuerpo. Cada fila necesita un <tr>.
Adám
1

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.

Neil
fuente
Si sabe que la entrada se dividirá por espacios, entonces debería poder usar en .lugar de\d
Kritixi Lithos
1

Carbón , 33 bytes

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

Pruébalo en línea!

Explicación

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

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")}
hoosierEE
fuente
1

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!

Xcali
fuente
Ahórrate algunos bytes. Por un ejemplo en el desafío, puede soltar el .'</table>'.
msh210
1

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!

Emanuel Vintilă
fuente
1

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!

Jeff Freeman
fuente
1
Los soportes son opcionales. Tratar Function F($m,$n){'<table><tr>'+'<th>A'*$n+('<tr>'+'<td>A'*$n)*--$m}.
mazzy
0

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.

vasilescur
fuente
0

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.

Tostadas de ingeniero
fuente
0

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»
Jonathan Allan
fuente
0

J 64 bytes

Otro puerto de la respuesta de Python:

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

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.

Francisco Hahn
fuente
0

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!

Taylor Scott
fuente
Esto no produce las etiquetas <td>.
papa
@ patata - ahh, no había visto eso. Está corregido
Taylor Scott
0

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                      
reffu
fuente
0

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.

Kritixi Lithos
fuente
0

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
mazzy
fuente