Rezumat problemă

ZeroF

C++

#1826

Să se scrie o funcție C++ care să returneze pentru un număr natural n transmis ca parametru numărul de cifre zero de la finalul lui n! = 1•2•...•n.

Consola Candale Silviu (silviu) ușoară

Clasa 10 Subprograme Subprograme care returnează valori Factorialul unui numar

Rezolvă

Detalii

Problema	ZeroF	Operații I/O	tastatură/ecran
Limita timp	0.1 secunde	Limita memorie	Total: 64 MB / Stivă 8 MB
Id soluție	#64931187	Utilizator	Sarac Razvan (RazvanSarac)
Fișier	zerof.cpp	Dimensiune	1.35 KB
Data încărcării	15 Iunie 2026, 21:50	Scor/rezultat	Eroare de compilare

Evaluare

Mesaj compilare

zerof.cpp:4:10: error: stray ‘#’ in program
    4 | Problema #1826 - ZeroF de pe PBInfo îți cere să scrii o funcție C++ numită zerof care să returneze numărul de zerouri de la sfârșitul lui $n!$ ($n$ factorial, adică $1 \cdot 2 \cdot 3 \cdot \dots \cdot n$).Logica din spate (Legendrea)Un zero la finalul unui număr apare de la înmulțirea lui $2$ cu $5$ ($2 \cdot 5 = 10$).În produsul $n!$, numărul de factori de $2$ este întotdeauna mult mai mare decât numărul de factori de $5$. Prin urmare, numărul de zerouri de la final este dat strict de numărul de ori în care numărul $5$ apare în descompunerea în factori primi a lui $n!$.Pentru a afla acest lucru eficient, folosim Formula lui Legendre:Împărțim succesiv $n$ la puterile lui 5 ($5, 25, 125, \dots$) și adunăm câturile până când $n$ devine mai mic decât puterea respectivă.De exemplu, pentru $n = 25$:$25 / 5 = 5$ (sunt 5 numere multipli de 5: 5, 10, 15, 20, 25)$25 / 25 = 1$ (numărul 25 mai aduce un factor de 5 în plus)Total zerouri = $5 + 1 = 6$.Codul C++ (Funcția solicitată)Iată implementarea completă și curată a funcției. Tu trebuie să trimiți pe site doar această funcție (fără main).C++int zerof(int n) {
      |          ^
zerof.cpp:4:169: error: stray ‘\’ in program
    4 | Problema #1826 - ZeroF de pe PBInfo îți cere să scrii o funcție C++ numită zerof care să returneze numărul de zerouri de la sfârșitul lui $n!$ ($n$ factorial, adică $1 \cdot 2 \cdot 3 \cdot \dots \cdot n$).Logica din spate (Legendrea)Un zero la finalul unui număr apare de la înmulțirea lui $2$ cu $5$ ($2 \cdot 5 = 10$).În produsul $n!$, numărul de factori de $2$ este întotdeauna mult mai mare decât numărul de factori de $5$. Prin urmare, numărul de zerouri de la final este dat strict de numărul de ori în care numărul $5$ apare în descompunerea în factori primi a lui $n!$.Pentru a afla acest lucru eficient, folosim Formula lui Legendre:Împărțim succesiv $n$ la puterile lui 5 ($5, 25, 125, \dots$) și adunăm câturile până când $n$ devine mai mic decât puterea respectivă.De exemplu, pentru $n = 25$:$25 / 5 = 5$ (sunt 5 numere multipli de 5: 5, 10, 15, 20, 25)$25 / 25 = 1$ (numărul 25 mai aduce un factor de 5 în plus)Total zerouri = $5 + 1 = 6$.Codul C++ (Funcția solicitată)Iată implementarea completă și curată a funcției. Tu trebuie să trimiți pe site doar această funcție (fără main).C++int zerof(int n) {
      |                                                                                                                                                                         ^
zerof.cpp:4:177: error: stray ‘\’ in program
    4 | Problema #1826 - ZeroF de pe PBInfo îți cere să scrii o funcție C++ numită zerof care să returneze numărul de zerouri de la sfârșitul lui $n!$ ($n$ factorial, adică $1 \cdot 2 \cdot 3 \cdot \dots \cdot n$).Logica din spate (Legendrea)Un zero la finalul unui număr apare de la înmulțirea lui $2$ cu $5$ ($2 \cdot 5 = 10$).În produsul $n!$, numărul de factori de $2$ este întotdeauna mult mai mare decât numărul de factori de $5$. Prin urmare, numărul de zerouri de la final este dat strict de numărul de ori în care numărul $5$ apare în descompunerea în factori primi a lui $n!$.Pentru a afla acest lucru eficient, folosim Formula lui Legendre:Împărțim succesiv $n$ la puterile lui 5 ($5, 25, 125, \dots$) și adunăm câturile până când $n$ devine mai mic decât puterea respectivă.De exemplu, pentru $n = 25$:$25 / 5 = 5$ (sunt 5 numere multipli de 5: 5, 10, 15, 20, 25)$25 / 25 = 1$ (numărul 25 mai aduce un factor de 5 în plus)Total zerouri = $5 + 1 = 6$.Codul C++ (Funcția solicitată)Iată implementarea completă și curată a funcției. Tu trebuie să trimiți pe site doar această funcție (fără main).C++int zerof(int n) {
      |                                                                                                                                                                                 ^
