Pagina Principală
Ora 15

Cel Mai Mic Multiplu Comun (CMMMC)

Învață să calculezi CMMMC folosind CMMDC și aplicații practice

40min teorie + 15min probleme PbInfo
Competența 3.3
Sigla liceului
TEORIE - 40 minute

Ce vei învăța astăzi?

După această lecție, vei stăpâni calcularea CMMMC folosind relația cu CMMDC și vei înțelege aplicațiile practice.

Ce este CMMMC și unde se folosește
Relația dintre CMMDC și CMMMC
CMMMC pentru mai multe numere
Aplicații practice ale CMMMC

Ce este CMMMC?

Definiție: Cel Mai Mic Multiplu Comun (CMMMC) a două numere naturale este cel mai mic număr pozitiv care este multiplu al ambelor numere.

Exemplu: CMMMC(4, 6) = 12 deoarece 12 este cel mai mic număr care este multiplu atât al lui 4 cât și al lui 6.

4
12
6
4
8
12
16
20
24
28
32
36
Multiplii lui 4
CMMMC(4,6)=12
Multiplii lui 6
6
12
18
24
30
36
42
48
54

Multiplii lui 4: 4, 8, 12, 16, 20, 24, 28, 32, 36...
Multiplii lui 6: 6, 12, 18, 24, 30, 36, 42, 48, 54...
Multipli comuni: 12, 24, 36, 48...
Cel mai mic: 12 ✓

Analogie: Zile de întâlnire

Gândește-te la CMMMC ca la prima zi când doi prieteni cu programe diferite se pot întâlni:

ANDREI

Vine la bibliotecă la 4 zile

Zilele: 4, 8, 12, 16, 20...
BOGDAN

Vine la bibliotecă la 6 zile

Zilele: 6, 12, 18, 24, 30...
ÎNTÂLNIRE

Prima zi comună: ziua 12

CMMMC(4,6)=12
URMĂTOAREA

A doua întâlnire: ziua 24

Următorul multiplu comun

Relația dintre CMMDC și CMMMC

FORMULA FUNDAMENTALĂ: CMMMC(a, b) × CMMDC(a, b) = a × b Sau: a × b CMMMC = ─────── CMMDC(a, b) EXEMPLE: Pentru a=4, b=6: CMMDC(4,6) = 2 a × b = 4 × 6 = 24 CMMMC = 24 / 2 = 12 ✓ Pentru a=12, b=18: CMMDC(12,18) = 6 a × b = 12 × 18 = 216 CMMMC = 216 / 6 = 36 ✓

De ce această formulă este importantă:

  1. Odată ce știm să calculăm CMMDC (algoritmul lui Euclid), putem calcula CMMMC instant
  2. Este mult mai eficientă decât găsirea multiplilor
  3. Funcționează pentru orice numere, chiar foarte mari
ALGORITM CMMMC_CuCMMDC VARIABILE a, b, produs, cmmdc, cmmmc: întreg ÎNCEPUT CITESTE a, b // Calculăm CMMDC folosind algoritmul lui Euclid cmmdc ← CMMDC_Euclid(a, b) // Calculăm produsul produs ← a × b // Aplicăm formula cmmmc ← produs / cmmdc SCRIE "CMMMC = ", cmmmc SFÂRȘIT ALGORITM CMMDC_Euclid VARIABILE a, b, r: întreg ÎNCEPUT // Algoritmul lui Euclid ┌ CÂT TIMP b ≠ 0 EXECUTĂ │ r ← a % b │ a ← b │ b ← r └■ RETURNEZĂ a SFÂRȘIT

Exemplu pentru a=12, b=18:

