Difference between revisions of "Clasa a V-a lecția 8 - 12 oct 2019"

From Algopedia
Jump to: navigation, search
(Created page with "= Tema - rezolvări = == Algoritmi (scheme logice + programe C) == * Calculați x<sup>11</sup> cu număr minim de înmulțiri: Care este numărul minim? '''Răspuns''': numă...")
 
(Tema)
(4 intermediate revisions by the same user not shown)
Line 93: Line 93:
  
 
'''Răspuns'''<nowiki>: Kant a pornit ceasul de acasă și l-a pus pe o oră oarecare, să-i spunem h1 . Apoi a plecat la prietenul său, unde și-a notat timpul, să-i spunem h2. Înainte să plece și-a notat din nou timpul, să-i spunem h3. Cînd a ajuns acasă ceasul său arăta h4. Diferența h4 – h1 este timpul cît a fost plecat. Diferența h3 – h2 este timpul cît a stat la prietenul său. (h4 – h1) – (h3 – h2) este timpul pe care l-a făcut pe drum, dus-întors. Jumate din acest timp l-a făcut la întoarcere. Adunînd la timpul de plecare de la prietenul său timpul de întoarcere Kant a aflat ora exactă h = h3 + [(h4 – h1) – (h3 – h2)] / 2.</nowiki>
 
'''Răspuns'''<nowiki>: Kant a pornit ceasul de acasă și l-a pus pe o oră oarecare, să-i spunem h1 . Apoi a plecat la prietenul său, unde și-a notat timpul, să-i spunem h2. Înainte să plece și-a notat din nou timpul, să-i spunem h3. Cînd a ajuns acasă ceasul său arăta h4. Diferența h4 – h1 este timpul cît a fost plecat. Diferența h3 – h2 este timpul cît a stat la prietenul său. (h4 – h1) – (h3 – h2) este timpul pe care l-a făcut pe drum, dus-întors. Jumate din acest timp l-a făcut la întoarcere. Adunînd la timpul de plecare de la prietenul său timpul de întoarcere Kant a aflat ora exactă h = h3 + [(h4 – h1) – (h3 – h2)] / 2.</nowiki>
 +
 +
= Lecție =
 +
 +
== Cum rezolvăm o problemă de algoritm ==
 +
Atunci când rezolvați o problemă nu vă repeziți să scrieți programul C. Tot ce am făcut împreună are un scop. Urmăriți următoarele etape:
 +
# Mai întâi gîndiți-vă la modul cum ați rezolva-o voi, "de mână". Pentru fiecare din ideile de rezolvare treceți prin etapele de mai jos.
 +
# Elaborați regula observată într-o metodă. Asigurați-vă că știți să traduceți acea metodă în pași pe calculator. Dacă aveți nevoie să inversați ordinea cifrelor unui număr, știți pașii elementari pentru asta?
 +
# Verificați că metoda funcționează pe câteva exemple, nu doar pe exemplul furnizat de problemă. Pentru aceasta creați-vă propriile exemple de test.
 +
# Scrieți schema logică.
 +
# Verificați schema logică pe exemple. Faceți corecturile necesare, dacă observați greșeli în metoda pe care ați gândit-o original. Verificați, de asemenea, că schema logică funcționează pe exemple la limită: când <code>n</code> este zero, sau unu, sau număr prim, etc. Rularea schemei logice se face ținând efectiv degetul pe săgeți până ajungeți la blocul de STOP. Păstrați un tabel cu valorile tuturor variabilelor la orice moment.
 +
# Deschideți Code::Blocks și creați un proiect.
 +
# Navigați la ''Project - Build Options'' și setați opțiunile ''-Wall'' și ''-O2''.
 +
# Introduceți programul C urmărind identic schema logică. Salvați cât mai des în timpul introducerii, folosind combinația ''CTRL-s''.
 +
# La final salvați din nou, apoi compilați apăsând butonul ''Build'', cel cu rotița dințată. Nu apăsați ''Build and run''!
 +
# Urmăriți cu atenție mesajele din secțiunea de jos, atât erorile cât și avertismentele (warnings). Corectați sursa pentru a nu mai avea astfel de mesaje.
 +
# Executați programul apăsând butonul ''Run'', cel cu triunghiul ''play''. Introduceți cât mai multe date, în execuții succesive, pentru a testa diverse cazuri. Testați cu precădere cazurile limită, 0, 1, etc.
 +
# După ce aduceți corecții programului, modificați corespunzător și schema logică, apoi reluați testarea.
 +
 +
