Méduse , 12 11 9 octets

\P$'*
  i

Essayez-le en ligne!

Explication

Le programme ci-dessus est équivalent au pseudocode fonctionnel suivant:

\            P      $       i        '*
map_prefixes(print, reshape(input(), '*'))

Le $(refaçonner) crée une chaîne d' Nastérisques. \Pcrée une fonction qui prend une liste (ou une chaîne) et transmet chacun de ses préfixes à P(print). Par conséquent, il imprime successivement les chaînes de 1à Nastérisques.

R, 45 octets

Pour l'approche en boucle:

for(i in 1:scan())cat(rep("*",i),"\n",sep="")

Brachylog , 12 octets

yke:"*"rj@w\

Essayez-le en ligne!

Cela suppose qu'une nouvelle ligne est acceptable

Explication

yk                The range [0, …, Input - 1]
  e               Take one element I of that range
   :"*"rj         Juxtapose "*" I times to itself
         @w       Write that string followed by a new line
           \      False: backtrack to another element of the range

Pas de nouvelle ligne, 15 octets

-:"*"rj:@[f~@nw

Essayez-le en ligne!

Celui-ci fonctionne en prenant tous les préfixes de "*" × Input.

Haskell, 35 38 octets

Compréhension de liste grâce à nimi:

f x=unlines[[1..n]>>"*"|n<-[1..x]]

Ancienne version:

f 0=""
f n=f(n-1)++([1..n]>>"*")++"\n"

Version alternative:

g n=([1..n]>>"*")++"\n"
f n=[1..n]>>=g

Pyth, 7 octets

VQ*\*hN

Bloqué un octet grâce à @ETHproductions Essayez-le en ligne

en utilisant la technique de @ PIetu1998

6, octets

j*L*\*S

2sable , 24 à 11 octets

>G')Ç>çJN×,

Essayez-le en ligne!

Et aucun signe d'astérisque! Golfé du 24 au 11 grâce à @Emigna .

Explication:

>G')Ç>çJN×,
>            Push input+1
 G           For N in range (1,input+1)
  ')Ç>çJ     Push '*' by getting ascii code for ')' and adding 1
        Nx,  Print '*' repeated N times

Brain-Flak 75 Octets

Comprend +3 pour -A

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

Essayez-le en ligne!

Explication:

{(({})[()]<                                                        >)}
#reduce the top element by one until it is 0 after doing the following
#Push this element back on to act as a counter for the next step.
#(counts down from input to 0 we'll call this counter)

           {({}[()]<                          >)}
           #reduce the top element by one until it is 0 after doing the following
           #(counts down from counter to 0)

                    (((((()()()){}()){})){}{})  
                    #push 42 (the ASCII code for *)

                                                 {}
                                                 #pop the counter used to push
                                                 #the right number of *s

                                                   ((()()()()()){})
                                                   #push a 10 (newline)

                                                                      {}
                                                                      #pop the null byte

Dyalog APL , 8 octets

↑'*'⍴⍨¨⍳

↑ matrifier la liste composée de

'*' la chaîne "*"

⍴⍨ remodelé par

¨ chacun des

⍳ les entiers 1 à travers l'argument.

TryAPL en ligne!

V , 8 octets

Àé*hòlÄx

Essayez-le en ligne!

JavaScript (ES6), 34 octets

f=x=>x?f(x-1)+`
`+'*'.repeat(x):''

Perl 6 , 23 octets

{.put for [\~] '*'xx$_}

(Si la sortie est autorisée à être une liste de "lignes" sans nouvelles lignes .put for peuvent être supprimés)

Explication:

# bare block lambda with implicit parameter ｢$_｣
{
  .put            # print with trailing newline
    for           # for every one of the following
      [\~]        # produce using concatenation operator
        '*' xx $_ # list repeat '*' by the input
}

(Voir la documentation producesi vous ne comprenez pas ce qui [\~] ...se passe)

