Cấu trúc vòng lặp do while

do {
   thực_hiện_công_việc();  
} while (điều_kiện);

thực_hiện_công_việc();
while (điều_kiện) {
   thực_hiện_công_việc();
}

while (true) {
   thực_hiện_công_việc();
   if (!điều_kiện) break;
}

LOOPSTART:
   thực_hiện_công_việc();
   if (điều_kiện) goto LOOPSTART;

var dem:int = 5;
var giaiThua:int = 1;
do {
  giaiThua *= dem--; /* Nhân rồi giảm. */
} while (dem > 0);
trace(giaiThua);

with Ada.Integer_Text_IO;

procedure GiaiThua is
  Dem : Integer:= 5;
  GiaiThua: Integer:= 1;
begin
  loop
    GiaiThua:= GiaiThua * Dem;
    Dem := Dem - 1;
    exit when Dem = 0;
  end loop;

  Ada.Integer_Text_IO.Put (GiaiThua);
end GiaiThua;

Khai báo factorial Như Số nguyên
Khai báo counter Như Số nguyên
factorial = 1
counter = 5
Thực hiện 
   factorial = factorial * counter
   counter = counter - 1
Lặp Khi counter > 0
In factorial

int counter = 5;
int factorial = 1;
do 
{
  factorial *= counter--; /* Nhân, sau đó giảm. */
} khi (counter > 0);
System.Console.WriteLine(factorial);

int counter = 5;
int factorial = 1;
do {
  factorial *= counter--; /* Nhân, sau đó giảm. */
} khi 
  

    
  
  (counter > 0);
printf('giai thừa của 5 là %d\n', factorial);

int counter = 5;
int factorial = 1;
do {
  factorial *= counter--;
} khi (counter > 0);
std::cout<<'giai thừa của 5 là '<<factorial<<std::endl;

factorial = 1;
count = 10;
do {
   factorial *= count--;
} khi (count > 1);

writeOutput(factorial);

int counter = 5;
int factorial = 1;

do {
  factorial *= counter--; // Nhân và giảm
} khi (counter > 0);
writeln('giai thừa của 5 là ', factorial);

      INTEGER CNT,FACT
      CNT=5
      FACT=1
    1 CONTINUE
      FACT=FACT*CNT
      CNT=CNT-1
      IF (CNT.GT.0) GOTO 1
      PRINT*,FACT
      END

chương trình FactorialProg
  nguyên:: đếm = 5
  nguyên:: giai thừa = 1
  giai thừa = giai thừa * đếm
  đếm = đếm - 1
  lặp khi (đếm > 0)
    giai thừa = giai thừa * đếm
    đếm = đếm - 1
  kết thúc lặp
  in ra *, giai thừa
kết thúc chương trình FactorialProg

int đếm = 5;
int giai thừa = 1;
lặp {
    giai thừa *= đếm--; /* Nhân rồi giảm. */
} trong khi (đếm > 0);
System.out.println('Giai thừa của 5 là ' + giai thừa);

var đếm = 5;
var giai thừa = 1;
lặp {
    giai thừa *= đếm--;
} trong khi (đếm > 0);
console.log(giai thừa);

var đếm = 5
var giai thừa = 1
lặp {
    giai thừa *= đếm--
}trong khi(đếm > 0)
println('Giai thừa của 5 là $giai thừa')

đếm = 5
giai thừa = 1
while True:
    giai thừa *= đếm
    đếm -= 1
    if đếm == 0:
        break
print(giai thừa)

#lang racket
(định nghĩa đếm 5)
(định nghĩa giai thừa 1)
(let vòng lặp ()
  (set! giai thừa (* giai thừa đếm))
  (set! đếm (sub1 đếm))
  (when (> đếm 0) (vòng lặp)))
(displayln giai thừa)

(định nghĩa (giai thừa n)
  (do ((đếm n (- đếm 1))
       (kết quả 1 (* kết quả đếm)))
    ((= đếm 0) kết quả); Điều kiện dừng và giá trị trả về.
  ; Thân của vòng lặp do là rỗng.
  ))

biến đếm = 10
giaiThua = 2
bắt đầu
  giaiThua *= biến đếm
  biến đếm -= 2
kết thúc trong khi biến đếm > 1
in ra giaiThua

| biến đếm giaiThua |
biến đếm:= 5.
giaiThua:= 1.
[biến đếm > 0] trongKhi: 
  [giaiThua:= giaiThua * biến đếm.
  biến đếm:= biến đếm - 1].
Transcript hiểnThị: giaiThua inRaChuoi

var counter = 5
var factorial = 1
lặp {
     factorial *= counter
     counter -= 1
} trong khi counter > 0
in(factorial)

var counter = 5
var factorial = 1
thực hiện {
     factorial *= counter
     counter -= 1
} trong khi counter > 0
in(factorial)

Dim counter As Integer = 5
Dim factorial As Integer = 1
Thực hiện
   factorial *= counter
   counter -= 1 
Vòng lặp trong khi counter > 0
Console.WriteLine(factorial)