Produire une table am * n en HTML

22

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

Patate
la source
Les commentaires ne sont pas pour une discussion approfondie; cette conversation a été déplacée vers le chat .
Mego

Réponses:

7

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)

Adam
la source
6

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

Arnauld
la source
3

JavaScript, 65 octets

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

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

l4m2
la source
récursivité. agréable!
mazzy
2

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
Emigna
la source
2

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

récursif
la source
2

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
Kevin Cruijssen
la source
Je pense qu'il y a une petite faute de frappe, tu as écrit "th" deux fois.
pomme de terre
@potato Ah, vous avez raison. Le code lui-même et le lien TIO étaient corrects, mais mon explication comportait une faute de frappe. Devrait être corrigé maintenant, merci.
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 octets) J'ai trouvé celui-ci intéressant, mais n'en valait pas la peine compte tenu de votre score actuel. Vous pouvez probablement jouer un peu à votre réponse en utilisant des idées comme le mutable m.
Olivier Grégoire
@ OlivierGrégoire J'avais initialement un modifiable m, mais à cause des <th>/ <td>différences ça n'aurait pas d'importance. Je dois encore vérifier s'il s'agit de la première itération de la boucle externe, auquel cas j'ai besoin des deux jet m, et je dois répéter la boucle interne plusieurs fois, auquel cas j'ai besoin de iet n. Au lieu d'aller vers le haut à partir de 0 et de vérifier, j<2je pourrais revenir en arrière et vérifier i>m-2, mais ce serait +1 octet au lieu de -1. Votre approche d'utiliser deux boucles séparées avec modifiables met nest en effet intéressant, cependant. :)
Kevin Cruijssen
2

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

Adam
la source
@ngn Tout est fait. Merci. Pertinent .
Adám
2

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

LambdaBeta
la source
Fonctionne toujours bien si vous supprimez le </t>qui apparaît deux fois et -8 octets.
pomme de terre
Vous pouvez raser 4 octets de plus si vous déplacez la sortie de la nouvelle ligne vers la boucle interne (également, cela évite une ligne vide): Essayez-le en ligne!
ErikF
2

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

JayCe
la source
1

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>"
Angs
la source
1

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'
Graham
la source
@ Adám Trop déclencher heureux j'ai peur. Ça va maintenant?
Graham
Oui, mais vous n'avez pas besoin de la ou des parenthèses de fin: t,,((⎕-1),n←⎕)⍴rni des deux premières virgules.
Adám
@ Adám Merci. Ce n'est pas ma journée doit être la chaleur (28C)!
Graham
Fusionner het rdans l'expression principale:'<table>'t(n⍴⊂'<th>A')t,,((⎕-1),n←⎕)⍴⊂'<td>A'
Adám
Quelque chose ne va pas. Vous n'en insérez qu'un <tr>pour le corps. Chaque ligne a besoin d'un <tr>.
Adám
1

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.

Neil
la source
Si vous savez que l'entrée va être divisée par des espaces, alors vous devriez pouvoir utiliser à la .place de\d
Kritixi Lithos
1

Fusain , 33 octets

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

Essayez-le en ligne!

Explication

<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
ASCII uniquement
la source
1

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

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!

Xcali
la source
Gardez-vous quelques octets. Selon un exemple du défi, vous pouvez supprimer le .'</table>'.
msh210
1

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!

Emanuel Vintilă
la source
1

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!

Jeff Freeman
la source
1
Les supports sont facultatifs. Essayez Function F($m,$n){'<table><tr>'+'<th>A'*$n+('<tr>'+'<td>A'*$n)*--$m}.
mazzy
0

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

vasilescur
la source
0

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.

Ingénieur Toast
la source
0

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

J, 64 octets

Un autre port de la réponse Python:

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

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é

Francisco Hahn
la source
0

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!

Taylor Scott
la source
Cela ne produit pas les balises <td>.
pomme de terre
@potato - ahh, je n'avais pas vu ça. C'est corrigé.
Taylor Scott
0

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                      
reffu
la source
0

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.

Kritixi Lithos
la source
0

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. $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
mazzy
la source