Imprimer une table de multiplication physique

40

Les rectangles ont cette belle propriété - un rectangle se compose d’exactement caractères!n×mn×m

Une propriété plus intéressante est que les rectangles peuvent être bien alignés dans une table de multiplication - par exemple, une table :3×3

# ## ###

# ## ###
# ## ###

# ## ###
# ## ###
# ## ###

Votre défi consiste à, étant donné un nombre ( n> 1 ), générer une table de multiplication formatée n \ times n .nn>1n×n

Règles

  • Vous pouvez prendre l’entrée un au dessus ou au dessous de n
  • Les règles d'E / S par défaut s'appliquent
  • Vous pouvez choisir n'importe quel caractère non-blanc pour représenter les blocs; tout autre caractère (bien que les nouvelles lignes soient spéciales) est considéré comme un espace. Le caractère choisi peut être différent pour différentes entrées, mais doit être identique tout au long de la saisie.
  • Le résultat peut avoir des caractères inutiles, tant que la table est alignée et qu'il n'y a aucune occurrence du caractère choisi qui ne fasse pas partie de la sortie requise.
  • Les séparateurs doivent avoir 1 caractère de largeur / hauteur et les rectangles doivent être remplis (c.-à-d. Pas de séparateurs entre leurs caractères)
  • Les lignes vides peuvent être vides, le remplissage n'est pas obligatoire
  • Le résultat peut être une chaîne, une matrice, un vecteur de lignes, un tableau de tableaux de caractères ou n'importe quoi 2Dish
  • Vous pouvez également générer une matrice / un vecteur de vecteurs / tout élément fini, mais l'arrière-plan et le premier plan doivent être deux nombres distincts (qui peuvent varier en entrée, mais pas dans une sortie) et aucun autre nombre ne peut être présent. Les caractères supplémentaires qui l'entourent sont également autorisés avec ce format (bien qu'ils doivent correspondre au numéro d'arrière-plan)
  • C'est , la réponse la plus courte en octets, par langue, gagne!

Exemples

Pour l’entrée 2, une sortie ascii-art valide, avec le caractère , est:

        ∙ ∙∙

Result: ∙ ∙∙.
        ∙ ∙∙

oui, le point est juste pour vous embrouiller.
Une autre réponse valable sous forme de matrice de nombres, 2 étant le numéro de fond et 9 le premier plan:

[[9,2,9,9,2,2],
 [2,2,2,2,2,2],
 [9,2,9,9,2,2],
 [9,2,9,9,2,2]]

Un exemple de sortie non valide serait

#  # #


#  # #

#  # #

comme les rectangles ont des séparateurs entre eux.

Exemple de sorties pour :4×4

# ## ### ####

# ## ### ####
# ## ### ####

# ## ### ####
# ## ### ####
# ## ### ####

# ## ### ####
# ## ### ####
# ## ### ####
# ## ### ####


1 0 1 1 0 1 1 1 0 1 1 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0
1 0 1 1 0 1 1 1 0 1 1 1 1
1 0 1 1 0 1 1 1 0 1 1 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0
1 0 1 1 0 1 1 1 0 1 1 1 1
1 0 1 1 0 1 1 1 0 1 1 1 1
1 0 1 1 0 1 1 1 0 1 1 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0
1 0 1 1 0 1 1 1 0 1 1 1 1
1 0 1 1 0 1 1 1 0 1 1 1 1
1 0 1 1 0 1 1 1 0 1 1 1 1
1 0 1 1 0 1 1 1 0 1 1 1 1
dzaima
la source
Pouvons-nous avoir des rangées / colonnes supplémentaires de caractères d'arrière-plan devant, plutôt qu'à la fin du tableau?
Kirill L.
@KirillL. Bien sûr, tant que les rangées s’alignent
dzaima
2
Nitpick: ∙ (U + 2219: BULLET OPERATOR) n’est pas présent dans le jeu de caractères ASCII. N'est pas non plus • (U + 2022: BALLE) ou (U + 22C5: OPÉRATEUR POINT) ou · (U + 00B7: MOYEN POINT). :)
Andreas Rejbrand

Réponses:

10

Haskell , 43 octets

f n=map=<<flip(map.max)$show.(10^)=<<[1..n]

Essayez-le en ligne!

Une approche intelligente de Ørjan Johansen produisant avec des 0 et des 1, générant chaque 10...00partie comme représentation sous forme de chaîne d’une puissance de 10.

