Input:

Due numeri decimali me nche indicano rispettivamente il numero di righe e colonne della tabella. me nsono maggiori o uguali a 1.

Produzione :

Una tabella in HTML che ha m righe e n colonne.

La tabella dovrebbe essere visualizzabile da un browser moderno a tua scelta. La maggior parte dei browser visualizzerà tutto correttamente anche se i tag non sono chiusi. Il rientro e la spaziatura corretti sono facoltativi.

Dovrebbe esserci almeno un carattere stampabile (non bianco) in ogni cella.

Le celle sulla prima riga dovrebbero usare i <th>tag mentre quelle sulle seguenti righe dovrebbero usare i <td>tag.

Condizioni di vittoria:

Questo è code-golf, quindi vince il codice sorgente più breve per ogni lingua.

Esempio di input:

2 3

Esempio di output:

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

Programma completo. Richiede stdin per l'elenco a due elementi [m,n]e stampa XHTML rigoroso su stdout.

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

Sessione di esempio:

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

Provalo online!

Spiegazione:

(... ).Render Rendi il seguente elemento HTML:

 ⎕NEW _.Table (... ) una nuova tabella con i seguenti parametri:

  (... ) ⍬ 1 il seguente contenuto, nessuno stile speciale, 1 riga di intestazione:

   ⎕⍴0 l'input valutato rimodella zero (ovvero una matrice di zeri m-row, n-column)

JavaScript (ES6), 70 byte

Salvato 2 byte grazie a @RickHitchcock

Accetta input nella sintassi del curry (m)(n).

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

Provalo online!

dimostrazione

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

Provalo online! Presuppone mnon è zero.

Tela , 31 byte

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

Provalo qui! o provalo visualizzato!

Dopo aver corretto 2 bug (ಠ_ಠ) nell'interprete, funzionano anche 30 byte

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

Provalo online!

Spiegazione

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

Esegui ed esegui il debug

Disimballato, non golfato e commentato, sembra così.

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

Esegui questo

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

Provalo online.

Spiegazione:

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

Programma completo. Richiede stdin per l'elenco a due elementi [m, n] e stampa i tag non chiusi su stdout.

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

Provalo online!

⊂'<th>A' racchiudere questa stringa per trattarla nel suo insieme

⎕⍴ pronta per le dimensioni e ciclicamente r eshape la singola cella di una matrice di tali dimensioni

…⍀ inserire cumulativamente la seguente funzione tra ciascuna coppia verticale di celle:

 {'d'}@3 ignora la cella superiore; posizionare din terza posizione nella cella inferiore

'<tr>',⍤1 anteporre questa stringa ogni riga

∊ ϵ nlist (appiattisci)

'<table>', anteporre questa stringa

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

Provalo online!

-8 byte grazie alla patata

-2 byte grazie a ceilingcat

L' sarray deve essere dichiarato come array non come puntatore, altrimenti non sarà modificabile (impostiamo la prima h su ad). Alla maggior parte dei browser non importa nemmeno se il tag di chiusura è corretto, quindi chiudiamo tutti i tag con </t>.

R , 73 byte

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

Provalo online!

Salvataggio di 7 byte con un hack sporco - sostituire "rep" con "<".

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

Quante parentesi ... Grazie a @nimi per due byte (e una perdita di genericità)!

Provalo online!

Senza tag di fine l'implementazione diretta vince a 87 byte ( provalo online ):

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

APL + WIN, 68 63 56 byte

12 byte in totale salvati grazie ad Adám

Richiede il numero di righe seguito dal numero di colonne e visualizza l'opzione di non chiusura:

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

Retina , 56 54 byte

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

Provalo online! Modifica: salvato 2 byte grazie a @CowsQuack. Spiegazione: Il primo stadio utilizza prima la moltiplicazione di stringhe di Retina 1 per generare il numero appropriato di celle, quindi per generare il numero appropriato di righe. Il secondo stadio cambia quindi la prima riga di tds in ths.

Carbone , 33 byte

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

Provalo online!

Spiegazione

<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

La versione K è qualsiasi cosa sia inclusa KDB+ 3.5 2017.11.30 .

La risposta di Port of the Python sopra. Termina con 1 byte in più a causa della necessità di arruolarsi e appiattirsi più volte.

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

Perl 5 -p , 65 54 byte

-11 byte grazie al promemoria di @ msh2108

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

Provalo online!

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

Provalo online!

PowerShell Core , 72 68 byte

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

Provalo online!