== Exercițiul 1 - palindrom ==
 +
Se citește un număr <code>n</code>. Să se spună dacă <code>n</code> este palindrom. Un număr este palindrom dacă prima lui cifră este egală cu ultima, a doua cu penultima și așa mai departe. Exemple de palindroame: 15351, 7337 sau 12233221.
 +
 +
Pentru a rezolva exerciţiul am observat următoarea proprietate: inversul unui număr palindrom este egal cu numărul original. Schema logică calculează inversul numărului <code>n</code> în variabila <code>r</code> şi apoi compară <code>r</code> cu originalul. Deoarece variabila <code>n</code> este modificată pe parcursul caculului, vom memora o copie a ei in variabila <code>nc</code>.
 +
 +
{|
 +
| [[Image:sl-palindrom-2.gif|frame|none|Palindrom]]
 +
| valign="top"|<syntaxhighlight>#include <stdio.h>
 +
 +
int main() {
 +
  int n, nc, r;
 +
 +
  scanf( "%d", &n );
 +
  nc = n;
 +
  r = 0;
 +
  while ( n > 0 ) {
 +
    r = r * 10 + n % 10;
 +
    n = n / 10;
 +
  }
 +
  if ( nc == r )
 +
    printf( "%d este palindrom\n", nc );
 +
  else
 +
    printf( "%d nu este palindrom\n", nc );
 +
  return 0;
 +
}</syntaxhighlight>
 +
|}
 +
== Exerciţiul 2 - divizorii unui număr ==
 +
Se citește un număr <code>n</code>, să se afișeze toți divizorii lui <code>n</code>. Spunem că <code>d</code> este divizor al lui <code>n</code> dacă <code>n</code> se împarte la <code>d</code>.
 +
 +
Pentru a rezolva exerciţiul vom varia un contor <code>d</code> de la 1 la <code>n</code>. El reprezintă potenţialii divizori ai lui <code>n</code>. Pentru fiecare valoare a lui <code>d</code> vom testa dacă <code>n</code> se împarte la <code>d</code>. Dacă da, vom afişa acel divizor.
 +
 +
{|
 +
| [[Image:sl-divizorii-lui-n.gif|frame|none|Divizorii lui n]]
 +
| valign="top"|<syntaxhighlight>#include <stdio.h>
 +
 +
int main() {
 +
  int n, d;
 +
 +
  scanf( "%d", &n );
 +
  printf( "Divizorii lui %d sint:", n );
 +
  d = 1;
 +
  while ( d <= n ) {
 +
    if ( n % d == 0 )
 +
      printf( " %d", d );
 +
    d = d + 1;
 +
  }
 +
  printf( "\n" );
 +
 +
  return 0;
 +
}</syntaxhighlight>
 +
|}
 +
 +
Observație: între <code>n/2</code> și <code>n</code> nu mai avem nici un divizor, deci am putea optimiza algoritmul punînd condiția <code>while ( d <= n / 2 )</code> și afișînd <code>n</code>, ultimul divizor, separat, în afara buclei <code>while</code>
 +
=== Modificare ===
 +
 +
O modificare ușoară a exerciţiului este: se citește un număr <code>n</code>. Să se afișeze toți divizorii impari ai lui <code>n</code>. Singura diferență este că vom adăuga 2 la <code>d</code> în loc de 1:
 +
 +
:<code>d ← d + 2</code>
 +
 +
== Operatori logici ==
 +
Condițiile care apar în blocurile de decizie (romburi) și în instrucțiunile <code>if</code> și <code>while</code> din C pot fi compuse folosind următorii operatori logici: '''și''', '''sau''' și '''not''' (în scheme logice), sau <code>&&</code>, <code>||</code> și <code>!</code> În limbajul C. Iată exemple de folosire în următoarele exerciții:
 +
 +
== Exerciţiul 3 - număr prim ==
 +
Se citește un număr <code>n</code>. Să se spună dacă <code>n</code> este prim. Un număr este prim dacă nu se împarte decît la 1 și la el însuși.
 +
 +