111111111
101001000
111111111
101001000
101001000
111111111
101001000
101001000
101001000

Haskell , 49 octets

f n=map=<<flip(map.max)$[0^i|x<-[1..n],i<-[0..x]]

Essayez-le en ligne!

Génère un motif comme [1,0,1,0,0,1,0,0,0,...], puis crée une 2D en prenant le nombre minde paires. L'étrangeté sans points sauve 2 octets sur le plus lisible:

f n|l<-do x<-[1..n];0:(1<$[1..x])=[[a*b|a<-l]|b<-l]

Essayez-le en ligne!

Xnor
la source
3
Ceci peut être raccourci avec mon vieux tour de nombre triangulaire: 43 octets
Ørjan Johansen
1
Je viens de me rendre compte flip(map.max)=mapM max.
Ørjan Johansen
@ ØrjanJohansen Whoa, comment ça marche? Je pense que vous pourriez faire en postant votre propre réponse :-)
xnor
Réglez la monade sur (->) b, puis mapM :: (a -> b -> c) -> [a] -> b -> [c].
Ørjan Johansen
@xnor vous avez oublié de passer flip(map.max)àmapM max
ASCII uniquement
9

R , 56 54 43 36 30 octets

x=!!sequence(2:scan())-1;x%o%x

Essayez-le en ligne!

Prend l'entrée un au dessus de n (retourne donc la matrice 3x3 pour n=4 ). Renvoie une matrice de 1s (au premier plan) et de 0s (arrière-plan) avec une ligne / colonne supplémentaire de zéros au premier plan.

Merci à digEmAll pour -7 octets.

Kirill L.
la source
Merci, BTW peut probablement même être 30, si la ligne vide supplémentaire peut être à l'avant, plutôt que à la fin.
Kirill L.
Oh, peuvent-ils? J'ai manqué ça !
digEmAll
6

JavaScript (ES6),  73 72  69 octets

Renvoie une chaîne composée de 1, d'espaces et de sauts de ligne.

n=>(g=s=>n-->0?g(s+`${p+=1} `):s[~n]?(+s[~n]?s:'')+`
`+g(s):'')(p='')

Essayez-le en ligne!


JavaScript (ES7),  87 83  82 octets

3 octets sauvés grâce à @dzaima

Retourne une matrice binaire, qui est construite cellule par cellule.

n=>[...Array(n*(n+3)/2)].map((_,y,a)=>a.map(h=(z,x)=>(17+8*x)**.5%1&&(z||h(1,y))))

Essayez-le en ligne!

Comment?

La largeur w de la matrice est donnée par:

w=Tn+n-1=(n+12)+n-1=n(n+3)2-1

(NB: comme le permettent les règles de challenge, nous produisons une matrice de largeur w+1 place.)

De même, la cellule située en (X,Y) est vide si le quadratique suivant admet une racine entière pour k=X ou k=Y :

X(X+3)2-1-k=0X2+3X-2-2k=0

dont le déterminant est:

Δ=9-4(-2-2k)=17+8k

Arnauld
la source
Pas sûr si cela peut économiser des octets, mais la solution de ce quadratique serait , donc il y aurait une racine entière si3±17+8k2 est impair, c’est-à-dire queΔest un carré parfait impair. ΔΔ
Erik l'Outgolfer
5

MATL, 14 à 10 octets

:"@:Fv]g&*

Cette réponse utilise 1pour les blocs et 0pour le fond

Essayez-le sur MATL Online

Explication

     % Implicitly grab the input as an integer, N
     %   STACK: { 3 }
:    % Create an array from 1...N
     %   STACK: { [1, 2, 3] }
"    % For each element M in this array
  @: % Create an array from 1...M
     %   STACK (for 1st iteration): { [1] }
     %   STACK (for 2nd iteration): { [1; 0], [1, 2] }
     %   STACK (for 3rd iteration): { [1; 0; 1; 2; 0], [1, 2, 3] }
  F  % Push a zero to the stack
     %   STACK (for 1st iteration): { [1], 0 }
     %   STACK (for 2nd iteration): { [1; 0], [1, 2], 0 }
     %   STACK (for 3rd iteration): { [1; 0; 1; 2; 0], [1, 2, 3], 0 }
  v  % Vertically concatenate everything on the stack
     %   STACK (for 1st iteration): { [1; 0] }
     %   STACK (for 2nd iteration): { [1; 0; 1; 2; 0] }
     %   STACK (for 3rd iteration): { [1; 0; 1; 2; 0; 1; 2; 3; 0] }
] 
g    % Convert everything to be boolean (turns all non-zeros to 1)
     %   STACK: { [1; 0; 1; 1; 0; 1; 1; 1; 0] }