Perl 5, 22 20 octets

say"*"x$_ for 1..pop

Exécutez-le avec le -Ecommutateur pour obtenir say.

$ perl -E 'say"*"x$_ for 1..pop' 5
*
**
***
****
*****

Écrit comme un programme complet, il ressemblerait à ceci:

use strict;
use feature 'say';

# get the argument
my $limit = pop @ARGV;

foreach my $i (1 .. $limit) { 
    say "*" x $i; 
}

• shiftet poptravaille implicitement sur @ARGV(la liste des arguments) en dehors de subs
• ..est l' opérateur de gamme
• say comprend une nouvelle ligne
• xest un opérateur pour répéter des chaînes et est expliqué dans perlop

Perl, 19 octets

-4 octets grâce à @Ton Hospel et son remaniement de la solution!

eval"s//*/;say;"x<>

Nécessite un drapeau gratuit -E(ou -M5.010) à exécuter. Prend un nombre à partir de l'entrée:

perl -E 'eval"s//*/;say;"x<>' <<< "5"

J, 11 8 octets

Économisé 3 octets grâce aux miles!

]\@#&'*'

Voici une décomposition:

(]\@#&'*') x
x (]\@#) '*'
]\ (x # '*')

Maintenant, ce dernier se lit comme "les préfixes ( ]\) de la chaîne constituée de xcopies de '*'". Observer:

   5 ]\@# '*'
*
**
***
****
*****
   ]\ 5# '*'
*
**
***
****
*****
   ]\ 5 # '*'
*
**
***
****
*****
   ]\@#&'*' 5
*
**
***
****
*****

Cas de test

   f =: ]\@#&'*'
   f 3
*
**
***
   f 5
*
**
***
****
*****
   f 1
*
   f 2
*
**
   f &. > ;/1+i.10
+-+--+---+----+-----+------+-------+--------+---------+----------+
|*|* |*  |*   |*    |*     |*      |*       |*        |*         |
| |**|** |**  |**   |**    |**     |**      |**       |**        |
| |  |***|*** |***  |***   |***    |***     |***      |***       |
| |  |   |****|**** |****  |****   |****    |****     |****      |
| |  |   |    |*****|***** |*****  |*****   |*****    |*****     |
| |  |   |    |     |******|****** |******  |******   |******    |
| |  |   |    |     |      |*******|******* |*******  |*******   |
| |  |   |    |     |      |       |********|******** |********  |
| |  |   |    |     |      |       |        |*********|********* |
| |  |   |    |     |      |       |        |         |**********|
+-+--+---+----+-----+------+-------+--------+---------+----------+

Solutions plus anciennes, 11 octets

'*'#~"+1+i.

C'est équivalent

'*' #~"0 1 + i.

1 + i.est la gamme [1, x]. Ensuite, '*' #~"0appliqué à cette plage forme des copies (élément) de '*'.

Programme de bonus:

