Contribution :

Deux entiers décimaux met nqui donnent respectivement le nombre de lignes et de colonnes du tableau. met nsont supérieurs ou égaux à 1.

Sortie:

Un tableau en HTML qui a m lignes et n colonnes.

Le tableau doit être affichable par un navigateur moderne de votre choix. La plupart des navigateurs afficheront tout correctement, même si les balises ne sont pas fermées. Un retrait et un espacement appropriés sont facultatifs.

Il doit y avoir au moins un caractère imprimable (non blanc) dans chaque cellule.

Les cellules de la première ligne doivent utiliser des <th>balises tandis que celles des lignes suivantes doivent utiliser des <td>balises.

Condition de victoire:

Il s'agit de code-golf, donc le code source le plus court pour chaque langue l'emporte.

Exemple d'entrée:

2 3

Exemple de sortie:

<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) avec MiServer 3.0 , 31 30 octets ^SBCS

Programme complet. Invite stdin pour la liste à deux éléments [m,n]et imprime XHTML strict sur stdout.

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

Exemple de session:

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

Essayez-le en ligne!

Explication:

(… ).Render Rendez l'élément HTML suivant:

 ⎕NEW _.Table (… ) Une nouvelle table avec les paramètres suivants:

  (… ) ⍬ 1 Le contenu suivant, sans style particulier, 1 ligne d'en-tête:

   ⎕⍴0 l'entrée évaluée remodèle zéro (c'est-à-dire une matrice de z lignes à m colonnes et n)

JavaScript (ES6), 70 octets

Enregistré 2 octets grâce à @RickHitchcock

Prend une entrée dans la syntaxe de curry (m)(n).

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

Essayez-le en ligne!

Démo

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 octets

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

Essayez-le en ligne! Suppose que ce mn'est pas zéro.

Toile , 31 octets

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

Essayez-le ici! ou Essayez-le visualisé!

Après avoir corrigé 2 bugs (ಠ_ಠ) dans l'interpréteur, 30 octets fonctionnent aussi

JavaScript, 65 octets

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

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

05AB1E , 30 octets

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

Essayez-le en ligne!

Explication

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

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

Exécuter et déboguer

Déballé, non golfé et commenté, il ressemble à ceci.

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

Exécutez celui-ci

Java 10, 139 133 102 octets

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

Essayez-le en ligne.

Explication:

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

-4 grâce à ngn.

Programme complet. Invite stdin pour la liste à deux éléments [m, n] et imprime les balises non fermées sur stdout.

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

Essayez-le en ligne!

⊂'<th>A' joindre cette chaîne pour la traiter dans son ensemble

⎕⍴ invite de dimensions et de manière cyclique r Eshape la cellule unique à une matrice de cette taille ,

…⍀ insérez cumulativement la fonction suivante entre chaque paire verticale de cellules:

 {'d'}@3 ignorer la cellule supérieure; placer den 3e position dans la cellule du bas

'<tr>',⍤1 ajouter cette chaîne à chaque ligne

∊ ϵ nlist (aplatir)

'<table>', ajouter cette chaîne

C (gcc) , 107 99 98 97 octets

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

Essayez-le en ligne!

-8 octets grâce à la pomme de terre

-2 octets grâce au plafond

Le stableau doit être déclaré comme un tableau et non comme un pointeur, sinon il ne sera pas modifiable (nous définissons le premier h sur ad). La plupart des navigateurs ne se soucient même pas de savoir si votre balise de fermeture est correcte, nous fermons donc toutes les balises avec </t>.

R , 73 octets

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

Essayez-le en ligne!

7 octets enregistrés avec un hack sale - remplacez "rep" par "<".

Haskell , 109 107 103 octets

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

Tant de parenthèses… Merci à @nimi pour deux octets (et une perte de généricité)!

Essayez-le en ligne!

Sans balises de fin, l'implémentation directe gagne à 87 octets ( essayez-le en ligne ):

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

APL + WIN, 68 63 56 octets

12 octets au total économisés grâce à Adám

Demande le nombre de lignes suivi du nombre de colonnes et affiche l'option de non-fermeture:

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

Rétine , 56 54 octets

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

Essayez-le en ligne! Edit: sauvé 2 octets grâce à @CowsQuack. Explication: La première étape utilise la multiplication de chaînes de Retina 1 d'abord pour générer le nombre approprié de cellules, puis pour générer le nombre approprié de lignes. La deuxième étape transforme ensuite la première rangée de tds en ths.

Fusain , 33 octets

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

Essayez-le en ligne!

Explication

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

La version K est tout ce qui est inclus KDB+ 3.5 2017.11.30.

Port de la réponse Python ci-dessus. Finit par être 1 octet de plus en raison de devoir enrôler et aplatir plusieurs fois.

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

Perl 5 -p , 65 54 octets

-11 octets grâce au rappel de @ msh2108

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

Essayez-le en ligne!

C # (.NET Core) , 130 octets

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

Essayez-le en ligne!

PowerShell Core , 72 68 octets

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

Essayez-le en ligne!