&*   % Perform element-wise multiplication to expand this array out into the 2D grid
     % Implicitly display the result
Suever
la source
4

APL (Dyalog Unicode) , 12 10 12 octets SBCS

∘.×⍨∊,\0,⎕⍴1

Essayez-le en ligne!

Edit: -2 octets de ngn. +2 octets car les réponses précédentes étaient invalides (avec une idée grâce à ngn et dzaima).

Explication

∘.×⍨∊,\0,⎕⍴1

             Take input.
           1  An array of 1s of length our input. Example: 1 1 1
       0,      Prepend a 0. Example: 0 1 1 1
     ,\        Take all the prefixes and concatenate them. Example: 0  0 1  0 1 1  0 1 1 1
              Flatten the list. Example: 0 0 1 0 1 1 0 1 1 1
∘.×⍨           Turn the above list into a multiplication table of 0s and 1s
               by multiplying the list with itself.

La sortie devrait ressembler à:

0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 1 0 1 1 0 1 1 1
0 0 0 0 0 0 0 0 0 0
0 0 1 0 1 1 0 1 1 1
0 0 1 0 1 1 0 1 1 1
0 0 0 0 0 0 0 0 0 0
0 0 1 0 1 1 0 1 1 1
0 0 1 0 1 1 0 1 1 1
0 0 1 0 1 1 0 1 1 1
Sherlock9
la source
1
vous pouvez prendre des mesures pour éviter les{ }
ngn
4

Gelée , 7 octets

‘RÄṬ|þ`

Essayez-le en ligne!

01

Explication

‘RÄṬ|þ`
 R       Take a range from 1 to
