Exerciții Swift de la ușor la greu, fiecare cu cerința, un indiciu, soluția completă și explicația ei. Înveți de la zero cu Curs Swift (iOS): primele 15 lecții sunt gratuite.
Le rezolvi direct pe pagină, în editorul Swift, exact ca în lecțiile cursului: scrii, apeși Verifică și afli imediat dacă e corect.
Pagină coordonată de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Pe pagina asta exersezi Swift prin 100 de exerciții rezolvate: variabile și tipuri, string-uri, condiții și switch cu pattern-uri, optionals, colecții cu map, filter și reduce, funcții și closures, struct, class și enum, protocoale și generice, erori, plus probleme practice din situații reale, ca un magazin, o bancă sau un catalog școlar. Fiecare exercițiu are un editor în care rulezi codul direct în browser, cu compilatorul Swift real, și o verificare automată a rezultatului.
Exercițiile sunt grupate pe capitole și, în fiecare capitol, merg de la ușor la greu. Citește cerința, încearcă să-l rezolvi singur pornind de la codul din editor și folosește indiciul doar dacă te blochezi. Abia după ce ai o variantă care rulează, uită-te la soluție și la explicație: acolo afli de ce funcționează și ce greșeli apar de obicei.
Harta exercițiilor
Trei insule, de la ușor la greu. Omulețul stă la exercițiul la care ai rămas: apasă pe orice exercițiu deschis ca să-l rezolvi.
Variabile, tipuri și operații
1UșorGratuit Rezolvat
Calculează totalul unui bon de cumpărături
Calculează totalul unui bon cu trei produse, fiecare cu preț unitar și cantitate. Datele sunt scrise direct în cod: pâine 4.50 lei × 2, lapte 7.25 lei × 3, cafea 32.90 lei × 1.
Afișează pe câte o linie subtotalul fiecărui produs și apoi totalul, cu exact două zecimale:
Pâine: 9.00 lei
Lapte: 21.75 lei
Cafea: 32.90 lei
Total: 63.65 lei
Fără import Foundation nu ai String(format:), așa că folosește funcția ajutătoare format2 din cod.
Rezultatul așteptat
Pâine: 9.00 lei
Lapte: 21.75 lei
Cafea: 32.90 lei
Total: 63.65 lei
Indiciu
Înmulțește prețul cu Double(cantitate), pentru că Swift nu amestecă singur Double cu Int.
Soluția
SWIFT
func format2(_ x: Double) -> String {
let c = Int((x * 100).rounded())
let r = abs(c) % 100
return (c < 0 ? "-" : "") + "\(abs(c) / 100)." + (r < 10 ? "0" : "") + "\(r)"
}
let pretPaine = 4.50, cantPaine = 2
let pretLapte = 7.25, cantLapte = 3
let pretCafea = 32.90, cantCafea = 1
let subPaine = pretPaine * Double(cantPaine)
let subLapte = pretLapte * Double(cantLapte)
let subCafea = pretCafea * Double(cantCafea)
let total = subPaine + subLapte + subCafea
print("Pâine: \(format2(subPaine)) lei")
print("Lapte: \(format2(subLapte)) lei")
print("Cafea: \(format2(subCafea)) lei")
print("Total: \(format2(total)) lei")
Explicația
Ideea e simplă, dar exersează două reguli importante din Swift. Prima: tipurile nu se convertesc implicit. pretPaine este Double, cantPaine este Int, iar pretPaine * cantPaine dă eroare de compilare. Conversia o faci tu, explicit, cu Double(cantPaine).
A doua: numerele zecimale afișate direct pot arăta ciudat (de exemplu 0.1 * 3 apare ca 0.30000000000000004). De aceea rotunjim la cenți: format2 înmulțește cu 100, rotunjește cu rounded(), apoi construiește textul cu partea întreagă și două cifre după punct, adăugând un 0 când restul e sub 10.
Folosim let peste tot, pentru că niciuna dintre valori nu se mai schimbă după calcul. Greșeala tipică este să scrii var din obișnuință: programul merge, dar compilatorul te avertizează că variabila nu e modificată niciodată.
Transformă o durată exprimată în minute în ore și minute, folosind împărțirea întreagă și restul. Un film durează 157 de minute, iar o ședință durează 45 de minute.
Pentru fiecare durată afișează o linie de forma:
157 minute = 2 h 37 min
45 minute = 0 h 45 min
Scrie calculul o singură dată, într-o funcție afiseaza(_ minute: Int), și apeleaz-o pentru ambele valori.
Rezultatul așteptat
157 minute = 2 h 37 min
45 minute = 0 h 45 min
Indiciu
Operatorul / între două Int aruncă zecimalele, iar % îți dă exact ce rămâne.
Soluția
SWIFT
func afiseaza(_ minute: Int) {
let ore = minute / 60
let rest = minute % 60
print("\(minute) minute = \(ore) h \(rest) min")
}
afiseaza(157)
afiseaza(45)
Explicația
Când împarți două numere Int în Swift, rezultatul este tot Int, iar partea zecimală se taie: 157 / 60 dă 2. Operatorul % (restul împărțirii) dă ce a rămas: 157 % 60 dă 37, adică minutele care nu au format o oră întreagă.
Am pus calculul într-o funcție cu parametrul fără etichetă (_ minute), ca apelul să se citească natural: afiseaza(157). Dacă scriai func afiseaza(minute: Int), apelul ar fi trebuit să fie afiseaza(minute: 157).
Greșeala tipică este să folosești Double aici: 157.0 / 60 dă 2.6166..., iar transformarea acelei zecimale în minute e complicată și predispusă la erori de rotunjire. Pentru unități care se împart exact (minute, secunde, bani), rămâi la numere întregi.
3UșorGratuit Rezolvat
Convertește temperatura din Celsius în Fahrenheit
Convertește o listă de temperaturi din grade Celsius în grade Fahrenheit cu formula F = C × 9 / 5 + 32. Temperaturile sunt -10, 0, 21.5 și 37.
Pentru fiecare valoare afișează o linie, cu ambele temperaturi la o zecimală:
-10.0 °C = 14.0 °F
0.0 °C = 32.0 °F
21.5 °C = 70.7 °F
37.0 °C = 98.6 °F
Scrie o funcție inFahrenheit(_ c: Double) -> Double și o funcție format1 care rotunjește la o zecimală.
Rezultatul așteptat
-10.0 °C = 14.0 °F
0.0 °C = 32.0 °F
21.5 °C = 70.7 °F
37.0 °C = 98.6 °F
Indiciu
Rotunjește înmulțind cu 10, aplicând rounded() și construind textul din partea întreagă și ultima cifră.
Soluția
SWIFT
func inFahrenheit(_ c: Double) -> Double {
return c * 9 / 5 + 32
}
func format1(_ x: Double) -> String {
let z = Int((x * 10).rounded())
let semn = z < 0 ? "-" : ""
return semn + "\(abs(z) / 10).\(abs(z) % 10)"
}
let temperaturi: [Double] = [-10, 0, 21.5, 37]
for c in temperaturi {
print("\(format1(c)) °C = \(format1(inFahrenheit(c))) °F")
}
Explicația
Formula se scrie direct în Swift: c * 9 / 5 + 32. Pentru că c este Double, literalele 9, 5 și 32 sunt tratate tot ca Double, deci împărțirea nu mai taie zecimalele. Dacă c ar fi fost Int, 21 * 9 / 5 ar fi dat 37, nu 37.8.
Afișarea e partea delicată. print(21.5 * 9 / 5 + 32) poate afișa 70.7 sau ceva de genul 70.69999999999999, în funcție de calcul. Funcția format1 lucrează cu zecimi întregi: 70.7 * 10 rotunjit dă 707, iar 707 / 10 și 707 % 10 dau 70 și 7.
Semnul îl tratăm separat, cu abs, pentru că -100 % 10 și -100 / 10 ar da rezultate cu minus în ambele părți. Am declarat tabloul ca [Double], altfel -10 și 0 ar fi fost deduse ca Int.
Calculează media a patru note ale unui elev și verifică dacă a promovat. Notele sunt 7, 9, 4 și 8. Un elev promovează dacă media este cel puțin 5 și nu are nicio notă sub 4.
Afișează media cu două zecimale și rezultatul ca valoare Bool:
Media: 7.00
Promovat: true
Folosește operatorii de comparație și operatorul logic &&. Notele sunt Int, dar media trebuie calculată cu zecimale.
Rezultatul așteptat
Media: 7.00
Promovat: true
Indiciu
Convertește suma la Double înainte să împarți, altfel 28 / 4 se calculează între întregi.
Soluția
SWIFT
func format2(_ x: Double) -> String {
let c = Int((x * 100).rounded())
let r = abs(c) % 100
return (c < 0 ? "-" : "") + "\(abs(c) / 100)." + (r < 10 ? "0" : "") + "\(r)"
}
let n1 = 7, n2 = 9, n3 = 4, n4 = 8
let media = Double(n1 + n2 + n3 + n4) / 4
let faraNoteMici = n1 >= 4 && n2 >= 4 && n3 >= 4 && n4 >= 4
let promovat = media >= 5 && faraNoteMici
print("Media: \(format2(media))")
print("Promovat: \(promovat)")
Explicația
Suma notelor este un Int (28). Dacă scrii (n1 + n2 + n3 + n4) / 4, rezultatul e tot Int, iar pentru note ca 7, 8, 8, 8 media 7.75 ar deveni 7. De aceea convertim suma cu Double(...) înainte de împărțire.
Condiția de promovare are două părți, legate cu &&: media cel puțin 5 și nicio notă sub 4. Am pus a doua parte într-o constantă separată, faraNoteMici, ca expresia finală să fie ușor de citit. Rezultatul unei comparații este un Bool, iar interpolarea îl afișează ca true sau false.
Observă că nota 4 este la limită: condiția este >= 4, deci 4 e acceptată. O greșeală frecventă este să scrii > 4, ceea ce ar schimba rezultatul. Citește întotdeauna cu atenție dacă limita intră sau nu în interval.
Calculează câte cutii sunt necesare pentru o comandă
Calculează câte cutii sunt necesare pentru a ambala o comandă, știind că o cutie încape un număr fix de produse. Ultima cutie poate fi incompletă, dar se folosește oricum.
Comenzile sunt: 23 de cani cu 6 pe cutie, 40 de pahare cu 8 pe cutie și 5 farfurii cu 12 pe cutie. Pentru fiecare comandă afișează:
23 produse, 6 pe cutie: 4 cutii, ultima cu 5
Dacă ultima cutie e plină, afișează ultima plină, iar pentru o singură cutie scrie 1 cutie. Rezolvă doar cu operații pe numere întregi, fără Double.
Rezultatul așteptat
23 produse, 6 pe cutie: 4 cutii, ultima cu 5
40 produse, 8 pe cutie: 5 cutii, ultima plină
5 produse, 12 pe cutie: 1 cutie, ultima cu 5
Indiciu
Rotunjirea în sus a lui a / b se poate scrie ca (a + b - 1) / b.
Soluția
SWIFT
func cutii(_ produse: Int, _ pePachet: Int) {
let nr = (produse + pePachet - 1) / pePachet
let rest = produse % pePachet
let ultima = rest == 0 ? "ultima plină" : "ultima cu \(rest)"
let textCutii = nr == 1 ? "1 cutie" : "\(nr) cutii"
print("\(produse) produse, \(pePachet) pe cutie: \(textCutii), \(ultima)")
}
cutii(23, 6)
cutii(40, 8)
cutii(5, 12)
Explicația
Împărțirea întreagă 23 / 6 dă 3, dar ai nevoie de 4 cutii, pentru că mai rămân 5 cani. Trucul clasic de rotunjire în sus fără zecimale este (a + b - 1) / b: adăugăm „aproape o cutie” înainte de împărțire. Pentru 40 și 8 obținem 47 / 8 = 5, exact cât trebuie, iar pentru 5 și 12 obținem 16 / 12 = 1.
Restul produse % pePachet spune câte produse sunt în ultima cutie. Când restul e 0, cutia e plină, iar operatorul ternar ?: alege textul potrivit într-o singură linie.
Am evitat Double intenționat: varianta cu (Double(a) / Double(b)).rounded(.up) funcționează, dar implică conversii inutile și, pentru numere mari, posibile erori de precizie. Greșeala tipică este a / b + 1, care dă o cutie în plus atunci când împărțirea este exactă (40 / 8 + 1 = 6).
6Ușor Blocat Rezolvat
Afișează o durată în secunde în format ore:minute:secunde
Afișează o durată dată în secunde în formatul HH:MM:SS, cu câte două cifre pentru fiecare parte.
Comprimă un șir de caractere înlocuind fiecare secvență de caractere identice consecutive cu caracterul urmat de numărul de repetări (codare run-length).
Găsește primul angajat disponibil dintr-un departament
Găsește primul angajat disponibil dintr-un departament dat, folosind first(where:) și firstIndex(where:), și tratează cazul în care nu există niciunul.
Elimină duplicatele dintr-o listă păstrând ordinea
Elimină emailurile duplicate dintr-o listă de abonați la newsletter, păstrând ordinea primei apariții și ignorând diferența dintre litere mari și mici.
Găsește două produse care însumează exact un buget
Găsește două produse diferite dintr-o listă de prețuri a căror sumă este exact egală cu un buget dat, într-o singură parcurgere a listei (problema „two sum”).
Aplică o scumpire la prețuri cu un parametru inout
Scrie o funcție care aplică o scumpire procentuală direct pe tabloul de prețuri primit, folosind un parametru inout, și întoarce câte prețuri au depășit un prag după scumpire.
Sortează produse după mai multe criterii cu closures
Sortează o listă de produse în trei moduri diferite, transmițând de fiecare dată alt closure funcției sorted(by:), și scrie o funcție proprie care primește criteriul ca parametru.
Aplică reduceri succesive cu funcții transmise ca parametri
Modelează regulile de reducere ale unui magazin ca funcții de tipul (Int) -> Int (primesc un total în lei și întorc totalul nou) și aplică-le pe rând unui coș.
Construiește un lanț de validări dintr-un tablou de closures
Construiește un sistem de validare pentru numele de utilizator în care fiecare regulă este un closure cu un mesaj asociat, iar regulile se pot combina în liste diferite.
Creează un enum pentru zilele săptămânii cu rawValue
Creează un enum Zi pentru zilele săptămânii, cu valori brute (rawValue) de tip Int de la 1 (luni) la 7 (duminică), și o proprietate calculată care spune dacă ziua este din weekend.
Folosește observatorii de proprietate willSet și didSet pentru a urmări automat modificările stocului unui produs și pentru a genera alerte când stocul scade sub un prag.
Gestionează stările unei comenzi cu un enum și tranziții
Modelează ciclul de viață al unei comenzi cu un enum Stare (plasată, plătită, expediată, livrată, anulată) și o metodă care permite doar tranzițiile valide.
Gestionează rezervările camerelor unui hotel cu subscript
Modelează un hotel ca o clasă care ține rezervările pe camere și nopți, cu un subscript care permite citirea ocupantului cu sintaxa hotel[camera, noapte].
Sortează produse implementând protocolul Comparable
Fă o structură Versiune (major, minor, patch) să respecte protocolul Comparable, astfel încât versiunile de aplicație să poată fi comparate cu < și sortate cu sorted().
Elimină contactele duplicate cu Equatable și Hashable
Elimină contactele duplicate dintr-o agendă, unde două contacte sunt considerate identice dacă au același număr de telefon, chiar dacă numele e scris diferit.
Oferă o implementare implicită printr-o extensie de protocol
Definește un protocol Notificare cu proprietățile titlu și canal, și oferă printr-o extensie de protocol o metodă implicită trimite() -> String și o prioritate implicită.
Verifică parantezele dintr-o expresie cu o stivă generică
Implementează o stivă generică Stiva<Element> (LIFO) cu metodele push, pop și proprietatea top, apoi folosește-o pentru a verifica dacă parantezele dintr-o expresie sunt corect închise.
Fă o structură iterabilă cu Sequence și IteratorProtocol
Creează o structură Rate care reprezintă graficul de plată al unui împrumut fără dobândă (suma împărțită în rate lunare egale, cu restul pus pe ultima rată) și fă-o să respecte Sequence, ca să poată fi parcursă cu for-in și folosită cu map, filter sau reduce.
Ignoră înregistrările invalide dintr-un import cu try?
Importă o listă de produse din linii de text de forma „nume;preț;stoc” și folosește try? pentru a sări peste liniile invalide, păstrându-le numărul pentru un raport.
Scrie o funcție de autentificare care întoarce Result<Utilizator, EroareLogin> în loc să arunce erori, apoi tratează rezultatul cu switch și cu metodele lui Result.
Certificat de formator autorizatMinisterul Muncii și Ministerul Educației · 2022
Din 2020 construiește Academia Programatorilor, iar din 2026 și JoburiIT.ro. Exercițiile de aici sunt gândite ca la job: date concrete, cerințe clare și soluții pe care le poți explica la un interviu de Swift.
Învață Swift de la zero, cu exerciții la fiecare lecție
Curs Swift (iOS): lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.