Ecco i miei casi di test e gli output previsti (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

Grazie, @ mazzy , per i -4 byte!

Pyth , 40 byte

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

Provalo online!

Dardo , 45 63 byte

Soluzione di lavoro:

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

Provalo online qui!

Funzione lambda / anonima che assume me ncome parametri, visualizza l'output a STDOUT.

Dal momento che le tabelle con non chiusa <table>, <tr>, <th>, e <td>tag rendono ancora nei browser moderni (es., Chrome), l'uscita è valida.

Vecchia soluzione (rotta):

Il mio primo tentativo ha dimenticato di passare a <td>dopo la prima riga:

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

Grazie a @Lynn per averlo segnalato.

Fogli Google, 66 byte

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

L'input è nella cella A1e B1.
Non c'è niente di speciale, davvero; sono solo Reptfunzioni nidificate .
Si fa assumere m > n > 0e che sono entrambi interi.

Gelatina ,  33  32 byte

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

Una presa programma completo rows, columnsche stampa il risultato.

Provalo online!

hmm, anche 32 usando una tabella:

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

J, 64 byte

Un'altra porta della risposta Python:

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

PHP, 161 byte

Provalo online

Codice

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

Spiegazione

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

La struttura della tabella completa è stata dimenticata<tfooter> <thead>, <tbody>..etc..

Prova un esempio della funzione

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

Spiegazione

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

Un array con tutti i tag per la tavola è costruito e poi con str_repeatè scritto un numero riferendosi ad un indice nella matrice, quindi per strtrla stringa più il matrice viene passata

Yabasic , 124 byte

Una funzione anonima che accetta input come numeri interi delimitati da spazio e output sulla 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>"

Provalo online!

Forth (gforth) , 86 byte

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

Provalo online!

Spiegazione

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

Carota , 77 51 byte

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

(Mentre lavoravo su questo, ho scoperto un bug che hnon funzionava e l'ho risolto)

Golf di alcuni byte accorciando l'html e usando "Dividi, Unisci" invece di "Sostituisci"

Provalo online! , utilizzare l'opzione della riga di comando-d per visualizzare l'AST (Nota: questo utilizza il nuovo interprete di nodi, quindi la versione precedente sul sito Web non può eseguirlo.)

Questo programma accetta l'input indicizzato 0 e in ordine inverso, a causa della strana natura di Carrot, 3 2stampando così una tabella 3 × 4.

Esegui il programma in questo modo, ./carrot -f prog.carrot input.txt

Fondamentalmente crea la riga di intestazione, quindi le righe di dati su un'altra cella del giardino (nastro 2D) e le concatena insieme.

La carota lavora su un nastro 2D, chiamato giardino. Ogni cella del giardino è composta da tre modalità stack, stringa, float, array. C'è un valore per ogni modalità, chiamato "stack" (nota: nome errato). Queste pile iniziano vuote. Quando una cella si trova in una modalità particolare, i seguenti comandi influenzeranno lo stack che corrisponde a questa modalità, ad esempio in modalità float, le operazioni influenzeranno lo stack float. E, naturalmente, ci sono comandi per passare da una modalità all'altra. Le modalità sono importanti perché ogni operatore può essere sovraccaricato per ciascuna modalità e ciascun tipo di argomento.

Inoltre, ci sono due modalità aggiuntive (queste riguardano solo i comandi, non lo stack direttamente), la modalità normale e la modalità di inserimento. La modalità normale funziona normalmente, dove ci sono operatori che accettano argomenti e influiscono direttamente sullo stack. In modalità cursore, (quasi) ogni personaggio viene interpretato letteralmente come una stringa e successivamente viene anteposto / aggiunto di conseguenza alla pila. La modalità Caret viene avviata / terminata con punti di inserimento (append) o down-caret (anteponi).

La carota inizia in una cella sul giardino, in modalità stack-string e in modalità caret.

A partire dalla modalità punto di inserimento, la stringa <th>Aviene aggiunta alla stringa di stack inizialmente vuota. Quindi segue il *comando che lo duplica $, l'input, i tempi. Quindi <tr>viene anteposto alla stringa di stack mediante l'uso del cursore inferiore v. Questo crea la riga di intestazione della tabella.

Per creare le righe di dati, dupliciamo l'intestazione in un'altra cella. lsposta l'IP nella cella vuota a destra e +aggiunge (^h)la stringa nella cella a sinistra (essenzialmente copiandola nella cella a destra). ()avvia una subshell, un nuovo programma Carrot con quasi lo stesso nastro ed ^esce dalla modalità punto di inserimento in modo da poter hottenere la stringa nella cella sinistra. Questo viene quindi *duplicato da($^F- 1) , il prossimo input meno 1, volte.

Sempre nella cella giusta, Aimposta l'array di questa cella sulla sua suddivisione in stack "h". Sunisce l'array dello stack "d"e imposta la stringa dello stack su questo valore. A"h"S"d"sostituisce davvero hs con ds per formare le righe di dati. Ora hci spostiamo sulla cella iniziale sinistra.

Ora aggiungiamo la stringa di stack della cella a destra a questa cella usando +(^l). Non resta che aggiungere il <table>tag, quindi lo facciamo vanteponendolo.

K (ngn / k) , 51 byte

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

Provalo online!

Powershell, 63 byte

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

salvalo come new-mntable.ps1. Script di prova:

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

output (gli spazi extra sono opzionali):

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

salvalo come new-mntable.ps1. Script di prova:

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

produzione:

<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

Come funziona:

1. '<table>h'+'d'*--$args[0] - crea una stringa come <table>hddd...
2. 'h|d'- cerca ho dcaratteri nella stringa per la sostituzione
3. '<tr>'+'<t$0>A'*$args[1] - Sostituisci ogni carattere con stringhe come <tr><t$0>A<t$0>A...
4. dove $0viene catturato group[0]- il carattere nel -replace.

Powershell, 65 byte, scriptblock

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

salvalo come new-mntable.ps1. Script di prova:

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

produzione:

<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