Inspiré par une tâche de programmation 101, voici une tâche qui, espérons-le, n'est pas trop facile ou qui fait double emploi (un peu difficile de chercher des choses comme celle-ci).

Contribution:

• Un entier positif n >= 1.

Sortie:

• n lignes d'astérisques, chaque nouvelle ligne ayant un astérisque de plus que la ligne précédente et commençant par un astérisque dans la première ligne.

Règles générales:

• C'est du code-golf, donc la réponse la plus courte en octets est gagnante.
• Comme le cours est dispensé en C ++, je suis impatient de voir les solutions en C ++.

Cas de test (n = 5):

*
**
***
****
*****

Vim, 8 octets

o <Esc><C-V>{r*J

Prend les entrées dans le tampon readahead, donc si l’entrée est 15, vous taperiez cela puis le code ci-dessus. Ceci est une règle stupide, mais semble être autorisé . Si vous avez entré des données dans un registre "a, vous vous en tiendriez juste @adevant (10). Si vous l'avez dans le fichier de démarrage, vous préférez D@"au lieu de cela (11).

S'appuie sur l'utilisation abusive de :set autoindent, qui est celle par défaut dans les règles de vimgolf.com et celle par défaut dans Vim 8 (et tout le monde l'utilise de toute façon).

• o <Esc>: Avec son argument de nombre, si votre texte commence par un espace et si vous l'avez :set autoindent, Vim disparaît et crée une cascade d'indent.
• <C-V>{r*: Transformer tous ces espaces en *s. J'utilise un bloc visuel pour que, même si vos paramètres de mise en retrait désagréables regroupent vos espaces dans des onglets, vous aurez toujours le bon nombre de *s.
• J: En commençant par omalheureusement laissé une ligne blanche en haut. Cela l'enlève.

JavaScript (ES6), 31 octets

Celui-ci comprend à la fois un saut de ligne de début et de fin.

Nous commençons avec une chaîne sne contenant qu'un saut de ligne. Ensuite, nous traitons nles appels récursifs en ajoutant un astérisque à gauche de cette chaîne à chaque itération. La concaténation de toutes les chaînes intermédiaires conduit au résultat attendu.

f=(n,s=`
`)=>n?s+f(n-1,'*'+s):s

Sans astérisque, 36 octets

f=(n,s=`
`)=>n?s+f(n-1,atob`Kg`+s):s

05AB1E , 7 à 6 octets

Utilise le codage CP-1252 .

'*×.p»

Version sans astérisque de 8 octets:

žQTè×.p»

Essayez-le en ligne!

Explication

Exemple utilisant input n = 5

'*      # push "*"
        # STACK: "*"
  ×     # repeat input number times
        # STACK: "*****"
   .p   # get prefixes of string
        # STACK: ['*', '**', '***', '****', '*****']
     »  # join by newlines
        # implicit print

PowerShell, 21 octets

1..$args[0]|%{'*'*$_}

Boucle d’ 1entrée en entrée $args[0], chaque itération utilisant la multiplication de chaînes pour construire une chaîne $_comportant autant d’ astérisques. Le comportement par défaut pour l'implicite Write-Outputà la fin est avec une nouvelle ligne pour le séparateur, nous l'obtenons donc gratuitement.

PS C:\Tools\Scripts\golfing> .\draw-asterisk-pattern.ps1 5
*
**
***
****
*****

PS C:\Tools\Scripts\golfing> .\draw-asterisk-pattern.ps1 2
*
**

PS C:\Tools\Scripts\golfing> .\draw-asterisk-pattern.ps1 7
*
**
***
****
*****
******
*******

Python 2, 37 à 34 octets

i=1;exec"print'*'*i;i+=1;"*input()

Ideone

iest initialisé à 1;
puis des execcommandes pour exécuter la chaîne de code suivante, elle doit donc être construite;
la chaîne est "print'*'*i;i+=1;"la *suivante mais la chaîne a la priorité sur la execet demande à la première répétition de répéter la chaîne input();
la execcommande exécute maintenant la longue chaîne qui agit comme une boucle, printune autre chaîne de longueur croissante, utilisant *à nouveau pour répéter le caractère '*', puis incrémentant iavec i+=1.

Python 3, 41 Octets
def f(n):i=1;exec("print('*'*i);i+=1;"*n) ; ou
lambda n,i=1:exec("print('*'*i);i+=1;"*n)

Gelée , 6 à 5 octets

”*ẋþY

TryItOnline

Comment?

”*ẋþY - Main link: n
”*    - literal string "*"
   þ  - form outer product with the dyadic function:
  ẋ   -     repeat list (right input is an implicit range(n), Jelly defaults to 1-based)
            so the outer product is like:
            [[i*'*' for i in range(1,len("*")+1)] for x in range(1,n+1)]
    Y - join with line feeds
      - implicit print

Bounty:
Je ne suis pas sûr de ce qu'est la clause no ordinals, puisqu'un personnage est la recherche d'un ordinal.
La recherche directe ne porterait que 42Ọẋþ³Ysur 7 octets (où le ³nous obtient l’entrée).
Une méthode légèrement indirecte consisterait, pour 8 octets , à “)’Ọẋþ³Yrechercher ')'dans la page de code de jelly, indexé 1, donc “)’42.

C #, 42 octets

f=n=>n<1?"":f(n-1)+"\n"+new string('*',n);

Programme complet avec cas de test:

using System;

namespace DrawAnAsteriskPattern
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<int,string>f= null;
            f=n=>n<1?"":f(n-1)+"\n"+new string('*',n);

            Console.WriteLine(f(5));
        }
    }
}

Pyth , 6 octets

j._*"*

Essayez ici .

Explication

j            Join by newlines
 ._          all prefixes of
    *        the result of repeating
      "*     the string "*"
             as many times as the implicit input 

GNU sed , 25 24 20 + 1 (drapeau n) = 21 octets

Edit: 4 octets de moins sur la base des commentaires de Riley

x;G;:;P;s:\n.:*\n:;t

Essayez-le en ligne!

Exemple d'exécution: l'entrée est au format unaire, ce qui est autorisé pour sed en fonction de ce consensus

me@LCARS:/PPCG$ sed -nf draw_triangle.sed <<< "0000"

*
**
***
****

Une nouvelle ligne principale est présente dans la sortie, mais cela est autorisé par l'OP.

Explication:

x;G             # prepend a newline to unary string
:               # start loop
   P            # print first line only
   s:\n.:*\n:   # shift one unary char from 2nd line to 1st, converted to a '*'
t               # repeat

Matlab, 26 23 octets

Bon vieux Matlab ...

@(n)tril(repmat('*',n))

A des espaces de fuite. trilvous donne la matrice triangulaire inférieure.

edit: sauvé 2 bythes grâce à Luis Mendo

C ++ - 92 96 octets

#include<string>
int main(){int n;std::string s;scanf("%d",&n);for(;n--;)puts((s+="*").data());}

Essayez-le en ligne

Ungolfed:

//this one hurts, but c++ strings are mutable
#include<string> 
int main(){
    int n;
    //this one hurts as well
    std::string s; 
    //read input to n
    //longer than 'std::cin>>n', but no #include<iostream> needed
    scanf("%d",&n); 
    // same as 'while(n--)', also characterwise, but way cooler
    for(;n--;) 
        //add a '*' the string
        //data() does the same as c_str()
        //puts automatically adds an '\n'
        puts((s+="*").data()); 
}

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.