‘          {the input} plus 1
  Ä      Cumulative sum; produces the first {input}+1 triangular numbers
   Ṭ     Produce an array with 1s at those indexes, 0s at other indexes
     þ   Create a table of {the array}
      `    with itself
    |      using bitwise OR

(X,y)1Xy0Rs’arrête au plus grand élément indiqué dans l’entrée, il faut donc tracer une ligne à droite et en bas.) Les espaces entre les nombres triangulaires sont les entiers consécutifs, donc les blocs rectangulaires formés par les espaces entre les lignes se terminent comme les tailles demandées par la question; et l'utilisation d'une opération OU (dans ce cas, au niveau des bits) permet aux lignes de se croiser correctement.

ais523
la source
Pourquoi est-ce un wiki de communauté?! Si vous souhaitez renoncer au représentant, vous pouvez le donner à Erik the Outgolfer
Jonathan Allan
1
Je réponds à toutes mes réponses (à moins que je ne pense qu'ils pourraient recevoir une prime, auquel cas j'utilise un compte temporaire pour eux). Vouloir obtenir une réputation enviable signifie normalement vouloir aggraver le site (une fois par semaine, j’ai rediffusé chaque jour pour prouver que c’était possible; ce n’était pas particulièrement difficile, et pourtant, cela impliquait un grand nombre de questions / réponses superficielles qui n t vraiment contribuer au site beaucoup). De plus, gagner de la réputation est principalement négatif pour le compte, car cela incite le site à vous faire faire du travail de modération. et obtenir des privilèges augmente le risque de gagner accidentellement des badges.
ais523
De plus, je suis surtout en désaccord avec le concept de propriété des publications sur SE (bien qu’il s’agisse principalement de questions plutôt que de réponses, mais vous ne pouvez pas poser une question sans l’aide du modérateur). Un marqueur CW dit très clairement "si quelque chose ne va pas ici, n'hésitez pas à le modifier"; donc, j'appliquerais un marqueur CW à tout, même s'il ne renonçait pas à la réputation. SE est censé faire partie du wiki, après tout, mais les gens ne l'utilisent pas toujours comme ça.
ais523
RE "viser une haute réputation" si vous ne le souhaitez pas, postez-le simplement lorsque vous pensez que cela a du sens et évitez ce que vous appelez des questions "superficielles". Soit vous pensez que cette réponse ajoute quelque chose au site, dans ce cas, postez-la sans CW, ou vous pensez qu'elle est "superficielle", dans ce cas, ne la publiez pas. RE "Je ne suis généralement pas d'accord avec le concept de propriété des publications sur SE" - et bien vous êtes simplement sur le mauvais site.
Jonathan Allan
2
Je pense que la réponse ajoute quelque chose au site, mais si ce n'est pas CW, je me sens obligé de poster de manière à gagner ma réputation plutôt que de publier ce que je pense serait intéressant; À l’époque où j’étais un utilisateur de 20 000 $, j’ai fini par détester vraiment le site et à peu près me détourner du code golf en général, j’ai donc supprimé mon compte. Quand je revenais, je supprimais mon compte avec chaque réponse que je postais (en créant un nouveau pour la réponse suivante), mais quelqu'un d'autre a souligné que chaque réponse aurait un effet similaire, alors je le fais maintenant à la place.
ais523
4

05AB1E , 9 octets

FNatliste[liste[Nat]]

Code:

$L×0ýSDδ*

Utilise le 05AB1E -encoding . Essayez-le en ligne! ou utilisez la version joliment imprimée .


Explication:

$ # Poussez le nombre 1 et l'entrée n 
 L # Créez la liste [1, 2, 3, ..., n ]
  × # Multiplication de chaînes vectorisée: 1 × [1, 2, 3, ..., n ]
                 Cela donnerait ["1", "11", "111", ..., "1" × n ]
   0ý # Rejoignez la liste résultante avec '0', résultant en "10110111011110111110 ..."
     S # Découpe en chiffres simples: [1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, ...]
      Dδ * # Table de multiplication avec elle-même
Adnan
la source
4

C # (compilateur interactif Visual C #) , 96 95 octets

-1 octet grâce à l' incarnation de l'ignorance

n=>{var l="";for(;n>0;)l=new string('#',n--)+' '+l;for(;n<l.Length;)WriteLine(l[n++]>32?l:"");}

Essayez-le en ligne!

ASCII seulement
la source
pas sûr si l'entrée via l'argument, mais la sortie via stdout est autorisée
ASCII-only
3
Il est bon de mélanger les formats IO
Jo King
1
Pourquoi ne pas ajouter le n--dans la new stringsection?
Incarnation de l'Ignorance
3

Python 2 , 67 octets

s='';n=input()
while n:s='#'*n+' '+s;n-=1
for c in s:print(c>' ')*s

Essayez-le en ligne!

Imprime les lignes vides pour les lignes vides, ce que le défi permet.

Même longueur (avec l'entrée une ci-dessus n):

r=range(input())
for n in r:print(' '.join(i*'#'for i in r)+'\n')*n

Essayez-le en ligne!

Xnor
la source
3

Charbon de bois , 18 octets

≔⪫EN×#⊕ι θEθ⭆θ⌊⟦ιλ

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Explication:

   N                Input number
  E                 Map over implicit range
       ι            Current value
      ⊕             Incremented
    ×               Repetitions of
     #              Literal `#`
 ⪫                  Join with spaces
≔        θ          Assign to variable
           θ        Retrieve variable
          E         Map over characters
             θ      Retrieve variable
            ⭆      Replace characters with
              ⌊     Minimum of
               ⟦    List of
                ι   Row character
                 λ  Column character
                    Implicitly print each row on its own line
Neil
la source
3

C # (.NET Core) , 208 155 octets

class M{static void Main(string[]a){int i=int.Parse(a[0]);var l="";for(;i>0;)l=new string('#',i--)+' '+l;for(;;)System.Console.WriteLine(l[i++]>32?l:"");}}

Essayez-le en ligne!

Une version beaucoup révisée grâce aux différentes personnes utiles (voir les commentaires).

Stack Stuck
la source
1
202?
ASCII uniquement
1
166, indexation corrigée
ASCII uniquement
1
@EmbodimentofIgnorance invalide, ne fonctionne pas pour n> = 10 ...
ASCII uniquement
1
@ ASCII-only cela fonctionne: tio.run/…
Incarnation de l'Ignorance
2
@ Stackstuck Oui. Un programme est autorisé à se terminer par un blocage
ASCII uniquement
3

Java 11, 109 octets

n->{var l="";for(;n>0;)l="x".repeat(n--)+" "+l;for(;n<l.length();)System.out.println(l.charAt(n++)>32?l:"");}

Port de @ ASCII uniquement réponse C # .NET .

Essayez-le en ligne.

