Echivalarea Structurilor Repetitive

Transformarea corectă a structurii REPRTĂ într-o

altă structură repetitivă cu număr necunoscut de pași este:

• i ← a

  cât timp i ≤ b execută

  { <instrucțiuni>

  i ← i + 1 }

• cât timp not

  <conditie> execută

  { <instrucțiuni> }

• cât timp

  <condiție> executa

  { <instrucțiuni> }

• pentru i←a,b execută

  { <instrucțiuni> }

Pentru > Repetă

i ← a

dacă i ≤ b atunci

repetă

<instrucțiuni>

i ← i + 1

până când i > b

• ADEVĂRAT

• FALS

Care este transformarea corectă a structurii repetitive cu număr cunoscut de pași într-o structură repetitivă cu test inițial?

• i ← a

  cât timp i ≤ b execută {<S.I.>

  i ← i + 1}

• pentru i←a,b execută

  <S.I.>

• <S.I.>

  cât timp not

  ( <condiție> ) execută <S.I.>

• i ← a

  dacă i ≤ b atunci

  {repetă

  {<S.I.>

  i ← i + 1}

  până când i > b

  }

Este adevărat că o structură repetitivă cu număr necunoscut de pași poate fi transformată într-o altă structură cu număr necunoscut de pași?

• ADEVĂRAT

• FALS

Transformarea corectă din cât timp într-o structură repetitivă cu test final este:

• repetă

  <S.I.>

  până când

  not ( <condiție> )

• dacă <condiție> atunci {repetă

  <S.I.>

  până când

  ! ( <condiție> )

  }

• dacă <condiție> atunci {repetă

  <S.I.>

  până când

  ( <condiție> )

  }

• dacă <condiție> atunci {repetă

  <S.I.>

  până când

  not( <condiție> )

  }

Scrieţi în pseudocod un algoritm echivalent cu cel dat, înlocuind

adecvat prima structură cât timp...execută cu o structură

repetitivă cu test final.

citeşte m,n

(numere naturale nenule, m<n)

x<-1

cât timp x=1 execută

{ x<-m; y<-n; n<-n-1

{cât timp x≠y execută

{dacă x>y atunci x<-x-y

altfel y<-y-x

}

}

}

scrie n+1

• citeşte m,n

  (numere naturale nenule, m<n)

  x<-1

  dacă x=1 atunci

  repetă

  { x<-m; y<-n; n<-n-1

  {cât timp x≠y execută

  {dacă x>y atunci x<-x-y

  altfel y<-y-x

  } } }

  până când x≠1

  scrie n-1

• citeşte m,n

  (numere naturale nenule, m<n)

  x<-1

  dacă x=y atunci

  repetă

  { x<-m; y<-n; n<-n-1

  {cât timp x≠y execută

  {dacă x>y atunci x<-x-y

  altfel y<-y-x

  } } }

  până când x≠1

  scrie n+1

• citeşte m,n

  (numere naturale nenule, m<n)

  x<-1

  dacă x=1 atunci

  repetă

  { x<-m; y<-n; n<-n-1

  {cât timp x≠y execută

  {dacă x>y atunci x<-x-y

  altfel y<-y-x

  } } }

  până când x≠1

  scrie n+1

• citeşte m,n

  (numere naturale nenule, m<n)

  x<-1

  dacă x=1 atunci

  repetă

  { x<-m; y<-n; n<-n-1

  {cât timp x≠y execută

  {dacă x>y atunci x<-x-y

  altfel y<-y-x

  } } }

  până când x≠1

  scrie n