Eingabe:

Zwei Dezimalzahlen mund ndiese geben jeweils die Anzahl der Zeilen und Spalten der Tabelle an. mund nsind größer als oder gleich 1.

Ausgabe :

Eine Tabelle in HTML mit m Zeilen und n Spalten.

Die Tabelle sollte von einem modernen Browser Ihrer Wahl angezeigt werden können. Die meisten Browser zeigen alles korrekt an, auch wenn Tags nicht geschlossen sind. Die richtige Einrückung und der richtige Abstand sind optional.

In jeder Zelle sollte mindestens ein druckbares Zeichen (ohne Leerzeichen) vorhanden sein.

Zellen in der ersten Zeile sollten <th>Tags verwenden, während die Zellen in den folgenden Zeilen <td>Tags verwenden sollten.

Gewinnbedingung:

Das ist Code-Golf, also gewinnt der kürzeste Quellcode für jede Sprache.

Eingabebeispiel:

2 3

Ausgabebeispiel:

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

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

APL (Dyalog Unicode) mit MiServer 3.0 , 31 30 Byte ^SBCS

Volles Programm. Fordert stdin zur Eingabe der Liste mit zwei Elementen auf [m,n]und gibt striktes XHTML an stdout aus.

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

Beispielsitzung:

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

Probieren Sie es online!

Erläuterung:

(… ).Render Rendern Sie das folgende HTML-Element:

 ⎕NEW _.Table (… ) Eine neue Tabelle mit folgenden Parametern:

  (… ) ⍬ 1 Folgenden Inhalt, kein spezielles Styling, 1 Kopfzeile:

   ⎕⍴0 ausgewertete Eingabe formt Null um (dh eine m-Zeilen-, n-Spaltenmatrix von Nullen)

JavaScript (ES6), 70 Byte

2 Bytes dank @RickHitchcock gespart

Übernimmt Eingaben in der Currying-Syntax (m)(n).

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

Probieren Sie es 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

Probieren Sie es online! Angenommen, mist nicht Null.

Canvas , 31 Byte

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

Probieren Sie es hier aus! oder versuchen Sie es visualisiert!

Nach dem Beheben von 2 Fehlern (ಠ_ಠ) im Interpreter funktionieren auch 30 Bytes

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

Probieren Sie es online!

Erläuterung

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

Führen Sie es aus und debuggen Sie es

Entpackt, ungolfed und kommentiert sieht es so aus.

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

Führen Sie dieses aus

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

Probieren Sie es online aus.

Erläuterung:

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 danke an ngn.

Volles Programm. Fordert stdin zur Eingabe der Liste mit zwei Elementen [m, n] auf und druckt nicht geschlossene Tags nach stdout.

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

Probieren Sie es online!

⊂'<th>A' Schließen Sie diese Zeichenfolge ein, um sie als Ganzes zu behandeln

⎕⍴ Aufforderung für Abmessungen und zyklisch r die einzelne Zelle zu einer Matrix von dieser Größe eshape

…⍀ Fügen Sie kumulativ die folgende Funktion zwischen jedem vertikalen Zellenpaar ein:

 {'d'}@3 ignoriere obere Zelle; Platzieren Sie es dan der 3. Stelle in der unteren Zelle

'<tr>',⍤1 Stellen Sie diese Zeichenfolge in jeder Zeile voran

∊ ϵ nlist (Abflachen)

'<table>', stellen Sie diese Zeichenfolge voran

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

Probieren Sie es online!

-8 Bytes dank Kartoffel

-2 Bytes dank Ceilingcat

Das sArray muss als Array deklariert werden, nicht als Zeiger, da es sonst nicht bearbeitet werden kann (wir setzen das erste h auf ad). Die meisten Browser kümmern sich nicht einmal darum, ob Ihr schließendes Tag korrekt ist. Deshalb schließen wir einfach alle Tags mit </t>.

R , 73 Bytes

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

Probieren Sie es online!

7 Bytes mit einem schmutzigen Hack gespeichert - ersetzen Sie "rep" durch "<".

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

So viele Klammern ... Danke an @nimi für zwei Bytes (und einen Verlust an Generizität)!

Probieren Sie es online!