n->{                       // Method with integer parameter and no return-type
  var l="";                //  Line-String, starting empty
  for(;n>0;)               //  Loop until `n` is 0:
    l=...+l;               //   Prepend to `l`:
       "x".repeat(n--)+" " //    Repeat "x" `n` amount of times, appended with a space
                           //    And decrease `n` by 1 afterwards with `n--`
    for(;n<l.length();)    //   Inner loop as long as `n` is smaller than the length of `l`:
      System.out.println(  //    Print with trailing newline:
        l.charAt(n++)>32?  //     If the `n`'th character of the line-String is NOT a space:
                           //     And increase `n` by 1 afterwards with `n++`
         l                 //      Print the line-String
        :                  //     Else:
         "");}             //      Print nothing (so only the newlines)
Kevin Cruijssen
la source
C'est Java 11, pas 8, à cause de la repeatméthode.
Olivier Grégoire
@ OlivierGrégoire Oops .. Fixe
Kevin Cruijssen
Cependant, est-il acceptable d'avoir un lambda qui lève une exception? Je pensais que tout allait bien pour un programme complet, mais pas pour les fonctions / exceptions
Olivier Grégoire
@ OlivierGrégoire Tant que le résultat attendu reste affiché, je ne vois pas pourquoi tbh.
Kevin Cruijssen
1
Ceci est lié à cette discussion . La réponse semble être que si les REPL sont acceptés (ce qui n'est pas le cas par défaut), alors c'est bien d'imprimer sur stderr ou de lever une exception, mais si REPL n'est pas accepté, aucune std / exception n'est autorisée.
Olivier Grégoire
2

APL + WIN, 29 octets

m/⍉(m←¯1↓∊(⍳n),¨¯1)/(n,n←⎕)⍴1

Explication:

(n,n←⎕)⍴1 prompt for integer n and create a nxn matrix of 1s

(m←¯1↓∊(⍳n) replicate the columns by 1,2,.....n and insert 0s between each replication

m/⍉ repeat replication and 0 insertion for the rows from above 

Exemple:

⎕:
3
1 0 1 1 0 1 1 1
0 0 0 0 0 0 0 0
1 0 1 1 0 1 1 1
1 0 1 1 0 1 1 1
0 0 0 0 0 0 0 0
1 0 1 1 0 1 1 1
1 0 1 1 0 1 1 1
1 0 1 1 0 1 1 1
Graham
la source
2

J , 17 octets

[:*/~2=/\[:I.2+i.

Essayez-le en ligne!

Galen Ivanov
la source
ne savait pas à propos de cette I.astuce!
Jonah
@Jonah J'attendais l'opportunité de l'utiliser :)
Galen Ivanov
2

Souris 2002 , 79 octets

Abuser des macros de la souris pour répéter la fonctionnalité.

?1+n:#P,n,j,k,b#P,j,y,k,#P,n,i,' ,#P,i,x,35;;;;$P0 2%:(1%.2%.-^4%3%!'2%.1+2%:)@

Essayez-le en ligne!

MooseOnTheRocks
la source
2

Ruby , 55 octets

->n{(s=(1..n).map{|x|?#*x}*' ').chars.map{|c|c<?!?c:s}}

Essayez-le en ligne!

Comment?

Commencez par créer la première ligne, puis parcourez ses caractères. Imprimer la ligne entière si le caractère est '#', sinon, imprimer le caractère unique (qui est un espace)

GB
la source
2

Flak cérébrale , 170 octets

(({})<>){(({})<{({}[()]<(<>({})<>){(({})<{({}[(())])}>[()])}{}{}(([(()()()()())(){}]){})>)}{}(({}))>[()])}{}{}{}([]){{}({}<>((((()()){}){}){}){})<>([])}{}<>{({}<>)<>}<>{}

Essayez-le en ligne!

MegaTom
la source
2

Perl 6 , 35 33 octets

{((\*Xx$_+1)~"
"Xx$_+1)>>.say}o^*

Essayez-le en ligne!

Anonymous Callable qui prend un nombre et imprime la table de multiplication avec * s avec une nouvelle ligne.

Explication:

{                             }o^* # Change the input to the range 0..n-1
  (\*Xx$_+1)    # Cross string multiply '*' by all of range 1..n
                # This creates the string "* ** *** ****" etc.
            ~"\n"                 # Append a newline
                 Xx$_+1           # Cross string multiply again
 (                     )>>.say    # And print all the lines
Jo King
la source
1

Haskell, 69 à 68 octets

(a#b)0=[]
(a#b)n=(a#b)(n-1)++b:(a<$[1..n])
f n=((1#0)n#(0<$(1#0)n))n

Retourne une matrice de nombres.

Essayez-le en ligne!

Variantes de favec le même nombre d'octets:

f n=((#)<*>(0<$)$(1#0)n)n
f n|l<-(1#0)n=(l#(0<$l))n
nimi
la source
La ligne 0 et la colonne aident-elles?
dfeuer
1
@dfeuer: oui, ils sauvegardent un octet. Voir la première version de ma réponse.
nimi
1

Stax , 7 octets

é╫▐§╘←╘

Exécuter et déboguer

Le personnage choisi est un backtick. (Comment codez-vous le format dans Markdown?)

Cela signifie aet bsont considérés comme des espaces blancs superflus.

récursif
la source
1

MathGolf , 20 octets

╒ÉÄ10;]h\■mÆε*╣¡§y╠n

Essayez-le en ligne!

MathGolf a vraiment besoin de plus de fonctionnalités pour scinder des listes et créer des listes 2D.

Explication

╒                      range(1,n+1)
 É                     start block of length 3
  Ä                    start block of length 1
   1                   push 1
    0                  push 0
     ;                 discard TOS
      ]                end array / wrap stack in array
                       the stack now contains the list [1, 0, 1, 1, 0, 1, 1, 1, 0, 1, ...]
       h               length of array/string without popping (used for splitting string)
        \              swap top elements
         ■             cartesian product with itself for lists, next collatz item for numbers
          m            explicit map
           Æ           start block of length 5
            ε*         reduce list by multiplication (logical AND)
              ╣¡       push the string " #"
                §      get character at index 0 or 1 based on logical AND value
                       block ends here, stack is now ['#',' ','#','#',' ','#',...]
                 y     join array without separator to string
                  ╠    pop a, b, push b/a (divides the string using the length of a single line)
                   n   join array of strings with newlines
maxb
la source
1

Encre , 151 152 151 octets

VAR k=0
=t(n)
~k=n
-(u)
~n--
{n+1:->s(k-n)->u}->->
=r(c)
->g(c)->
{k-c:<>->r(c+1)}->->
=g(n)
{n>1:@<>->g(n-1)}@->->
=s(n)
{n:
->r(1)->
->s(n-1)
}
.->->

Essayez-le en ligne!

C'est une bonne chose que les règles autorisent les personnages excédentaires.

Edit: +1: Espacement fixe. De plus, affichez en utilisant @ (qui n'a pas besoin d'être échappé) au lieu de # (qui le fait)

Edit: -1: Apparemment, ce correctif signifiait également que je n'avais plus besoin d'une période de fin pour forcer une nouvelle ligne sur les lignes non vides. Soigné.

Sara J
la source
Ohh, je n'ai même pas remarqué ces espaces. Je verrai si je peux faire quelque chose à leur sujet ...
Sara J
1

C ++, 170 156 octets

Merci à dzaima

#include<string>
using v=std::string;v f(int a){v s;for(int i=1;i<=a;++i,s+='\n')for(int k=0;k<i;++k,s+='\n')for(int j=1;j<=a;++j)s+=v(j,'#')+' ';return s;}
HatsuPointerKun
la source
138 octets
ceilingcat
0

SmileBASIC, 83 77 octets

Sortie graphique. L'entrée estN-1

INPUT N
FOR J=0TO N
X=0FOR I=0TO N
GFILL X,Y,X+I,Y+J
X=X+I+2NEXT
Y=Y+J+2NEXT
12Me21
la source
0

Python 3 , 88 83 octets

-5 octets de Jo King

n,l=range(int(input())),''
for i in n:l+='#'*-~i+' '
for j in n:print((l+'\n')*-~j)

Essayez-le en ligne!

Kérosène
la source
Vous pouvez économiser des octets en déclarant en ldehors de la boucle. Essayez-le en ligne!
Jo King
@JonathanFrech Il y a un espace supplémentaire dans la chaîne newline
Jo King
0

Perl 6, 63 octets

{(1..$_).map(((1..$_).map("#"x*).join(" ")~"\n")x*).join("\n")}
bb94
la source
1
.join(' ')ne fait rien, '#'peut être à la \*place, les chaînes de nouvelle ligne peuvent utiliser des nouvelles lignes littérales, les deux l.map(str x*)peuvent être à la (str Xx l)place. 38 octets
Jo King