zerof.cpp:4:185: error: stray ‘\’ in program
    4 | Problema #1826 - ZeroF de pe PBInfo îți cere să scrii o funcție C++ numită zerof care să returneze numărul de zerouri de la sfârșitul lui $n!$ ($n$ factorial, adică $1 \cdot 2 \cdot 3 \cdot \dots \cdot n$).Logica din spate (Legendrea)Un zero la finalul unui număr apare de la înmulțirea lui $2$ cu $5$ ($2 \cdot 5 = 10$).În produsul $n!$, numărul de factori de $2$ este întotdeauna mult mai mare decât numărul de factori de $5$. Prin urmare, numărul de zerouri de la final este dat strict de numărul de ori în care numărul $5$ apare în descompunerea în factori primi a lui $n!$.Pentru a afla acest lucru eficient, folosim Formula lui Legendre:Împărțim succesiv $n$ la puterile lui 5 ($5, 25, 125, \dots$) și adunăm câturile până când $n$ devine mai mic decât puterea respectivă.De exemplu, pentru $n = 25$:$25 / 5 = 5$ (sunt 5 numere multipli de 5: 5, 10, 15, 20, 25)$25 / 25 = 1$ (numărul 25 mai aduce un factor de 5 în plus)Total zerouri = $5 + 1 = 6$.Codul C++ (Funcția solicitată)Iată implementarea completă și curată a funcției. Tu trebuie să trimiți pe site doar această funcție (fără main).C++int zerof(int n) {
      |                                                                                                                                                                                         ^
zerof.cpp:4:191: error: stray ‘\’ in program
    4 | Problema #1826 - ZeroF de pe PBInfo îți cere să scrii o funcție C++ numită zerof care să returneze numărul de zerouri de la sfârșitul lui $n!$ ($n$ factorial, adică $1 \cdot 2 \cdot 3 \cdot \dots \cdot n$).Logica din spate (Legendrea)Un zero la finalul unui număr apare de la înmulțirea lui $2$ cu $5$ ($2 \cdot 5 = 10$).În produsul $n!$, numărul de factori de $2$ este întotdeauna mult mai mare decât numărul de factori de $5$. Prin urmare, numărul de zerouri de la final este dat strict de numărul de ori în care numărul $5$ apare în descompunerea în factori primi a lui $n!$.Pentru a afla acest lucru eficient, folosim Formula lui Legendre:Împărțim succesiv $n$ la puterile lui 5 ($5, 25, 125, \dots$) și adunăm câturile până când $n$ devine mai mic decât puterea respectivă.De exemplu, pentru $n = 25$:$25 / 5 = 5$ (sunt 5 numere multipli de 5: 5, 10, 15, 20, 25)$25 / 25 = 1$ (numărul 25 mai aduce un factor de 5 în plus)Total zerouri = $5 + 1 = 6$.Codul C++ (Funcția solicitată)Iată implementarea completă și curată a funcției. Tu trebuie să trimiți pe site doar această funcție (fără main).C++int zerof(int n) {
      |                                                                                                                                                                                               ^
zerof.cpp:4:197: error: stray ‘\’ in program
    4 | Problema #1826 - ZeroF de pe PBInfo îți cere să scrii o funcție C++ numită zerof care să returneze numărul de zerouri de la sfârșitul lui $n!$ ($n$ factorial, adică $1 \cdot 2 \cdot 3 \cdot \dots \cdot n$).Logica din spate (Legendrea)Un zero la finalul unui număr apare de la înmulțirea lui $2$ cu $5$ ($2 \cdot 5 = 10$).În produsul $n!$, numărul de factori de $2$ este întotdeauna mult mai mare decât numărul de factori de $5$. Prin urmare, numărul de zerouri de la final este dat strict de numărul de ori în care numărul $5$ apare în descompunerea în factori primi a lui $n!$.Pentru a afla acest lucru eficient, folosim Formula lui Legendre:Împărțim succesiv $n$ la puterile lui 5 ($5, 25, 125, \dots$) și adunăm câturile până când $n$ devine mai mic decât puterea respectivă.De exemplu, pentru $n = 25$:$25 / 5 = 5$ (sunt 5 numere multipli de 5: 5, 10, 15, 20, 25)$25 / 25 = 1$ (numărul 25 mai aduce un factor de 5 în plus)Total zerouri = $5 + 1 = 6$.Codul C++ (Funcția solicitată)Iată implementarea completă și curată a funcției. Tu trebuie să trimiți pe site doar această funcție (fără main).C++int zerof(int n) {
      |                                                                                                                                                                                                     ^