CMMDC(12,18): Algoritmul Euclid: 12%18=12, 18%12=6, 12%6=0 → CMMDC=6
Produs: a×b = 12×18 = 216
CMMMC: 216 / 6 = 36 ✓
ALGORITM CMMMC_Factori VARIABILE a, b, cmmmc: întreg ÎNCEPUT CITESTE a, b // Descompunem în factori primi cmmmc ← 1 // Factorul 2 ┌ CÂT TIMP a % 2 = 0 SAU b % 2 = 0 EXECUTĂ │ ┌ DACA a % 2 = 0 ATUNCI │ │ a ← a / 2 │ └ SFÂRȘIT DACA │ ┌ DACA b % 2 = 0 ATUNCI │ │ b ← b / 2 │ └ SFÂRȘIT DACA │ cmmmc ← cmmmc × 2 └■ // Alți factori impari PENTRU d ← 3, √max(a,b), 2 EXECUTĂ ┌ CÂT TIMP a % d = 0 SAU b % d = 0 EXECUTĂ │ ┌ DACA a % d = 0 ATUNCI │ │ a ← a / d │ └ SFÂRȘIT DACA │ ┌ DACA b % d = 0 ATUNCI │ │ b ← b / d │ └ SFÂRȘIT DACA │ cmmmc ← cmmmc × d └■ SFÂRȘIT PENTRU // Factorii rămași ┌ DACA a > 1 ATUNCI │ cmmmc ← cmmmc × a └ SFÂRȘIT DACA ┌ DACA b > 1 ATUNCI │ cmmmc ← cmmmc × b └ SFÂRȘIT DACA SCRIE "CMMMC = ", cmmmc SFÂRȘIT

Metoda tradițională (mai lentă): Descompunem ambele numere în factori primi și luăm fiecare factor la puterea cea mai mare.

Exemplu: 12=2×3, 18=2×3 → CMMMC=2×3=4×9=36

Unde folosim CMMMC în viața reală?

Programări periodice

Dacă un eveniment are loc la 4 zile, altul la 6 zile, când se vor întâlni?

CMMMC(4,6)=12 zile

Roți dințate

Două roți cu 12 și 18 dinți. Când revin în poziția inițială?

CMMMC(12,18)=36 rotații ale roții mici

Ritmuri muzicale

Un instrument bate la 3 timpi, altul la 4. Când se sincronizează?

CMMMC(3,4)=12 timpi

Aducere la numitor comun

Pentru a aduna 1/4 + 1/6, avem nevoie de numitor comun

CMMMC(4,6)=12 → 3/12 + 2/12 = 5/12

Exercițiu de completare - Calcul CMMMC:

Completează codul C++ pentru calcularea CMMMC:
#include <iostream>
using namespace ______;
int cmmdc(int a, int b) {
    ______ (b != 0) { // Algoritmul lui Euclid
        int rest = a ______ b;
        a = b;
        b = rest;
    }
    ______ a;
}
______ main() {
    int a, b;
    cin >> a >> ______;
    int d = ______(a, b); // Calculăm CMMDC
    int cmmmc = (a ______ b) / d; // Formula CMMMC = (a×b)/CMMDC
    cout << ______;
    return ______;
}
Bancă de cuvinte:
std while % return int b cmmdc * cmmmc 0

Test de înțelegere: Care este CMMMC?

Test rapid:

Care este CMMMC(8, 12) folosind formula cu CMMDC?

Pașii de calcul:
Pas 1 - CMMDC(8,12): Algoritmul Euclid: 8%12=8, 12%8=4, 8%4=0 → CMMDC=4
Pas 2 - Produsul: a×b = 8×12 = 96
Pas 3 - Formula: CMMMC = (a×b) / CMMDC = 96 / 4 = ?

Sfaturi practice pentru calculul CMMMC

Întotdeauna folosește formula cu CMMDC

CMMMC = (a × b) / CMMDC(a, b) este cea mai rapidă metodă.

Atenție la overflow!

Pentru numere mari, a × b poate depăși limita lui int. Folosește long long.

Numere prime între ele

Dacă CMMDC=1 (numere prime între ele), atunci CMMMC = a × b.

Dacă un număr îl divide pe celălalt

Dacă a divide pe b, atunci CMMMC(a, b) = b (numărul mai mare).

Capcane comune și soluții pentru CMMMC

Greșeli frecvente la calculul CMMMC:

❌ Folosirea metodei naive (căutarea multiplilor)
// GREȘIT pentru numere mari! int multiplu = max(a, b); while (true) { if (multiplu % a == 0 && multiplu % b == 0) { break; // Foarte lent! } multiplu++; }

Soluție: Folosește întotdeauna formula cu CMMDC.

❌ Overflow la înmulțire

Pentru a=1000000, b=1000000, a×b depășește limita lui int.

long long cmmmc = (long long)a * b / cmmdc(a, b);
❌ Împărțirea înainte de înmulțire