[:#&'*'\#&1

Ceci est un fork plafonné #&'*'\appliqué au résultat #&1de l'entrée. #&1donne un tableau de xuns et des #&'*'\formes '*'aux préfixes de ce tableau.

Cas de test

   f1 =: '*'#~"+1+i.
   f2 =: [:#&'*'\#&1
   f1 1
*
   f2 2
*
**
   f1 3
*
**
***
   f2 4
*
**
***
****
   f2 5
*
**
***
****
*****
   f1 5
*
**
***
****
*****
   (f1;f2)3
+---+---+
|*  |*  |
|** |** |
|***|***|
+---+---+
   f1;f2
f1 ; f2
   (f1;f2)5
+-----+-----+
|*    |*    |
|**   |**   |
|***  |***  |
|**** |**** |
|*****|*****|
+-----+-----+
   (f1;f2)10
+----------+----------+
|*         |*         |
|**        |**        |
|***       |***       |
|****      |****      |
|*****     |*****     |
|******    |******    |
|*******   |*******   |
|********  |********  |
|********* |********* |
|**********|**********|
+----------+----------+

Vim, 22 , 18 frappes

O <esc>J:h r<cr>lyEZZ<C-v>{@"

Un grand crédit à @Udioica pour avoir fourni une réponse géniale sur vim que j'ai développée. Cette réponse ne contient aucun astérisque, dans l’espoir de gagner la prime.

Explication:

La saisie est tapée avant le reste du programme. Udioica a inventé ce truc génial. Taper <n>O <esc>créera une pyramide d’espaces et une ligne vide, tant que vous avez :set autoindentactivé. Cette option est activée par défaut dans vim 8 et neovim, mais pas les anciennes versions de vim. Comme cela crée également une ligne supplémentaire, nous avons l'habitude Jde joindre cette ligne à la suivante, ce qui supprime simplement la ligne située en dessous de nous.

Maintenant, à ce stade, nous devons remplacer tous ces espaces par des astérisques. Si je ne craignais pas d'utiliser des astérisques dans mon code, je sélectionnerais simplement le tout <C-v>{et le type r*, ce qui remplace chaque caractère de la sélection par un astérisque. Mais je ne peux pas faire ça.

Nous ouvrons donc les pages d’aide à :h r. La chose intéressante à propos de cela est que dans la fenêtre de vim, cette page est affichée comme:

                            r
r{char}         Replace the character under the cursor with {char}.
                ...

Avec le curseur sur le premier 'r'. Cependant, le fichier lui-même contient ce texte:

                            *r*
r{char}         Replace the character under the cursor with {char}.
                ...

Assez pratique. Donc, nous passons au-dessus d'un caractère avec l, et tirons le texte r*avec yE([y] à la [E] nd de ce mot).

Pour fermer ce tampon, nous utilisons le raccourci pour enregistrer un fichier ZZ. Maintenant, nous sélectionnons visuellement nos espaces et lançons le texte tiré comme si nous l'avions dactylographié @". Cela fonctionne parce que "@" exécute le registre suivant sous forme de frappes vim, et "est le registre par défaut pour yanking.

C, 47 46 45 43 octets

Prend les entrées de la ligne de commande

f(n){for(n&&f(n-1);~n;putchar(n--?42:10));}

Fondamentalement, si n n'est pas 0, recurse sur n-1. en haut de la récursivité, où n est 0, une nouvelle ligne est simplement imprimée, la boucle for se termine lorsque n est égal à -1 ou ~ n est égal à zéro, sinon elle affiche le code ASCII 42, qui est '*'. Essayez sur ideone

C ++ 58 octets + 19 pour inclure iostream est 77

#include<iostream>
int f(int n){for(n&&f(n-1);~n;std::cout<<(n--?"*":"\n"));}

main(c,v)char**v;
{
    f(atoi(v[1]));
}

a.exe 3
*
**
***

Rétine , 14 octets

Le nombre d'octets suppose un codage ISO 8859-1.

.+
$**
.
$`$&¶

Essayez-le en ligne!

Explication

.+
$**

Transformez l'entrée Nen Nastérisques.

.
$`$&¶

Remplacez chaque astérisque par tous les éléments jusqu’à et y compris cet astérisque (c’est le $`$&) et un saut de ligne (c’est le ¶).

MATL, 9 à 8 octets

1 octet enregistré grâce à @Luis

:"42@Y"c

Essayez-le en ligne

Cubix , 22 octets

?(.;I:^;/-.@o;(!\>'*oN

Testez-le en ligne! Sort un retour à la ligne final.

Au début, je n'étais pas sûr de pouvoir placer ceci sur un cube de 2, mais à la fin, tout s'est bien passé:

    ? (
    . ;
I : ^ ; / - . @
o ; ( ! \ > ' *
    o N
    . .

J'ajouterai une explication quand j'en aurai le temps, j'espère plus tard aujourd'hui.