#include <stdio.h>
  main()
   {
         int i=1,j,nb;
 
   printf("triangle\nnombre de ligne : " );
   scanf("%d",&nb);
   printf("\n" );  
   for(i=nb;i>=1;i--)  
       {
          for(j=i;j>=1;j--)  
          {
              printf("*" );            
                         }
              printf("\n" );    
            }
     
   
  system("PAUSE" );  
 }

1. #include <iostream>
2. #include <string>
3. using namespace std;
5. int main () {
6.   int largeur, largeur_max = 10;
7.   // sens décroissant
8.   largeur = largeur_max;
9.   do { cout << string(largeur, '*') << endl ; } while (--largeur);
10.   //saut d'une ligne pour séparer les deux
11.   cout << endl;
12.   // sens croissant
13.   largeur = largeur_max;
14.   do { cout << string(largeur_max+1-largeur, '*') << endl; } while (--largeur);
15.   // pause avant de finir
16.   char c = cin.get();
17.   return 0;
18. }

1. #include <iostream>
2. #include <string>
3. using namespace std;
5. int main () {
6.   int largeur, largeur_max = 10;
7.   // sens décroissant version "je veux la boucle en décroissante comme ça"
8.   largeur = largeur_max;
9.   do { cout << string(largeur_max - largeur, ' ') << string(largeur, '*') << endl ; } while (--largeur);
10.   //saut d'une ligne pour séparer les deux
11.   cout << endl;
12.   // sens croissant
13.   largeur = largeur_max;
14.   do { cout << string(largeur_max+1-largeur, '*') << endl; } while (--largeur);
15.   // pause avant de finir
16.   char c = cin.get();
17.   return 0;
18. }

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <string.h>
4. int main()
5. {
6.   int largeur, largeur_max = 10;
7.   char *buffer = calloc(largeur_max+1, 1);
8.   memset(buffer, '*', largeur_max);
9.   printf("%s\n", buffer);
10.   largeur = largeur_max - 1;
11.   do {
12.     *(buffer + largeur_max - 1 - largeur--) = ' ';
13.     printf("%s\n",buffer);
14.   } while (largeur);
15.   free(buffer);
16.   getchar();
17.   return EXIT_SUCCESS;
18. }

#!/usr/local/bin/perl
use strict;
use warnings;
 
my $largeur_max = 10;
# croissant
map {print ' 'x$_, "\n"}(1..$largeur_max);
# decroissant
map {print ' 'x$_, '*'x($largeur_max - $_), "\n"}(0..$largeur_max-1);

#!/bin/ruby
#Croissant
(gets.to_i+1).times {|star| puts "*"*star}
 
#décroissant
gets.to_i.downto(1) {|i| puts "*"*i}

#!/usr/bin/python
print "\n".join([('*'*i).rjust(10) for i in xrange(10,0,-1)])

section .data
 
    chaine: times 10 db 0x2a
    retour_chariot: db 0xa
        
section .text
 
    global _start
 
    _start:
                
        mov rcx,0
 
boucle:
        mov rax, 0
boucle2:
        cmp rax,rcx
        je fin
        mov byte [chaine + rax], 32 ;32=espace
        inc rax
        jmp boucle2
        
fin:
                
        ;sys_write
        push rcx
        mov rax, 4
        mov rbx, 2
        mov rcx, chaine
        mov rdx, 11
        int 80h
        
        pop rcx
        inc rcx
        cmp rcx, 10
        jb boucle
        
 
        ; Exit
        mov rax, 1
        mov rbx, 0
        int 80h

----------------------------------------
-- Star déssine un triangle d'étoile à
-- la base en haut.
----------------------------------------
 
with Ada.Text_Io, Ada.Integer_Text_Io, Ada.Strings.Fixed;
use Ada, Ada.Strings;
 
procedure Star is
 
   buffer : access String;
   -- buffer, alloué une seule fois à la saisie de la dimension.
 
   Dimension : Natural := 0;
   -- Dmention du triangle.
 
begin
 
   -- Saisie de la dimension du triangle.
   loop
      Saisie :
      begin
         Text_Io.Put("Saisissez la dimenssion de 1 à 80 : " );
         Integer_Text_Io.Get(Dimension);
         if Dimension > 0 and Dimension <=80 then
            exit;
         else
            raise Constraint_Error;
         end if;
      exception
         when Constraint_Error =>
            Text_Io.Put_Line("Erreur de saisie." );
      end Saisie;
   end loop;
 
   -- initialisation du buffer.
   Buffer := new String(1..Dimension);
 
   -- Affichage du triangle
   for Columns in reverse 1..Dimension loop
      Fixed.Move(Fixed."*"(Columns, '*'), Buffer.all, Error, Right, space);
      -- On place le nombre d'étoiles voulu dans le buffer justifié à droite.      
 
      Text_Io.Put_Line(Buffer.all);
      -- On affiche la ligne et on saute à la suivante.
   end loop;
   Text_Io.Get_Immediate(Buffer(1));