Voici mes cas de test et sorties attendues (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

Merci, @ mazzy , pour les -4 octets!

Pyth , 40 octets

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

Essayez-le en ligne!

Dart , 45 63 octets

Solution de travail:

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

Essayez-le en ligne ici!

Fonction lambda / anonyme prenant met ncomme paramètres, affiche la sortie versSTDOUT .

Depuis tables avec unclosed <table>, <tr>, <th>et<td> balises rendent toujours dans les navigateurs modernes (ex., Chrome), la sortie est valide.

Ancienne solution (cassée):

Ma première tentative a oublié de passer <td>après la première ligne:

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

Merci à @Lynn de l'avoir signalé.

Google Sheets, 66 octets

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

L'entrée est dans la cellule A1et B1.
Il n'y a rien d'extraordinaire, vraiment; ce sont juste des Reptfonctions imbriquées .
Il ne suppose m > n > 0et qu'ils sont tous les deux entiers.

Gelée ,  33  32 octets

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

Une prise de programme complète rows, columnsqui imprime le résultat.

Essayez-le en ligne!

hmm, également 32 à l'aide d'une table:

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

J, 64 octets

Un autre port de la réponse Python:

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

PHP, 161 octets

Essayez-le en ligne

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

Explication

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 octets

Structure de table complète oubliée<tfooter> <thead>, <tbody>..etc..

Essayez un exemple de la fonction

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

Explication

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

Un tableau avec toutes les balises de la table qu'il est construit, puis avec str_repeatun nombre se référant à un index dans le tableau est écrit, puis à strtrla chaîne plus le tableau est passé

Yabasic , 124 octets

Fonction anonyme qui prend les entrées sous forme d'entiers délimités par des espaces et les renvoie vers la 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>"

Essayez-le en ligne!

Forth (gforth) , 86 octets

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

Essayez-le en ligne!

Explication

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

Carotte , 77 51 octets

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

(En travaillant là-dessus, j'ai découvert un bogue qui hne fonctionnait pas et je l'ai corrigé)

Golfé quelques octets en raccourcissant le code HTML ainsi qu'en utilisant "scinder, joindre" au lieu de "remplacer"

Essayez-le en ligne! , utilisez l'option de ligne de commande-d pour voir l'AST (Remarque: ceci utilise le nouvel interpréteur de noeud, donc l'ancienne version sur le site Web ne peut pas l'exécuter.)

Ce programme prend l'entrée indexée 0 et dans l'ordre inverse, en raison de la nature étrange de Carrot, 3 2imprimant ainsi un tableau 3 × 4.

Exécutez le programme comme ça, ./carrot -f prog.carrot input.txt

Fondamentalement, crée la ligne d'en-tête, puis les lignes de données sur une autre cellule du jardin (bande 2D), et les concatène ensemble.

Carrot travaille sur une bande 2D, appelée jardin. Chaque cellule du jardin est composée de trois modes de pile, chaîne, flottant, tableau. Il existe une valeur pour chaque mode, appelée "pile" (remarque: impropre). Ces piles commencent vides. Lorsqu'une cellule est dans un mode particulier, les commandes suivantes affecteront la pile qui correspond à ce mode, par exemple en mode flottant, les opérations affecteront le flotteur de pile. Et bien sûr, il existe des commandes pour basculer entre les modes. Les modes sont importants car chaque opérateur peut être surchargé pour chaque mode et chaque type d'argument.

De plus, il existe deux modes supplémentaires (ceux-ci n'affectent que les commandes, pas directement la pile), le mode normal et le mode caret. Le mode normal fonctionne normalement, où des opérateurs acceptent des arguments et affectent directement la pile. En mode accent circonflexe, (presque) chaque caractère est interprété littéralement comme une chaîne et est ensuite ajouté / ajouté en conséquence à la pile. Le mode insertion est démarré / terminé avec des accents (ajout) ou vers le bas (ajout).

La carotte commence dans une cellule du jardin, en mode pile-chaîne et en mode caret.

À partir du mode caret, la chaîne <th>Aest ajoutée à la chaîne de pile initialement vide. Suit ensuite la *commande qui le duplique $, l'entrée, les temps. Puis <tr>est ajouté à la chaîne de pile par l'utilisation du curseur bas v. Cela crée la ligne d'en-tête de la table.

Pour créer les lignes de données, nous dupliquons l'en-tête dans une autre cellule. ldéplace l'IP vers la cellule vide de droite et +ajoute (^h)la chaîne dans la cellule à gauche (en la copiant essentiellement dans la cellule de droite). ()démarre un sous-shell, un nouveau programme Carrot avec presque la même bande, et ^quitte le mode caret afin que nous puissions hobtenir la chaîne dans la cellule de gauche. Il est ensuite *dupliqué par ($^F- 1), la prochaine entrée moins 1 fois.

Toujours dans la cellule de droite, Adéfinit le tableau de cette cellule sur son empilement divisé par "h". Srejoint le tableau de pile par "d"et définit la chaîne de pile à cette valeur. A"h"S"d"remplace vraiment hs par ds pour former les lignes de données. Passons maintenant hà la cellule de départ de gauche.

Maintenant, nous ajoutons la chaîne de pile de la cellule à droite de cette cellule en utilisant +(^l). Il ne reste plus qu'à ajouter la <table>balise, nous le faisons donc en la vajoutant au préalable.

K (ngn / k) , 51 octets

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

Essayez-le en ligne!

Powershell, 63 octets

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

enregistrez-le sous new-mntable.ps1. Script de test:

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

sortie (les espaces supplémentaires sont facultatifs):

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

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

enregistrez-le sous new-mntable.ps1. Script de test:

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

sortie:

<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

Comment ça marche:

1. '<table>h'+'d'*--$args[0] - créer une chaîne comme <table>hddd...
2. 'h|d'- chercher h ou dcaractères dans la chaîne pour remplacer
3. '<tr>'+'<t$0>A'*$args[1] - remplacez chaque caractère par une chaîne comme <tr><t$0>A<t$0>A...
4. où $0est capturé group[0]- l'omble dans le -replace.

Powershell, 65 octets, scriptblock

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

enregistrez-le sous new-mntable.ps1. Script de test:

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

sortie:

<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