Ohne End-Tags gewinnt die direkte Implementierung mit 87 Bytes ( Online testen ):

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

APL + WIN, 68 63 56 Bytes

Insgesamt 12 Bytes gespart dank Adám

Fordert zur Eingabe der Anzahl der Zeilen gefolgt von der Anzahl der Spalten auf und gibt die Option ohne Abschluss aus:

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

Netzhaut , 56 54 Bytes

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

Probieren Sie es online! Bearbeiten: 2 Bytes dank @CowsQuack gespeichert. Erläuterung: In der ersten Stufe wird die String-Multiplikation von Retina 1 zuerst verwendet, um die entsprechende Anzahl von Zellen und dann die entsprechende Anzahl von Zeilen zu generieren. Die zweite Stufe ändert dann die erste Reihe von tds in ths.

Holzkohle , 33 Bytes

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

Probieren Sie es online!

Erläuterung

<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

K-Version ist was auch immer enthalten ist KDB+ 3.5 2017.11.30.

Port of the Python Antwort oben. Endet 1 Byte länger, weil Sie sich mehrmals registrieren und reduzieren müssen.

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

Perl 5 -p , 65 54 Bytes

-11 Bytes dank der Erinnerung von @ msh2108

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

Probieren Sie es 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;}

Probieren Sie es online!

PowerShell Core , 72 bis 68 Byte

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

Probieren Sie es online!