a / cmmdc * b vs a * b / cmmdc. Prima variantă poate da rezultat greșit din cauza pierderii la împărțirea întreagă.

Best Practices pentru CMMMC:

✅ Folosește întotdeauna formula cu CMMDC
✅ Folosește long long pentru produs pentru a evita overflow
✅ Verifică cazul a=0 sau b=0 - CMMMC(0,x)=0
✅ Reutilizează funcția CMMDC pe care o știi deja
✅ Pentru mai multe numere, folosește cmmmc = cmmmc(cmmmc(a,b), c)
PROBLEME PBINFO - 15 minute

PbInfo #13 - CMMMC a două numere

Enunț:

Cerință: Se citesc două numere naturale a și b. Să se calculeze CMMMC al celor două numere.

Date de intrare:

Programul citește de la tastatură numerele a și b.

Date de ieșire:

Programul va afișa pe ecran CMMMC al numerelor a și b.

Exemplu:

Intrare:

12 18

Ieșire:

36

Explicație: Cel mai mic multiplu comun al lui 12 și 18 este 36

Cum gândim soluția:
  1. Citim numerele a și b
  2. Calculăm CMMDC(a, b) folosind algoritmul lui Euclid
  3. Aplicăm formula: CMMMC = (a × b) / CMMDC
  4. Atenție la overflow: folosim long long pentru produs
  5. Afișăm rezultatul
Execuție pentru a=12, b=18:
Pas 1 - CMMDC: CMMDC(12,18) = 6 (algoritmul lui Euclid)
Pas 2 - Produs: a×b = 12×18 = 216
Pas 3 - CMMMC: 216 / 6 = 36 ✓
Verificare: Multiplii lui 12: 12,24,36,48... | Multiplii lui 18: 18,36,54... | Primul comun: 36
Ce trebuie să verifici mereu?
  • Cazul a=0 sau b=0: CMMMC(0, x) = 0
  • Numere prime între ele: CMMMC = a×b
  • Un număr divide pe celălalt: CMMMC = numărul mai mare
  • Numere mari: folosește long long pentru produs
  • Divizibilitate: (a × b) % CMMDC == 0 întotdeauna
Scrie soluția în C++:
Soluție corectă (fără funcții, doar în main):
#include <iostream>
using namespace std;

int main() {
    int a, b;
    cin >> a >> b;
    
    // Salvăm valorile originale pentru calculul produsului
    int originalA = a, originalB = b;
    
    // 1. Calculăm CMMDC cu algoritmul lui Euclid ITERATIV
    //    (Repetăm împărțirea până când b devine 0)
    while (b != 0) {
        int rest = a % b; // Calculăm restul împărțirii
        a = b;           // Mutăm numărul mai mic în a
        b = rest;        // Restul devine noul b
    }
    int cmmdc = a; // CMMDC este ultimul a nenul
    
    // 2. Calculăm CMMMC folosind formula
    //    Atenție la tipul long long pentru a evita depășirea!
    long long produs = (long long)originalA * originalB;
    long long cmmmc = produs / cmmdc;
    
    // 3. Afișăm rezultatul
    cout << cmmmc;
    
    return 0;
}
Varianta cu funcție simplă (NErecursivă):
#include <iostream>
using namespace std;

// Funcție ITERATIVĂ pentru CMMDC (fără recursivitate)
int cmmdcIterativ(int x, int y) {
    while (y != 0) {
        int rest = x % y;
        x = y;
        y = rest;
    }
    return x;
}

int main() {
    int a, b;
    cin >> a >> b;
    
    // Apelăm funcția iterativă
    int d = cmmdcIterativ(a, b);
    
    // Calculăm CMMMC
    long long cmmmc = (long long)a * b / d;
    
    cout << cmmmc;
    return 0;
}

Ce învățăm din această problemă:

  • Formula fundamentală: CMMMC = (a × b) / CMMDC
  • Algoritmul iterativ Euclid: Bucla while în loc de recursivitate
  • Management overflow: Folosim long long pentru produsul a×b
  • Cazuri speciale: CMMMC(0, x) = 0
  • Eficiență: O(log min(a,b)) - foarte rapid
  • Relatia dintre CMMDC și CMMMC: Produsul lor este a×b

PbInfo #14 - CMMMC a n numere

Problemă care calculează CMMMC pentru mai multe numere