end star;

import java.util.Scanner;
 
class Stars {
    public static void main(String args[]){
        int max ;
        Scanner in= new Scanner(System.in);;
        
        System.out.println("Entrer le nombre d'étoiles" );
        max = Integer.parseInt(in.nextLine());
        System.out.println("Descendant (entrer D) ou ascendant (entrer A)?" );
    
        if (in.nextLine().equals("A" )) {
            for (int i=1; i<=max; i++) {
                printStars(i);
            }    
        }else {
            for (int i=max; i>0; --i) {
                printStars(i);
            }    
        }
 
        in.close();
    }
    
    private static void printStars(int number){
        for(int j=0; j<number; j++){
            System.out.print("*" );
        }
        System.out.println("" );
    }
}

1. #!/bin/bash
2. echo longueur?
3. read longueur
5. for (( i=0 ; $i<$longueur ; i=$i+1 ))
6. do
7.     for (( j=0 ; $j<$longueur ; j=$j+1 ))
8.     do
9.         if [ $j -lt $i ]
10.         then
11.             echo -n ' '
12.         else
13.             echo -n '*'
14.         fi
15.     done
16.     echo
17. done

1. $largeur = 10;
2. for($k = (2 << ($largeur-1)) - 1; $k > 0; $k = $k >> 1) echo str_replace('1','*',sprintf("%{$largeur}b\n", $k));

1. #include <iostream>
2. #include <iomanip>
4. template<int n, int w=n>
5. struct Star
6. {
7.     Star()
8.     {
9.         std::cout << std::setfill(' ') << std::setw(w-n) << "" << std::setfill('*') << std::setw(n) << '\n';
10.         Star<n-1, w> foo;
11.     }
12. };
14. template<int w>
15. struct Star<0, w>
16. {
17.     Star()
18.     {
19.     }
20. };
22. int main()
23. {
24.     Star<10> toto;
25.     return 0;
26. }

1. #include <iostream>
2. #include <algorithm>
3. #include <string>
4. #include <iterator>
6. struct Etoiles: public std::iterator<std::forward_iterator_tag, std::string>
7. {
8.     Etoiles(std::string const& s) : s_(s) {}
10.     Etoiles& operator++() { s_[s_.find('*')] = ' '; return *this; }
12.     std::string operator*() const { return s_; }
14.     friend bool operator!=(Etoiles const& l, Etoiles const& r)
15.         { return l.s_ != r.s_; }
17. private:
18.     std::string s_;
19. };
21. int main()
22. {
23.     std::copy(Etoiles("**********" ), Etoiles("          " ),
24.               std::ostream_iterator<std::string>(std::cout, "\n" ));
25.     return 0;
26. }

1. #include <iostream>
2. #include <algorithm>
3. #include <string>
4. #include <iterator>
6. struct Mutate: public std::iterator<std::forward_iterator_tag, std::string>
7. {
8.     Mutate() : end_(true) {}
9.     Mutate(std::string const& s,
10.             std::string const& d) : s_(s), d_(d), end_(false) {
11.         d_.resize(std::max(s_.size(), d_.size()), ' ');
12.         s_.resize(std::max(s_.size(), d_.size()), ' ');
13.     }
15.     Mutate& operator++() {
16.         std::pair<std::string::iterator, std::string::iterator>
17.             i = std::mismatch(s_.begin(), s_.end(), d_.begin());
18.         *i.first = *i.second;
19.         return *this;
20.     }
22.     std::string operator*() const { return s_; }
24.     friend bool operator!=(Mutate const& l, Mutate const& r)
25.     { return !(l.s_ == r.s_
26.                || (l.end_ && r.s_ == r.d_)
27.                || (r.end_ && l.s_ == l.d_)); }
29. private:
30.     std::string s_;
31.     std::string d_;
32.     bool end_;
33. };
35. int main()
36. {
37.     std::copy(Mutate("", "**********" ), Mutate(),
38.               std::ostream_iterator<std::string>(std::cout, "\n" ));
39.     std::copy(Mutate("**********", "" ), Mutate(),
40.               std::ostream_iterator<std::string>(std::cout, "\n" ));
41.     return 0;
42. }