Hier sind meine Testfälle und erwarteten Ausgaben (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

Danke, @ mazzy , für die -4 Bytes!

Pyth , 40 Bytes

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

Probieren Sie es online!

Dart , 45 63 Bytes

Arbeits lösung:

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

Probieren Sie es hier online aus!

Lambda / anonyme Funktion, die mund nals Parameter verwendet, zeigt die Ausgabe an STDOUT.

Da die Tabellen mit unclosed <table>, <tr>, <th>, und <td>Tags macht noch in modernen Browsern (ex., Chrome), ist der Ausgang gültig.

Alte (kaputte) Lösung:

Mein erster Versuch vergaß <td>nach der ersten Reihe zu wechseln :

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

Vielen Dank an @Lynn für den Hinweis.

Google Sheets, 66 Bytes

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

Die Eingabe erfolgt in Zelle A1und B1.
Es ist wirklich nichts Besonderes; Es sind nur verschachtelte ReptFunktionen.
Es wird davon ausgegangen, m > n > 0dass beide ganze Zahlen sind.

Jelly ,  33  32 Bytes

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

Eine vollständige Programmaufnahme rows, columnsdie das Ergebnis druckt.

Probieren Sie es online!

hmm, auch 32 mit einer Tabelle:

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

J, 64 Bytes

Ein weiterer Port der Python-Antwort:

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

PHP, 161 Bytes

Probieren Sie es online aus

Code

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

Erläuterung

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

Vollständige Tabellenstruktur vergessen<tfooter> <thead>, <tbody>..etc..

Probieren Sie ein Beispiel für die Funktion

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

Erläuterung

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

Ein Array mit allen Tags für die Tabelle, die erstellt wurde, und str_repeateiner Zahl, die auf einen Index im Array verweist, wird geschrieben und anschließend an strtrdie Zeichenfolge plus das Array übergeben

Yabasic , 124 Bytes

Eine anonyme Funktion, die Eingaben von durch Leerzeichen getrennten Ganzzahlen und Ausgaben an die Konsole annimmt.

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

Probieren Sie es online!

Viertens (gviertens) , 86 Bytes

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

Probieren Sie es online!

Erläuterung

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

Karotte , 77 51 Bytes

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

(Während ich daran arbeitete, entdeckte ich einen Fehler, der hnicht funktionierte und behebte ihn)

Einige Bytes durch Kürzung des HTML-Codes und Verwendung von "Teilen, Verbinden" anstelle von "Ersetzen" abgegolten

Probieren Sie es online! Verwenden Sie die Befehlszeilenoption -d, um den AST anzuzeigen.

Dieses Programm verwendet die Eingabe 0-indiziert und in umgekehrter Reihenfolge, da Carrot seltsam ist, und 3 2druckt so eine 3 × 4-Tabelle.

Führen Sie das Programm wie folgt aus: ./carrot -f prog.carrot input.txt

Im Grunde genommen erstellt die Kopfzeile dann die Datenzeilen in einer anderen Zelle des Gartens (2D-Band) und verkettet sie miteinander.

Karotte arbeitet auf einem 2D-Band, Garten genannt. Jede Zelle im Garten besteht aus drei Stapelmodi: String, Float und Array. Für jeden Modus gibt es einen Wert, der als "Stapel" bezeichnet wird (Anmerkung: falsche Bezeichnung). Diese Stapel beginnen leer. Befindet sich eine Zelle in einem bestimmten Modus, wirken sich die folgenden Befehle auf den Stapel aus, der diesem Modus entspricht. Beispielsweise wirken sich die Vorgänge im Float-Modus auf den Stapel-Float aus. Und natürlich gibt es Befehle zum Umschalten zwischen den Modi. Die Modi sind wichtig, da jeder Operator für jeden Modus und jeden Argumenttyp überladen werden kann.

Darüber hinaus gibt es zwei zusätzliche Modi (diese wirken sich nur auf die Befehle aus, nicht direkt auf den Stapel), den normalen Modus und den Caret-Modus. Der Normalmodus funktioniert normal, wenn Operatoren Argumente aufnehmen und den Stapel direkt beeinflussen. Im Caret-Modus wird (fast) jedes Zeichen buchstäblich als Zeichenfolge interpretiert und später dem Stapel entsprechend vorangestellt / angehängt. Der Caret-Modus wird mit Carets (anhängen) oder Downcarets (voranstellen) gestartet / beendet.

Karotte beginnt in einer Zelle im Garten, im Stapelmodus und im Caret-Modus.

Beginnend im Caret-Modus wird der String <th>Adem anfänglich leeren Stack-String hinzugefügt. Dann folgt der *Befehl, der es dupliziert $, die Eingabe, mal. Dann <tr>wird der Stack-Zeichenkette mit dem Downcaret vorangestellt v. Dadurch wird die Kopfzeile der Tabelle erstellt.

Um die Datenzeilen zu erstellen, duplizieren wir den Header in eine andere Zelle. Verschiebt ldie IP- +Adresse in die rechte leere Zelle und hängt (^h)die Zeichenfolge in der Zelle links an (im Wesentlichen durch Kopieren in die rechte Zelle). ()Startet eine Subshell, ein neues Carrot-Programm mit fast demselben Band, und beendet den ^Caret-Modus, damit wir hden String in der linken Zelle finden können. Dies wird dann *durch ($^F- 1)die nächste Eingabe minus 1-mal dupliziert .

ASetzt das Array dieser Zelle in der rechten Zelle auf die Stapelung, die durch geteilt wird "h". SVerbindet das Stack-Array mit "d"und setzt den Stack-String auf diesen Wert. A"h"S"d"Ersetzt einfach hs durch ds, um die Datenzeilen zu bilden. Jetzt gehen hwir zur linken Startzelle.

Nun hängen wir die Stapelzeichenfolge der Zelle mit rechts an diese Zelle an +(^l). Alles, was übrig bleibt, ist das Hinzufügen des <table>Tags. vDazu müssen wir ihm voranstellen.

K (ngn / k) , 51 Bytes

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

Probieren Sie es online!

Powershell, 63 Bytes

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

Speichern Sie es als new-mntable.ps1. Testskript:

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

Ausgabe (zusätzliche Leerzeichen sind optional):

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

Speichern Sie es als new-mntable.ps1. Testskript:

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

Ausgabe:

<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

Wie es funktioniert:

1. '<table>h'+'d'*--$args[0] - Erstelle einen String wie <table>hddd...
2. 'h|d'- Suche hoder dZeichen in der Zeichenfolge zum Ersetzen
3. '<tr>'+'<t$0>A'*$args[1] - Ersetze jedes Zeichen mit einem String <tr><t$0>A<t$0>A...
4. wo $0ist ein gefangener group[0]- der char in der -replace.

Powershell, 65 Bytes, scriptblock

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

Speichern Sie es als new-mntable.ps1. Testskript:

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

Ausgabe:

<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