Enunț:

Cerință: Se citește un număr n, apoi n numere naturale. Să se calculeze CMMMC al celor n numere.

Date de intrare:

Programul citește de la tastatură numărul n, apoi n numere naturale.

Date de ieșire:

Programul va afișa pe ecran CMMMC al celor n numere.

Exemplu:

Intrare:

3
4 6 8

Ieșire:

24

Explicație: Cel mai mic multiplu comun al numerelor 4, 6, 8 est e 24

Cum gândim soluția:
  1. Citim n
  2. Citim primul număr → acesta devine rezultatul curent
  3. Pentru fiecare din următoarele n-1 numere:
    • Calculăm CMMMC între rezultatul curent și numărul curent
    • Actualizăm rezultatul cu CMMMC-ul găsit
  4. Afișăm rezultatul final
Cum funcționează pentru 4, 6, 8:
Pas 1: rezultat = 4
Pas 2: CMMMC(4, 6) = 12 → rezultat = 12 CMMDC(4,6)=2 → 4×6/2=12
Pas 3: CMMMC(12, 8) = 24 → rezultat = 24 CMMDC(12,8)=4 → 12×8/4=24
REZULTAT: 24 ✓ (multi plii: 4→4,8,12,16,20,24... | 6→6,12,18,24... | 8→8,16,24...)
De ce această metodă funcționează?

Folosim proprietatea asociativității CMMMC:

  1. CMMMC(a, b, c) = CMMMC(CMMMC(a, b), c)
  2. CMMMC(a, b, c, d) = CMMMC(CMMMC(a, b, c), d)
  3. Ordinea nu contează: CMMMC este comutativ și asociativ

Formula cheie: rezultat = cmmmc(rezultat, numar) pentru fiecare număr

Scrie soluția în C++:
Soluție corectă (pentru n numere, fără recursivitate):
#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;
    
    long long rezultat;
    cin >> rezultat; // Primul număr este primul candidat pentru rezultat
    
    // Pentru fiecare din următoarele n-1 numere
    for (int i = 1; i < n; i++) {
        int x;
        cin >> x;
        
        // Calculăm CMMDC între rezultatul curent și noul număr x
        long long a = rezultat, b = x; // Copii pentru calcul
        while (b != 0) {
            long long rest = a % b;
            a = b;
            b = rest;
        }
        long long cmmdcCurent = a;
        
        // Actualizăm rezultatul folosind formula CMMMC
        // Calculăm mai întâi CMMMC pentru a evita overflow
        rezultat = (rezultat / cmmdcCurent) * x;
    }
    
    cout << rezultat;
    return 0;
}

Explicație pas cu pas pentru n=3, numerele 4, 6, 8:

  1. Citește n=3.
  2. rezultat = 4 (primul număr).
  3. Bucla 1: Citește x=6.
    • Calculează CMMDC(4,6) = 2 (iterativ: 4%6=4, 6%4=2, 4%2=0).
    • rezultat = (4/2) * 6 = 2 * 6 = 12.
  4. Bucla 2: Citește x=8.
    • Calculează CMMDC(12,8) = 4 (iterativ: 12%8=4, 8%4=0).
    • rezultat = (12/4) * 8 = 3 * 8 = 24.
  5. Afișează 24.

Cheia este: CMMMC(a,b,c) = CMMMC( CMMMC(a,b), c ). Repetăm acest proces pentru fiecare număr nou.

Varianta cu funcții separate:
#include <iostream>
using namespace std;

// Funcție pentru calcularea CMMDC (iterativă)
int cmmdc(int a, int b) {
    while (b != 0) {
        int rest = a % b;
        a = b;
        b = rest;
    }
    return a;
}

// Funcție pentru calcularea CMMMC a două numere
long long cmmmc(int a, int b) {
    if (a == 0 || b == 0) return 0;
    
    // Calculăm CMMDC
    int d = cmmdc(a, b);
    
    // Împărțim mai întâi pentru a reduce riscul de overflow
    return (long long)(a / d) * b;
}

int main() {
    int n;
    cin >> n;
    
    long long rezultat;
    cin >> rezultat;
    
    for (int i = 1; i < n; i++) {
        int x;
        cin >> x;
        rezultat = cmmmc(rezultat, x);
    }
    
    cout << rezultat;
    
    return 0;
}