Vom proceda similar cu afişarea divizorilor: vom căuta primul divizor al lui <code>n</code>, începînd cu 2. Dacă găsim un divizor numărul nu este prim. Dacă, în schimb, primul divizor găsit este chiar <code>n</code>, numărul este prim.
 +
 +
{|
 +
| [[Image:sl-numar-prim.gif|frame|none|Număr prim]]
 +
| valign="top"|<syntaxhighlight>#include <stdio.h>
 +
 +
int main() {
 +
  int n, d;
 +
 +
  scanf( "%d", &n );
 +
  d = 2;
 +
  while ( d < n && n % d > 0 )
 +
    d = d + 1;
 +
  if ( d == n )
 +
    printf( "%d este prim\n", n );
 +
  else
 +
    printf( "%d nu este prim\n", n );
 +
 +
  return 0;
 +
}</syntaxhighlight>
 +
|}
 +
 +
Observații:
 +
# Avem cu adevărat nevoie de condiția <code>d < n</code>? Justificați răspunsul.
 +
# Putem face mai puține iterații dacă observăm că dacă un număr nu are nici un divizor strict mai mare ca 1 dar mai mic sau egal cu radical din <code>n</code> atunci el nu va avea nici alți divizori mai mari decît radical din <code>n</code> dar mai mici decît <code>n</code>. Cum justificăm acest lucru? Putem, deci, înlocui condiția <code>d < n</code> cu <code>d * d <= n</code>. În acest caz va trebui să modificăm condiția finală de test de primalitate din <code>d == n</code> în <code>d * d > n</code>.
 +
 +
Iată algoritmul modificat:
 +
 +
{|
 +
| [[Image:sl-numar-prim-2.gif|frame|none|Număr prim]]
 +
| valign="top"|<syntaxhighlight>#include <stdio.h>
 +
 +
int main() {
 +
  int n, d;
 +
 +
  scanf( "%d", &n );
 +
  d = 2;
 +
  while ( d * d <= n && n % d > 0 )
 +
    d = d + 1;
 +
  if ( d * d > n )
 +
    printf( "%d este prim\n", n );
 +
  else
 +
    printf( "%d nu este prim\n", n );
 +
 +
  return 0;
 +
}</syntaxhighlight>
 +
|}
 +
 +
== Exerciţiul 4 - numere prime pînă la n ==
 +
Se citește un număr <code>n</code>. Să se afișeze toate numerele prime mai mici sau egale cu <code>n</code>.
 +
 +
Vom folosi exerciţiul anterior. Vom varia un contor p de la 2 pînă la <code>n</code>. Aceste numere pot sau nu să fie numere prime, drept pentru care vom testa fiecare din ele dacă este prim.
 +
{|
 +
| [[Image:sl-nr-prime-pina-la-n.gif|frame|none|Numere prime pînă la n]]
 +
| valign="top"|<syntaxhighlight>#include <stdio.h>
 +
 +
int main() {
 +
  int n, p, d;
 +
 +
  scanf( "%d", &n );
 +
  printf( "Nr. prime pina la %d:", n );
 +
  p = 2;
 +
  while ( p <= n ) {
 +
    d = 2;
 +
    while ( d < p && p % d > 0 )
 +
      d = d + 1;
 +
    if ( d == p )
 +
      printf( " %d", p );
 +
    p = p + 1;
 +
  }
 +
  printf( "\n" );
 +
 +
  return 0;
 +
}</syntaxhighlight>
 +
|}
 +
 +
Observație: acesta este primul nostru algoritm în care am folosit două bucle <code>while</code> imbricate (una într-alta). Interesant, nu?
 +
 +
= Tema =
 +
* Să se rezolve următoarele probleme (schemă logică + program C executat în CodeBlocks):
 +
** Să se afișeze toți divizorii impari ai lui <code>n</code>.
 +
** Se citesc două numere, <code>n</code> și <code>k</code>. Să se afișeze toate numerele mai mici sau egale cu <code>n</code> care se divid cu <code>k</code>. Exemple: pentru <code>n = 7 k = 2</code> se va afișa 2 4 6; pentru <code>n = 25 k = 5</code> se va afișa 5 10 15 20 25.
 +
** Se citește un număr <code>n</code>. Să se afișeze toate numerele perfecte mai mici sau egale cu <code>n</code>. Un număr este ''perfect'' dacă este egal cu suma divizorilor lui strict mai mici ca el. Primul număr perfect este 6, deoarece 6 = 1 + 2 + 3. Următorul număr este 28 deoarece 28 = 1 + 2 + 4 + 7 + 14. Exemple: dacă <code>n = 8</code> se va afișa 6. Dacă <code>n = 30</code> se va afișa 6 28. Dacă <code>n = 500</code> se va afișa 6 28 496.
 +
* Problemă de logică: ce linie urmează în secvență:
 +