zerof.cpp:4:307: error: stray ‘\’ in program
    4 | Problema #1826 - ZeroF de pe PBInfo îți cere să scrii o funcție C++ numită zerof care să returneze numărul de zerouri de la sfârșitul lui $n!$ ($n$ factorial, adică $1 \cdot 2 \cdot 3 \cdot \dots \cdot n$).Logica din spate (Legendrea)Un zero la finalul unui număr apare de la înmulțirea lui $2$ cu $5$ ($2 \cdot 5 = 10$).În produsul $n!$, numărul de factori de $2$ este întotdeauna mult mai mare decât numărul de factori de $5$. Prin urmare, numărul de zerouri de la final este dat strict de numărul de ori în care numărul $5$ apare în descompunerea în factori primi a lui $n!$.Pentru a afla acest lucru eficient, folosim Formula lui Legendre:Împărțim succesiv $n$ la puterile lui 5 ($5, 25, 125, \dots$) și adunăm câturile până când $n$ devine mai mic decât puterea respectivă.De exemplu, pentru $n = 25$:$25 / 5 = 5$ (sunt 5 numere multipli de 5: 5, 10, 15, 20, 25)$25 / 25 = 1$ (numărul 25 mai aduce un factor de 5 în plus)Total zerouri = $5 + 1 = 6$.Codul C++ (Funcția solicitată)Iată implementarea completă și curată a funcției. Tu trebuie să trimiți pe site doar această funcție (fără main).C++int zerof(int n) {
      |                                                                                                                                                                                                                                                                                                                   ^
zerof.cpp:4:698: error: stray ‘\’ in program
    4 | Problema #1826 - ZeroF de pe PBInfo îți cere să scrii o funcție C++ numită zerof care să returneze numărul de zerouri de la sfârșitul lui $n!$ ($n$ factorial, adică $1 \cdot 2 \cdot 3 \cdot \dots \cdot n$).Logica din spate (Legendrea)Un zero la finalul unui număr apare de la înmulțirea lui $2$ cu $5$ ($2 \cdot 5 = 10$).În produsul $n!$, numărul de factori de $2$ este întotdeauna mult mai mare decât numărul de factori de $5$. Prin urmare, numărul de zerouri de la final este dat strict de numărul de ori în care numărul $5$ apare în descompunerea în factori primi a lui $n!$.Pentru a afla acest lucru eficient, folosim Formula lui Legendre:Împărțim succesiv $n$ la puterile lui 5 ($5, 25, 125, \dots$) și adunăm câturile până când $n$ devine mai mic decât puterea respectivă.De exemplu, pentru $n = 25$:$25 / 5 = 5$ (sunt 5 numere multipli de 5: 5, 10, 15, 20, 25)$25 / 25 = 1$ (numărul 25 mai aduce un factor de 5 în plus)Total zerouri = $5 + 1 = 6$.Codul C++ (Funcția solicitată)Iată implementarea completă și curată a funcției. Tu trebuie să trimiți pe site doar această funcție (fără main).C++int zerof(int n) {
      |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ^
zerof.cpp:4:1: error: ‘Problema’ does not name a type
    4 | Problema #1826 - ZeroF de pe PBInfo îți cere să scrii o funcție C++ numită zerof care să returneze numărul de zerouri de la sfârșitul lui $n!$ ($n$ factorial, adică $1 \cdot 2 \cdot 3 \cdot \dots \cdot n$).Logica din spate (Legendrea)Un zero la finalul unui număr apare de la înmulțirea lui $2$ cu $5$ ($2 \cdot 5 = 10$).În produsul $n!$, numărul de factori de $2$ este întotdeauna mult mai mare decât numărul de factori de $5$. Prin urmare, numărul de zerouri de la final este dat strict de numărul de ori în care numărul $5$ apare în descompunerea în factori primi a lui $n!$.Pentru a afla acest lucru eficient, folosim Formula lui Legendre:Împărțim succesiv $n$ la puterile lui 5 ($5, 25, 125, \dots$) și adunăm câturile până când $n$ devine mai mic decât puterea respectivă.De exemplu, pentru $n = 25$:$25 / 5 = 5$ (sunt 5 numere multipli de 5: 5, 10, 15, 20, 25)$25 / 25 = 1$ (numărul 25 mai aduce un factor de 5 în plus)Total zerouri = $5 + 1 = 6$.Codul C++ (Funcția solicitată)Iată implementarea completă și curată a funcției. Tu trebuie să trimiți pe site doar această funcție (fără main).C++int zerof(int n) {
      | ^~~~~~~~
zerof.cpp: In function ‘int main()’:
zerof.cpp:19:25: error: ‘zerof’ was not declared in this scope
   19 |                 cout << zerof(x) << endl;
      |                         ^~~~~

Cum funcționează evaluarea?