Ce învățăm din această problemă:

  • Asociativitatea CMMMC: CMMMC(a, b, c) = CMMMC(CMMMC(a, b), c)
  • Algoritm incremental: Pornim cu primul număr și extindem progresiv
  • Cazuri speciale:
  • n=1 → CMMMC = singurul număr
  • Există 0 → CMMMC = 0
  • Numere prime între ele → CMMMC = produsul lor
  • Optimizare overflow: Împărțim mai întâi, apoi înmulțim
  • Eficiență: O(n × log(min)) - foarte rapid
EXERCIȚII PRACTICE - 10 minute

Exercițiul Practic: CMMMC și aplicații

Sarcini de lucru

Completează următoarele sarcini pentru a-ți consolida cunoștințele despre CMMMC

Sarcina 1: Analiză relație CMMDC-CMMMC

Analizează relația dintre CMMDC și CMMMC:

Pentru a=24, b=36, calculează CMMDC, CMMMC și verifică dacă CMMDC×CMMMC = a×b.

Soluție pentru Sarcina 1:

Analiza pentru a=24, b=36:

  • Calcul CMMDC(24,36):
  • Algoritmul lui Euclid: 24%36=24, 36%24=12, 24%12=0
  • CMMDC = 12
  • Calcul CMMMC(24,36):
  • Formula: CMMMC = (a×b) / CMMDC = (24×36) / 12
  • 24×36 = 864
  • 864 / 12 = 72
  • CMMMC = 72
  • Verificare relație:
  • CMMDC × CMMMC = 12 × 72 = 864
  • a × b = 24 × 36 = 864
  • 864 = 864 ✓ RELAȚIA SE VERIFICĂ!
  • Verificare multipli:
  • Multiplii lui 24: 24, 48, 72, 96, 120...
  • Multiplii lui 36: 36, 72, 108, 144...
  • Primul multiplu comun este 72 ✓

Concluzie: Relația CMMDC(a,b) × CMMMC(a,b) = a × b este corectă și extrem de utilă!

Sarcina 2: Implementare în C++ pentru problema întâlnirii

Cerință: Andrei merge la bibliotecă la fiecare A zile, Bogdan la fiecare B zile. În ce zi se vor întâlni pentru prima dată, dacă astăzi este ziua 0?

Soluție pentru Sarcina 2:
#include <iostream>
using namespace std;

int main() {
    int A, B;
    cin >> A >> B;
    
    // Salvăm valorile originale
    int originalA = A, originalB = B;
    
    // Calculăm CMMDC cu algoritmul lui Euclid ITERATIV
    while (B != 0) {
        int rest = A % B;
        A = B;
        B = rest;
    }
    int cmmdc = A;
    
    // Calculăm CMMMC folosind formula
    long long cmmmc = (long long)originalA * originalB / cmmdc;
    
    cout << "Andrei merge la biblioteca la fiecare " << originalA << " zile" << endl;
    cout << "Bogdan merge la biblioteca la fiecare " << originalB << " zile" << endl;
    cout << "Prima zi cand se vor intalni: ziua " << cmmmc << endl;
    
    // Afișăm și următoarele întâlniri
    cout << "Urmatoarele intalniri: ";
    for (int i = 2; i <= 5; i++) {
        cout << "ziua " << cmmmc * i;
        if (i < 5) cout << ", ";
    }
    
    cout << endl;
    return 0;
}

Explicații importante:

  • Interpretarea problemei: Dacă Andrei merge la A zile, el va fi la bibliotecă în zilele: 0, A, 2A, 3A...
  • CMMMC ca soluție: Prima zi comună este CMMMC(A, B)
  • Caz special: Dacă A=1 (merge zilnic) sau B=1, se întâlnesc imediat
  • Următoarele întâlniri: Toți multiplii lui CMMMC
  • Teste recomandate:
  • A=4, B=6 → CMMMC=12 (se întâlnesc în ziua 12, 24, 36...)
  • A=3, B=3 → CMMMC=3 (se întâlnesc în fiecare 3 zile)
  • A=1, B=5 → CMMMC=5 (Bogdan merge la 5 zile, Andrei zilnic)
  • A=0, B=4 → CMMMC=0 (dacă A=0, Andrei nu merge niciodată)

Descarcă toate exercițiile și soluțiile