<pre>      1
 +
      1 1
 +
      2 1
 +
    1 2 1 1
 +
  1 1 1 2 2 1
 +
  3 1 2 2 1 1
 +
1 3 1 1 2 2 2 1</pre>
 +
 +
Rezolvări aici [http://solpedia.francu.com/wiki/index.php/Clasa_a_V-a_lec%C8%9Bia_9_-_5_oct_2017]

Revision as of 16:18, 7 October 2019

Tema - rezolvări

Algoritmi (scheme logice + programe C)

  • Calculați x11 cu număr minim de înmulțiri: Care este numărul minim?

Răspuns: numărul minim de înmulțiri este 5. Demonstrați că nu puteți rezolva problema cu 4 înmulțiri. O posibilitate de calcul este:

x11 cu număr minim de înmulțiri
#include <stdio.h>
int main() {
  int x, x2, x4, x8, x11;

  scanf( "%d", &x );
  x2 = x * x;
  x4 = x2 * x2;
  x8 = x4 * x4;
  x11 = x8 * x2 * x;
  printf( "%d la puterea 11 = %d\n", x, x11 );

  return 0;
}
  • Se citește un număr n. Să se spună cîte cifre pare are el. Exemple: dacă n=3528 el are 2 cifre pare (2 și 8), dacă n=49285640 el are 6 cifre pare (4, 2, 8, 6, 4, 0).

Răspuns 1:

Cîte cifre pare are numărul n
#include <stdio.h>

int main() {
  int n, c, nrp;

  scanf( "%d", &n );
  nrp = 0;
  while ( n > 0 ) {
    c = n % 10;
    n = n / 10;
    if ( c % 2 == 0 )
      nrp = nrp + 1;
  }
  printf( "Nr. cifre pare: %d\n", nrp );

  return 0;
}

Răspuns 2: Putem simplifica această soluție? Iată ce putem face:

  1. Precum am mai discutat mai demult, n % 10 % 2 este totuna cu n % 2. Deci testul c % 2 == 0 poate fi înlocuit cu n % 2 == 0, scutind un calcul și o variabilă. Pentru aceasta trebuie să facem testul înainte de a îl împărți pe n la 10.
  2. Ce valori poate lua restul împărțirii la 2? Zero sau unu. Cînd adunăm 1 la nrp? Atunci cînd restul este 0. Atunci cînd restul este unu nu adunăm nimic la nrp, ceea ce este totuna cu a aduna zero. Cu alte cuvinte putem întotdeauna să adunăm negarea restului. Cum calculăm acest număr? El este 1 - rest.

Iată o soluție bazată pe aceste două simplificări:

Cîte cifre pare are numărul n varianta 2
#include <stdio.h>

int main() {
  int n, nrp;

  scanf( "%d", &n );
  nrp = 0;
  while ( n > 0 ) {
    nrp = nrp + 1 - n % 2;
    n = n / 10;
  }
  printf( "Nr. cifre pare: %d\n", nrp );

  return 0;
}
  • Se citește un număr n. Să se afișeze cel mai mare divizor propriu al lui n (strict mai mic decît n). Exemplu: dacă n=24 cel mai mare divizor propriu este 12. Dacă n=7 cel mai mare divizor propriu este 1. Dacă n=125 cel mai mare divizor propriu este 25. Dacă n=175 cel mai mare divizor propriu este 35.

Răspuns:

Cel mai mare divizor propriu al lui n
#include <stdio.h>

int main() {
  int n, d;

  scanf( "%d", &n );
  d = n - 1;
  while ( n % d > 0 )
    d = d - 1;
  printf( "Cel mai mare divizor propriu: %d\n", d );
  return 0;
}

Problemă de logică

Filozoful Immanuel Kant a ajuns acasă unde a constatat că ceasul de perete a stat deoarece a uitat să-l întoarcă. El a plecat către prietenul lui bun. Acolo a stat o vreme la discuții filozofice, apoi s-a întors înapoi acasă unde a potrivit ceasul la ora exactă! Cum a procedat Kant? Se știe că:

  • Prietenul lui Kant are un ceas care merge bine
  • Pe vremea lui Kant nu existau ceasuri de mînă sau alte dispozitive mobile cu ceas
  • Kant merge cu viteză constantă, de ani de zile aceeași.

Răspuns: Kant a pornit ceasul de acasă și l-a pus pe o oră oarecare, să-i spunem h1 . Apoi a plecat la prietenul său, unde și-a notat timpul, să-i spunem h2. Înainte să plece și-a notat din nou timpul, să-i spunem h3. Cînd a ajuns acasă ceasul său arăta h4. Diferența h4 – h1 este timpul cît a fost plecat. Diferența h3 – h2 este timpul cît a stat la prietenul său. (h4 – h1) – (h3 – h2) este timpul pe care l-a făcut pe drum, dus-întors. Jumate din acest timp l-a făcut la întoarcere. Adunînd la timpul de plecare de la prietenul său timpul de întoarcere Kant a aflat ora exactă h = h3 + [(h4 – h1) – (h3 – h2)] / 2.

Lecție

Cum rezolvăm o problemă de algoritm

Atunci când rezolvați o problemă nu vă repeziți să scrieți programul C. Tot ce am făcut împreună are un scop. Urmăriți următoarele etape:

  1. Mai întâi gîndiți-vă la modul cum ați rezolva-o voi, "de mână". Pentru fiecare din ideile de rezolvare treceți prin etapele de mai jos.
  2. Elaborați regula observată într-o metodă. Asigurați-vă că știți să traduceți acea metodă în pași pe calculator. Dacă aveți nevoie să inversați ordinea cifrelor unui număr, știți pașii elementari pentru asta?
  3. Verificați că metoda funcționează pe câteva exemple, nu doar pe exemplul furnizat de problemă. Pentru aceasta creați-vă propriile exemple de test.
  4. Scrieți schema logică.
  5. Verificați schema logică pe exemple. Faceți corecturile necesare, dacă observați greșeli în metoda pe care ați gândit-o original. Verificați, de asemenea, că schema logică funcționează pe exemple la limită: când n este zero, sau unu, sau număr prim, etc. Rularea schemei logice se face ținând efectiv degetul pe săgeți până ajungeți la blocul de STOP. Păstrați un tabel cu valorile tuturor variabilelor la orice moment.
  6. Deschideți Code::Blocks și creați un proiect.
  7. Navigați la Project - Build Options și setați opțiunile -Wall și -O2.
  8. Introduceți programul C urmărind identic schema logică. Salvați cât mai des în timpul introducerii, folosind combinația CTRL-s.
  9. La final salvați din nou, apoi compilați apăsând butonul Build, cel cu rotița dințată. Nu apăsați Build and run!
  10. Urmăriți cu atenție mesajele din secțiunea de jos, atât erorile cât și avertismentele (warnings). Corectați sursa pentru a nu mai avea astfel de mesaje.
  11. Executați programul apăsând butonul Run, cel cu triunghiul play. Introduceți cât mai multe date, în execuții succesive, pentru a testa diverse cazuri. Testați cu precădere cazurile limită, 0, 1, etc.
  12. După ce aduceți corecții programului, modificați corespunzător și schema logică, apoi reluați testarea.

Exercițiul 1 - palindrom

Se citește un număr n. Să se spună dacă n este palindrom. Un număr este palindrom dacă prima lui cifră este egală cu ultima, a doua cu penultima și așa mai departe. Exemple de palindroame: 15351, 7337 sau 12233221.

Pentru a rezolva exerciţiul am observat următoarea proprietate: inversul unui număr palindrom este egal cu numărul original. Schema logică calculează inversul numărului n în variabila r şi apoi compară r cu originalul. Deoarece variabila n este modificată pe parcursul caculului, vom memora o copie a ei in variabila nc.

Palindrom
#include <stdio.h>

int main() {
  int n, nc, r;

  scanf( "%d", &n );
  nc = n;
  r = 0;
  while ( n > 0 ) {
    r = r * 10 + n % 10;
    n = n / 10;
  }
  if ( nc == r )
    printf( "%d este palindrom\n", nc );
  else
    printf( "%d nu este palindrom\n", nc );
  return 0;
}

Exerciţiul 2 - divizorii unui număr

Se citește un număr n, să se afișeze toți divizorii lui n. Spunem că d este divizor al lui n dacă n se împarte la d.

Pentru a rezolva exerciţiul vom varia un contor d de la 1 la n. El reprezintă potenţialii divizori ai lui n. Pentru fiecare valoare a lui d vom testa dacă n se împarte la d. Dacă da, vom afişa acel divizor.

Divizorii lui n
#include <stdio.h>

int main() {
  int n, d;

  scanf( "%d", &n );
  printf( "Divizorii lui %d sint:", n );
  d = 1;
  while ( d <= n ) {
    if ( n % d == 0 )
      printf( " %d", d );
    d = d + 1;
  }
  printf( "\n" );

  return 0;
}

Observație: între n/2 și n nu mai avem nici un divizor, deci am putea optimiza algoritmul punînd condiția while ( d <= n / 2 ) și afișînd n, ultimul divizor, separat, în afara buclei while

Modificare

O modificare ușoară a exerciţiului este: se citește un număr n. Să se afișeze toți divizorii impari ai lui n. Singura diferență este că vom adăuga 2 la d în loc de 1:

d ← d + 2

Operatori logici

Condițiile care apar în blocurile de decizie (romburi) și în instrucțiunile if și while din C pot fi compuse folosind următorii operatori logici: și, sau și not (în scheme logice), sau &&, || și ! În limbajul C. Iată exemple de folosire în următoarele exerciții:

Exerciţiul 3 - număr prim

Se citește un număr n. Să se spună dacă n este prim. Un număr este prim dacă nu se împarte decît la 1 și la el însuși.

Vom proceda similar cu afişarea divizorilor: vom căuta primul divizor al lui n, începînd cu 2. Dacă găsim un divizor numărul nu este prim. Dacă, în schimb, primul divizor găsit este chiar n, numărul este prim.

Număr prim
#include <stdio.h>

int main() {
  int n, d;

  scanf( "%d", &n );
  d = 2;
  while ( d < n && n % d > 0 )
    d = d + 1;
  if ( d == n )
    printf( "%d este prim\n", n );
  else
    printf( "%d nu este prim\n", n );

  return 0;
}

Observații:

  1. Avem cu adevărat nevoie de condiția d < n? Justificați răspunsul.
  2. Putem face mai puține iterații dacă observăm că dacă un număr nu are nici un divizor strict mai mare ca 1 dar mai mic sau egal cu radical din n atunci el nu va avea nici alți divizori mai mari decît radical din n dar mai mici decît n. Cum justificăm acest lucru? Putem, deci, înlocui condiția d < n cu d * d <= n. În acest caz va trebui să modificăm condiția finală de test de primalitate din d == n în d * d > n.

Iată algoritmul modificat:

Număr prim
#include <stdio.h>

int main() {
  int n, d;

  scanf( "%d", &n );
  d = 2;
  while ( d * d <= n && n % d > 0 )
    d = d + 1;
  if ( d * d > n )
    printf( "%d este prim\n", n );
  else
    printf( "%d nu este prim\n", n );

  return 0;
}

Exerciţiul 4 - numere prime pînă la n

Se citește un număr n. Să se afișeze toate numerele prime mai mici sau egale cu n.

Vom folosi exerciţiul anterior. Vom varia un contor p de la 2 pînă la n. Aceste numere pot sau nu să fie numere prime, drept pentru care vom testa fiecare din ele dacă este prim.

Numere prime pînă la n
#include <stdio.h>

int main() {
  int n, p, d;

  scanf( "%d", &n );
  printf( "Nr. prime pina la %d:", n );
  p = 2;
  while ( p <= n ) {
    d = 2;
    while ( d < p && p % d > 0 )
      d = d + 1;
    if ( d == p )
      printf( " %d", p );
    p = p + 1;
  }
  printf( "\n" );

  return 0;
}

Observație: acesta este primul nostru algoritm în care am folosit două bucle while imbricate (una într-alta). Interesant, nu?

Tema

  • Să se rezolve următoarele probleme (schemă logică + program C executat în CodeBlocks):
    • Să se afișeze toți divizorii impari ai lui n.
    • Se citesc două numere, n și k. Să se afișeze toate numerele mai mici sau egale cu n care se divid cu k. Exemple: pentru n = 7 k = 2 se va afișa 2 4 6; pentru n = 25 k = 5 se va afișa 5 10 15 20 25.
    • Se citește un număr n. Să se afișeze toate numerele perfecte mai mici sau egale cu n. Un număr este perfect dacă este egal cu suma divizorilor lui strict mai mici ca el. Primul număr perfect este 6, deoarece 6 = 1 + 2 + 3. Următorul număr este 28 deoarece 28 = 1 + 2 + 4 + 7 + 14. Exemple: dacă n = 8 se va afișa 6. Dacă n = 30 se va afișa 6 28. Dacă n = 500 se va afișa 6 28 496.
  • Problemă de logică: ce linie urmează în secvență:
       1
      1 1
      2 1
    1 2 1 1
  1 1 1 2 2 1
  3 1 2 2 1 1
1 3 1 1 2 2 2 1

Rezolvări aici [1]