Tabla y gráfico de variable cualitativa Ordinal

Espejo Agüero, Elar Jammir

Variable: Nivel de satisfacción con los productos recibidos

Etiquetas de fila Cuenta de Nivel de satisfacción con los productos recibidos

Muy insatisfecho 4
Muy satisfecho 28
Neutral 28
Satisfecho 120
Total general 180

Nota: Se editó la tabla dinámica, visto que las personas encuestadas no

seleccionaron la opción de “Insatisfecho”
Etiquetas de fila Cuenta de Nivel de satisfacción con los productos recibidos
Muy satisfecho 28
Satisfecho 120
Neutral 28
Insatisfecho 0
Muy insatisfecho 4
Total general 180
<𝑎𝑙𝑔𝑜𝑟𝑖𝑡ℎ𝑚>#𝑖𝑛𝑐𝑙𝑢𝑑𝑒 <𝑓𝑠𝑡𝑟𝑒𝑎𝑚> // 𝑃𝑎𝑟𝑎 𝑚𝑎𝑛𝑒𝑗𝑜 𝑑𝑒 𝑎𝑟𝑐ℎ𝑖𝑣𝑜𝑠#𝑖𝑛𝑐𝑙𝑢𝑑𝑒 <𝑞𝑢𝑒𝑢𝑒> // 𝑃𝑎𝑟𝑎 𝑐𝑜𝑙𝑎𝑠#𝑖𝑛𝑐𝑙𝑢𝑑𝑒 <𝑠𝑡𝑎𝑐𝑘> // 𝑃𝑎𝑟𝑎 𝑝𝑖𝑙
𝑐𝑖𝑜𝑠𝑏𝑜𝑜𝑙 𝑒𝑠𝑆𝑜𝑙𝑜𝐿𝑒𝑡𝑟𝑎𝑠𝑌𝐸𝑠𝑝𝑎𝑐𝑖𝑜𝑠(𝑐𝑜𝑛𝑠𝑡 𝑠𝑡𝑟𝑖𝑛𝑔& 𝑠𝑡𝑟, 𝑖𝑛𝑡 𝑖𝑛𝑑𝑒𝑥 = 0) { 𝑖𝑓 (𝑖𝑛𝑑𝑒𝑥 == 𝑠𝑡𝑟.𝑙𝑒𝑛𝑔𝑡ℎ()) 𝑟𝑒𝑡𝑢𝑟𝑛 𝑡𝑟𝑢𝑒; 𝑖𝑓 (!𝑖𝑠𝑎𝑙𝑝ℎ𝑎(𝑠𝑡𝑟[
𝑠𝑡𝑟𝑎𝑟 𝑒𝑙 𝑚𝑒𝑛𝑢 𝑑𝑒𝑙 𝑚𝑒𝑑𝑖𝑐𝑜𝑒𝑥𝑡𝑒𝑟𝑛 𝑣𝑜𝑖𝑑 𝑚𝑎𝑛𝑒𝑗𝑎𝑟𝑀𝑒𝑛𝑢𝑀𝑒𝑑𝑖𝑐𝑜(𝑣𝑒𝑐𝑡𝑜𝑟<𝑅𝑒𝑐𝑒𝑡𝑎>& 𝑟𝑒𝑐𝑒𝑡𝑎𝑠);// 𝐹𝑢𝑛𝑐𝑖𝑜𝑛 𝑝𝑎𝑟𝑎 𝑚𝑎𝑛𝑒𝑗𝑎𝑟 𝑙𝑎 𝑎𝑠𝑖𝑔𝑛𝑎𝑐𝑖𝑜
𝑜𝑚𝑏𝑟𝑒 𝑖𝑛𝑐𝑜𝑟𝑟𝑒𝑐𝑡𝑜. 𝑆𝑜𝑙𝑜 𝑠𝑒 𝑝𝑒𝑟𝑚𝑖𝑡𝑒𝑛 𝑙𝑒𝑡𝑟𝑎𝑠 𝑦 𝑒𝑠𝑝𝑎𝑐𝑖𝑜𝑠. 𝑉𝑢𝑒𝑙𝑣𝑎 𝑎 𝑖𝑛𝑔𝑟𝑒𝑠𝑎𝑟." << 𝑒𝑛𝑑𝑙; } } 𝑤ℎ𝑖𝑙𝑒 (!𝑒𝑛𝑡𝑟𝑎𝑑𝑎𝑉𝑎𝑙𝑖𝑑𝑎); // 𝑉𝑎𝑙𝑖𝑑𝑎𝑟
𝑒𝑛𝑡𝑟𝑎𝑑𝑎𝑉𝑎𝑙𝑖𝑑𝑎 = 𝑒𝑠𝑆𝑜𝑙𝑜𝐿𝑒𝑡𝑟𝑎𝑠𝑁𝑢𝑚𝑒𝑟𝑜𝑠𝑌𝐸𝑠𝑝𝑎𝑐𝑖𝑜𝑠(𝑛𝑢𝑒𝑣𝑎𝑅𝑒𝑐𝑒𝑡𝑎.𝑑𝑜𝑠𝑖𝑠); 𝑖𝑓 (!𝑒𝑛𝑡𝑟𝑎𝑑𝑎𝑉𝑎𝑙𝑖𝑑𝑎) { 𝑐𝑜𝑢𝑡 << "𝐷𝑜𝑠𝑖𝑠 𝑖𝑛𝑐𝑜𝑟
𝑎 𝑎 𝑖𝑛𝑔𝑟𝑒𝑠𝑎𝑟." << 𝑒𝑛𝑑𝑙; 𝑒𝑛𝑡𝑟𝑎𝑑𝑎𝑉𝑎𝑙𝑖𝑑𝑎 = 𝑓𝑎𝑙𝑠𝑒; } 𝑒𝑙𝑠𝑒 { 𝑒𝑛𝑡𝑟𝑎𝑑𝑎𝑉𝑎𝑙𝑖𝑑𝑎 = 𝑡𝑟𝑢𝑒; 𝑐𝑖𝑛.𝑖𝑔𝑛𝑜𝑟𝑒(); // 𝐿𝑖𝑚𝑝𝑖𝑎𝑟 𝑒𝑙 𝑏𝑢
< 𝑒𝑛𝑑𝑙; 𝑒𝑛𝑡𝑟𝑎𝑑𝑎𝑉𝑎𝑙𝑖𝑑𝑎 = 𝑓𝑎𝑙𝑠𝑒; } 𝑒𝑙𝑠𝑒 { 𝑒𝑛𝑡𝑟𝑎𝑑𝑎𝑉𝑎𝑙𝑖𝑑𝑎 = 𝑡𝑟𝑢𝑒; 𝑐𝑖𝑛.𝑖𝑔𝑛𝑜𝑟𝑒(); // 𝐿𝑖𝑚𝑝𝑖𝑎𝑟 𝑒𝑙 𝑏𝑢𝑓𝑓𝑒𝑟 𝑑𝑒 𝑒𝑛𝑡𝑟𝑎𝑑𝑎
𝑑𝑖𝑟𝑒𝑐𝑐𝑖𝑜𝑛; 𝑠𝑡𝑟𝑖𝑛𝑔 𝑐𝑒𝑙𝑢𝑙𝑎𝑟; 𝑠𝑡𝑟𝑖𝑛𝑔 𝑐𝑜𝑟𝑟𝑒𝑜; // 𝐷𝑎𝑡𝑜𝑠 𝑀𝑒𝑑𝑖𝑐𝑜𝑠 𝑓𝑙𝑜𝑎𝑡 𝑝𝑒𝑠𝑜; 𝑓𝑙𝑜𝑎𝑡 𝑡𝑎𝑙𝑙𝑎; 𝑓𝑙𝑜𝑎𝑡 𝑡𝑒𝑚𝑝𝑒𝑟𝑎𝑡𝑢𝑟𝑎; 𝑓𝑙𝑜𝑎𝑡 𝑝𝑟𝑒𝑠𝑖𝑜𝑛;
𝑟𝑠𝑖𝑣𝑎 𝑝𝑎𝑟𝑎 𝑣𝑎𝑙𝑖𝑑𝑎𝑟 𝑠𝑖 𝑢𝑛 𝑛𝑢𝑚𝑒𝑟𝑜 𝑑𝑒 𝑡𝑒𝑙𝑒𝑓𝑜𝑛𝑜 𝑒𝑠 𝑣𝑎𝑙𝑖𝑑𝑜𝑏𝑜𝑜𝑙 𝑒𝑠𝐶𝑒𝑙𝑢𝑙𝑎𝑟𝑉𝑎𝑙𝑖𝑑𝑜(𝑐𝑜𝑛𝑠𝑡 𝑠𝑡𝑟𝑖𝑛𝑔& 𝑐𝑒𝑙𝑢𝑙𝑎𝑟, 𝑖𝑛𝑡 𝑖𝑛𝑑𝑒𝑥 = 0) { // 𝑆𝑒 𝑎𝑠𝑢𝑚
ℎ𝑎(𝑛𝑜𝑚𝑏𝑟𝑒[𝑖𝑛𝑑𝑒𝑥]) && 𝑛𝑜𝑚𝑏𝑟𝑒[𝑖𝑛𝑑𝑒𝑥] != ′ ′) 𝑟𝑒𝑡𝑢𝑟𝑛 𝑓𝑎𝑙𝑠𝑒; 𝑟𝑒𝑡𝑢𝑟𝑛 𝑒𝑠𝑁𝑜𝑚𝑏𝑟𝑒𝑉𝑎𝑙𝑖𝑑𝑜(𝑛𝑜𝑚𝑏𝑟𝑒, 𝑖𝑛𝑑𝑒𝑥 + 1);}// 𝐹𝑢𝑛𝑐𝑖𝑜𝑛 𝑝𝑎𝑟𝑎 𝑣𝑎𝑙𝑖
𝑛𝑐𝑖𝑜𝑛 𝑝𝑎𝑟𝑎 𝑟𝑒𝑔𝑖𝑠𝑡𝑟𝑎𝑟 𝑑𝑎𝑡𝑜𝑠 𝑑𝑒𝑙 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒 𝑐𝑜𝑛 𝑣𝑎𝑙𝑖𝑑𝑎𝑐𝑖𝑜𝑛𝑒𝑠𝑣𝑜𝑖𝑑 𝑟𝑒𝑔𝑖𝑠𝑡𝑟𝑎𝑟𝐷𝑎𝑡𝑜𝑠𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒(𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒& 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒) { 𝑐𝑜𝑢𝑡 << "𝑅𝑒𝑔𝑖𝑠
𝑒𝑉𝑎𝑙𝑖𝑑𝑜(𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑎𝑝𝑒𝑙𝑙𝑖𝑑𝑜)) { 𝑐𝑜𝑢𝑡 << "𝐴𝑝𝑒𝑙𝑙𝑖𝑑𝑜 𝑛𝑜 𝑣𝑎𝑙𝑖𝑑𝑜. 𝐼𝑛𝑔𝑟𝑒𝑠𝑒 𝑠𝑜𝑙𝑜 𝑐𝑎𝑟𝑎𝑐𝑡𝑒𝑟𝑒𝑠 𝑎𝑙𝑓𝑎𝑏𝑒𝑡𝑖𝑐𝑜𝑠." << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "𝐴𝑝𝑒
𝑙𝑒 (!𝑒𝑠𝐺𝑒𝑛𝑒𝑟𝑜𝑉𝑎𝑙𝑖𝑑𝑜(𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑔𝑒𝑛𝑒𝑟𝑜)); 𝑐𝑜𝑢𝑡 << "𝐸𝑠𝑡𝑎𝑑𝑜 𝑐𝑖𝑣𝑖𝑙 (𝑆/𝐶/𝑉/𝐷): "; 𝑑𝑜 { 𝑐𝑖𝑛 >> 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑒𝑠𝑡𝑎𝑑𝑜𝐶𝑖𝑣𝑖𝑙; 𝑖𝑓 (!𝑒𝑠
𝐿𝑖𝑚𝑝𝑖𝑎𝑟 𝑒𝑙 𝑏𝑢𝑓𝑓𝑒𝑟 𝑑𝑒𝑙 𝑡𝑒𝑐𝑙𝑎𝑑𝑜 // 𝐼𝑛𝑔𝑟𝑒𝑠𝑎 𝑙𝑎 𝑑𝑖𝑟𝑒𝑐𝑐𝑖𝑜𝑛 𝑐𝑜𝑢𝑡 << "𝐷𝑖𝑟𝑒𝑐𝑐𝑖𝑜𝑛: "; 𝑔𝑒𝑡𝑙𝑖𝑛𝑒(𝑐𝑖𝑛, 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑑𝑖𝑟𝑒𝑐𝑐𝑖𝑜𝑛); // 𝐼𝑛𝑔𝑟𝑒𝑠
< "𝑆𝑒𝑙𝑒𝑐𝑐𝑖𝑜𝑛𝑒 𝑒𝑙 𝑑𝑎𝑡𝑜 𝑞𝑢𝑒 𝑑𝑒𝑠𝑒𝑎 𝑎𝑐𝑡𝑢𝑎𝑙𝑖𝑧𝑎𝑟:" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "1. 𝑁𝑜𝑚𝑏𝑟𝑒" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "2. 𝐴𝑝𝑒𝑙𝑙𝑖𝑑𝑜" << 𝑒𝑛𝑑𝑙; 𝑐
𝑔𝑒𝑡𝑙𝑖𝑛𝑒(𝑐𝑖𝑛, 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑛𝑜𝑚𝑏𝑟𝑒); 𝑖𝑓 (!𝑒𝑠𝑁𝑜𝑚𝑏𝑟𝑒𝑉𝑎𝑙𝑖𝑑𝑜(𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑛𝑜𝑚𝑏𝑟𝑒)) { 𝑐𝑜𝑢𝑡 << "𝑁𝑜𝑚𝑏𝑟𝑒 𝑛𝑜 𝑣𝑎𝑙𝑖𝑑𝑜. 𝑃𝑜
𝑡 << "𝑁𝑢𝑒𝑣𝑜 𝑎𝑝𝑒𝑙𝑙𝑖𝑑𝑜: "; } } 𝑤ℎ𝑖𝑙𝑒 (!𝑒𝑠𝑁𝑜𝑚𝑏𝑟𝑒𝑉𝑎𝑙𝑖𝑑𝑜(𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑎𝑝𝑒𝑙𝑙𝑖𝑑𝑜)); 𝑏𝑟𝑒𝑎𝑘; 𝑐𝑎𝑠𝑒 3: 𝑐𝑜
𝑙𝑖𝑑𝑜. 𝑃𝑜𝑟 𝑓𝑎𝑣𝑜𝑟, 𝑖𝑛𝑔𝑟𝑒𝑠𝑒 ′𝑀′ 𝑜 ′𝐹′." << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "𝑁𝑢𝑒𝑣𝑜 𝑔𝑒𝑛𝑒𝑟𝑜 (𝑀/𝐹): "; } } 𝑤ℎ𝑖𝑙𝑒 (!𝑒𝑠𝐺𝑒𝑛𝑒𝑟𝑜𝑉
𝑑𝑜 { 𝑐𝑜𝑢𝑡 << "𝑁𝑢𝑒𝑣𝑜 𝐷𝑁𝐼 (8 𝑑𝑖𝑔𝑖𝑡𝑜𝑠): "; 𝑐𝑖𝑛 >> 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑑𝑛𝑖; 𝑖𝑓 (!𝑒𝑠𝐷𝑛𝑖𝑉𝑎𝑙𝑖𝑑𝑜(𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑑𝑛𝑖)
𝑐𝑜𝑢𝑡 << "𝐶𝑒𝑙𝑢𝑙𝑎𝑟 𝑛𝑜 𝑣𝑎𝑙𝑖𝑑𝑜. 𝐼𝑛𝑡𝑒𝑛𝑡𝑒 𝑛𝑢𝑒𝑣𝑎𝑚𝑒𝑛𝑡𝑒." << 𝑒𝑛𝑑𝑙; } } 𝑤ℎ𝑖𝑙𝑒 (!𝑒𝑠𝐶𝑒𝑙𝑢𝑙𝑎𝑟𝑉𝑎𝑙𝑖𝑑𝑜(𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑐𝑒𝑙𝑢𝑙𝑎𝑟));
𝑎𝑙𝑖𝑑𝑜 = 𝑓𝑎𝑙𝑠𝑒; 𝑐𝑖𝑛.𝑖𝑔𝑛𝑜𝑟𝑒(); // 𝐿𝑖𝑚𝑝𝑖𝑎𝑟 𝑒𝑙 𝑏𝑢𝑓𝑓𝑒𝑟 𝑑𝑒 𝑒𝑛𝑡𝑟𝑎𝑑𝑎 // 𝐿𝑒𝑒𝑟 𝑦 𝑣𝑎𝑙𝑖𝑑𝑎𝑟 𝑒𝑙 𝑛𝑜𝑚𝑏𝑟𝑒 𝑑𝑒𝑙 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒 𝑑𝑜 { 𝑐𝑜𝑢𝑡 << "𝐼𝑛𝑔
\𝑛′); // 𝐼𝑔𝑛𝑜𝑟𝑎 𝑙𝑎 𝑒𝑛𝑡𝑟𝑎𝑑𝑎 𝑛𝑜 𝑣𝑎𝑙𝑖𝑑𝑎 𝑐𝑜𝑢𝑡 << "𝐸𝑛𝑡𝑟𝑎𝑑𝑎 𝑛𝑜 𝑣𝑎𝑙𝑖𝑑𝑎. 𝑃𝑜𝑟 𝑓𝑎𝑣𝑜𝑟, 𝑖𝑛𝑔𝑟𝑒𝑠𝑒 𝑢𝑛 𝑛𝑢𝑚𝑒𝑟𝑜 𝑝𝑎𝑟𝑎 𝑒𝑙 𝑝𝑒𝑠𝑜: "; } 𝑐𝑜𝑢𝑡 <<
<< "𝑃𝑟𝑒𝑠𝑖𝑜𝑛 𝑎𝑟𝑡𝑒𝑟𝑖𝑎𝑙 (𝑚𝑚𝐻𝑔): "; 𝑤ℎ𝑖𝑙𝑒 (!(𝑐𝑖𝑛 >> 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑝𝑟𝑒𝑠𝑖𝑜𝑛)) { 𝑐𝑖𝑛.𝑐𝑙𝑒𝑎𝑟(); 𝑐𝑖𝑛.𝑖𝑔𝑛𝑜𝑟𝑒(𝑛𝑢𝑚𝑒𝑟𝑖𝑐_𝑙𝑖𝑚𝑖𝑡𝑠<𝑠𝑡𝑟𝑒𝑎𝑚𝑠𝑖
& 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒) { 𝑐𝑜𝑛𝑠𝑡 𝑖𝑛𝑡 𝑎𝑛𝑐ℎ𝑜 = 50; // 𝐴𝑛𝑐ℎ𝑜 𝑑𝑒𝑙 𝑐𝑢𝑎𝑑𝑟𝑜 𝑐𝑜𝑢𝑡 << 𝑠𝑡𝑟𝑖𝑛𝑔(𝑎𝑛𝑐ℎ𝑜, ′−′) << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "| " << 𝑙𝑒𝑓𝑡 << 𝑠𝑒𝑡𝑤
𝑎𝑛𝑐ℎ𝑜 − 29) << 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑝𝑟𝑒𝑠𝑖𝑜𝑛 << " |" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "| 𝑆𝑎𝑡𝑢𝑟𝑎𝑐𝑖𝑜𝑛 𝑑𝑒 𝑜𝑥𝑖𝑔𝑒𝑛𝑜 (%): " << 𝑙𝑒𝑓𝑡 << 𝑠𝑒𝑡𝑤(𝑎𝑛𝑐ℎ𝑜 − 31) <<
2) << 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑛𝑜𝑚𝑏𝑟𝑒 << " |" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "| 𝐴𝑝𝑒𝑙𝑙𝑖𝑑𝑜: " << 𝑙𝑒𝑓𝑡 << 𝑠𝑒𝑡𝑤(𝑎𝑛𝑐ℎ𝑜 − 12) << 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑎𝑝𝑒𝑙𝑙𝑖𝑑𝑜 << " |" <<
𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑑𝑖𝑟𝑒𝑐𝑐𝑖𝑜𝑛 << " |" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "| 𝐶𝑒𝑙𝑢𝑙𝑎𝑟: " << 𝑙𝑒𝑓𝑡 << 𝑠𝑒𝑡𝑤(𝑎𝑛𝑐ℎ𝑜 − 12) << 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑐𝑒𝑙𝑢𝑙𝑎𝑟 << " |" << 𝑒𝑛𝑑𝑙; 𝑐
𝑛𝑜 𝑣𝑎𝑙𝑖𝑑𝑜. 𝐼𝑛𝑔𝑟𝑒𝑠𝑒 𝑠𝑜𝑙𝑜 𝑐𝑎𝑟𝑎𝑐𝑡𝑒𝑟𝑒𝑠 𝑎𝑙𝑓𝑎𝑏𝑒𝑡𝑖𝑐𝑜𝑠." << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "𝐼𝑛𝑔𝑟𝑒𝑠𝑒 𝑒𝑙 𝑛𝑜𝑚𝑏𝑟𝑒 𝑑𝑒𝑙 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒: "; 𝑔𝑒𝑡𝑙𝑖𝑛𝑒(𝑐𝑖𝑛, 𝑝𝑎𝑐𝑖𝑒𝑛
𝑒) { 𝑠𝑡𝑟𝑖𝑛𝑔 𝑖𝑛𝑝𝑢𝑡; 𝑔𝑒𝑡𝑙𝑖𝑛𝑒(𝑐𝑖𝑛, 𝑖𝑛𝑝𝑢𝑡); 𝑡𝑟𝑦 { 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑒𝑠𝑝𝑒𝑐𝑖𝑎𝑙𝑖𝑑𝑎𝑑𝐴𝑠𝑖𝑔𝑛𝑎𝑑𝑎 = 𝑠𝑡𝑜𝑖(𝑖𝑛𝑝𝑢𝑡); 𝑖𝑓 (𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒
𝑒 𝑒𝑙 𝑛𝑢𝑚𝑒𝑟𝑜 𝑐𝑜𝑟𝑟𝑒𝑠𝑝𝑜𝑛𝑑𝑖𝑒𝑛𝑡𝑒 𝑎 𝑙𝑎 𝑒𝑠𝑝𝑒𝑐𝑖𝑎𝑙𝑖𝑑𝑎𝑑 𝑎𝑠𝑖𝑔𝑛𝑎𝑑𝑎: "; } 𝑐𝑎𝑡𝑐ℎ (𝑜𝑢𝑡_𝑜𝑓_𝑟𝑎𝑛𝑔𝑒& 𝑒) { 𝑐𝑜𝑢𝑡 << "𝑁𝑢𝑚𝑒𝑟𝑜 𝑓𝑢𝑒𝑟𝑎 𝑑𝑒 𝑟𝑎
𝑠." << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "𝐼𝑛𝑔𝑟𝑒𝑠𝑒 𝑒𝑙 𝑛𝑜𝑚𝑏𝑟𝑒 𝑑𝑒𝑙 𝑚𝑒𝑑𝑖𝑐𝑜 𝑎𝑠𝑖𝑔𝑛𝑎𝑑𝑜: "; 𝑔𝑒𝑡𝑙𝑖𝑛𝑒(𝑐𝑖𝑛, 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑚𝑒𝑑𝑖𝑐𝑜𝐴𝑠𝑖𝑔𝑛𝑎𝑑𝑜); } 𝑐𝑜𝑢𝑡 << "𝐸
𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "𝐼𝑛𝑔𝑟𝑒𝑠𝑒 𝑒𝑙 𝑛𝑜𝑚𝑏𝑟𝑒 𝑑𝑒𝑙 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒: "; 𝑔𝑒𝑡𝑙𝑖𝑛𝑒(𝑐𝑖𝑛, 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑛𝑜𝑚𝑏𝑟𝑒); } 𝑐𝑜𝑢𝑡 << "𝑁𝑖𝑣𝑒𝑙𝑒𝑠 𝑑𝑒 𝑢𝑟𝑔𝑒𝑛𝑐𝑖𝑎\𝑛
𝑐𝑖𝑛.𝑖𝑔𝑛𝑜𝑟𝑒(𝑛𝑢𝑚𝑒𝑟𝑖𝑐_𝑙𝑖𝑚𝑖𝑡𝑠<𝑠𝑡𝑟𝑒𝑎𝑚𝑠𝑖𝑧𝑒>::𝑚𝑎𝑥(), ′\𝑛′); 𝑐𝑖𝑛 >> 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑛𝑖𝑣𝑒𝑙𝑈𝑟𝑔𝑒𝑛𝑐𝑖𝑎; } 𝑎𝑢𝑡𝑜 𝑖𝑡 = 𝑓𝑖𝑛𝑑_𝑖𝑓(𝑙𝑖𝑠𝑡𝑎𝐸𝑠𝑝𝑒
𝑖𝑎𝑟 𝑒𝑙 𝑏𝑢𝑓𝑓𝑒𝑟 𝑑𝑒𝑙 𝑡𝑒𝑐𝑙𝑎𝑑𝑜 𝑠𝑡𝑟𝑖𝑛𝑔 𝑛𝑜𝑚𝑏𝑟𝑒; 𝑔𝑒𝑡𝑙𝑖𝑛𝑒(𝑐𝑖𝑛, 𝑛𝑜𝑚𝑏𝑟𝑒); 𝑤ℎ𝑖𝑙𝑒 (!𝑒𝑠𝑁𝑜𝑚𝑏𝑟𝑒𝑉𝑎𝑙𝑖𝑑𝑜(𝑛𝑜𝑚𝑏𝑟𝑒)) { 𝑐𝑜𝑢𝑡 << "𝑁𝑜𝑚𝑏𝑟𝑒

𝑟𝑖𝑜∗ 𝑐𝑟𝑒𝑎𝑟𝑈𝑠𝑢𝑎𝑟𝑖𝑜(𝑠𝑡𝑟𝑖𝑛𝑔 𝑡𝑖𝑝𝑜, 𝑠𝑡𝑟𝑖𝑛𝑔 𝑛𝑜𝑚𝑏𝑟𝑒, 𝑠𝑡𝑟𝑖𝑛𝑔 𝑐𝑜𝑛𝑡𝑟𝑎𝑠𝑒𝑛𝑎) { 𝑈𝑠𝑢𝑎𝑟𝑖𝑜∗ 𝑛𝑢𝑒𝑣𝑜 = 𝑛𝑒𝑤 𝑈𝑠𝑢𝑎𝑟𝑖𝑜; 𝑛𝑢𝑒𝑣𝑜−>𝑡𝑖𝑝𝑜 = 𝑡𝑖𝑝𝑜; 𝑛
𝑛𝑡𝑟𝑎𝑠𝑒𝑛𝑎) { 𝑐𝑜𝑢𝑡 << "𝐼𝑛𝑔𝑟𝑒𝑠𝑒 𝑛𝑜𝑚𝑏𝑟𝑒: "; 𝑐𝑖𝑛 >> 𝑛𝑜𝑚𝑏𝑟𝑒; 𝑐𝑖𝑛.𝑖𝑔𝑛𝑜𝑟𝑒(𝑛𝑢𝑚𝑒𝑟𝑖𝑐_𝑙𝑖𝑚𝑖𝑡𝑠<𝑠𝑡𝑟𝑒𝑎𝑚𝑠𝑖𝑧𝑒>::𝑚𝑎𝑥(), ′\𝑛′); // 𝐿𝑖𝑚𝑝𝑖𝑎
𝑛𝑢𝑙𝑙𝑝𝑡𝑟) { 𝑖𝑓 (𝑎𝑐𝑡𝑢𝑎𝑙−>𝑛𝑜𝑚𝑏𝑟𝑒 == 𝑛𝑜𝑚𝑏𝑟𝑒 && 𝑎𝑐𝑡𝑢𝑎𝑙−>𝑐𝑜𝑛𝑡𝑟𝑎𝑠𝑒𝑛𝑎 == 𝑐𝑜𝑛𝑡𝑟𝑎𝑠𝑒𝑛𝑎) { 𝑟𝑒𝑡𝑢𝑟𝑛 𝑡𝑟𝑢𝑒; } 𝑎𝑐𝑡𝑢𝑎𝑙 = 𝑎
𝑓𝑒𝑟𝑚𝑒𝑟𝑎𝑣𝑜𝑖𝑑 𝑚𝑎𝑛𝑒𝑗𝑎𝑟𝑀𝑒𝑛𝑢𝐸𝑛𝑓𝑒𝑟𝑚𝑒𝑟𝑎(𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒& 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒, 𝑣𝑒𝑐𝑡𝑜𝑟<𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒>& 𝑙𝑖𝑠𝑡𝑎𝐸𝑠𝑝𝑒𝑟𝑎) { 𝑖𝑛𝑡 𝑜𝑝𝑐𝑖𝑜𝑛; 𝑑𝑜 { 𝑐𝑜𝑢𝑡 <<
𝑡 << "𝐼𝑛𝑔𝑟𝑒𝑠𝑒 𝑢𝑛𝑎 𝑜𝑝𝑐𝑖𝑜𝑛: "; 𝑐𝑖𝑛 >> 𝑜𝑝𝑐𝑖𝑜𝑛; 𝑠𝑤𝑖𝑡𝑐ℎ (𝑜𝑝𝑐𝑖𝑜𝑛) { 𝑐𝑎𝑠𝑒 1: 𝑟𝑒𝑔𝑖𝑠𝑡𝑟𝑎𝑟𝐷𝑎𝑡𝑜𝑠𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒(𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒);
𝐴𝑠𝑖𝑔𝑛𝑎𝑛𝑑𝑜 𝑒𝑠𝑝𝑒𝑐𝑖𝑎𝑙𝑖𝑑𝑎𝑑 𝑦 𝑚𝑒𝑑𝑖𝑐𝑜..." << 𝑒𝑛𝑑𝑙; 𝑎𝑠𝑖𝑔𝑛𝑎𝑟𝐸𝑠𝑝𝑒𝑐𝑖𝑎𝑙𝑖𝑑𝑎𝑑𝑌𝑀𝑒𝑑𝑖𝑐𝑜(𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒); 𝑏𝑟𝑒𝑎𝑘; 𝑐𝑎𝑠𝑒 6:
𝑝𝑐𝑖𝑜𝑛 != 8);}// 𝐹𝑢𝑛𝑐𝑖𝑜𝑛 𝑝𝑎𝑟𝑎 𝑚𝑜𝑠𝑡𝑟𝑎𝑟 𝑒𝑙 𝑚𝑒𝑛𝑢 𝑦 𝑔𝑒𝑠𝑡𝑖𝑜𝑛𝑎𝑟 𝑒𝑙 𝑖𝑛𝑔𝑟𝑒𝑠𝑜 𝑑𝑒 𝑢𝑠𝑢𝑎𝑟𝑖𝑜𝑠𝑣𝑜𝑖𝑑 𝑚𝑜𝑠𝑡𝑟𝑎𝑟𝑀𝑒𝑛𝑢𝐼𝑛𝑔𝑟𝑒𝑠𝑜(𝑈𝑠𝑢𝑎𝑟𝑖𝑜∗& 𝑙𝑖𝑠𝑡𝑎𝑀
𝑒𝑟𝑚𝑒𝑟𝑖𝑎" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "5. 𝑆𝑎𝑙𝑖𝑟" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "𝐼𝑛𝑔𝑟𝑒𝑠𝑒 𝑢𝑛𝑎 𝑜𝑝𝑐𝑖𝑜𝑛: "; 𝑐𝑖𝑛 >> 𝑜𝑝𝑐𝑖𝑜𝑛; 𝑖𝑓 (𝑐𝑖𝑛.𝑓𝑎𝑖𝑙()) {
 𝑖𝑎𝑟 𝑒𝑙 𝑏𝑢𝑓𝑓𝑒𝑟 𝑑𝑒𝑙 𝑡𝑒𝑐𝑙𝑎𝑑𝑜 𝑠𝑡𝑟𝑖𝑛𝑔 𝑛𝑜𝑚𝑏𝑟𝑒; 𝑔𝑒𝑡𝑙𝑖𝑛𝑒(𝑐𝑖𝑛, 𝑛𝑜𝑚𝑏𝑟𝑒); 𝑤ℎ𝑖𝑙𝑒 (!𝑒𝑠𝑁𝑜𝑚𝑏𝑟𝑒𝑉𝑎𝑙𝑖𝑑𝑜(𝑛𝑜𝑚𝑏𝑟𝑒)) { 𝑐𝑜𝑢𝑡 << "𝑁𝑜𝑚𝑏𝑟𝑒
𝑟𝑖𝑜∗ 𝑐𝑟𝑒𝑎𝑟𝑈𝑠𝑢𝑎𝑟𝑖𝑜(𝑠𝑡𝑟𝑖𝑛𝑔 𝑡𝑖𝑝𝑜, 𝑠𝑡𝑟𝑖𝑛𝑔 𝑛𝑜𝑚𝑏𝑟𝑒, 𝑠𝑡𝑟𝑖𝑛𝑔 𝑐𝑜𝑛𝑡𝑟𝑎𝑠𝑒𝑛𝑎) { 𝑈𝑠𝑢𝑎𝑟𝑖𝑜∗ 𝑛𝑢𝑒𝑣𝑜 = 𝑛𝑒𝑤 𝑈𝑠𝑢𝑎𝑟𝑖𝑜; 𝑛𝑢𝑒𝑣𝑜−>𝑡𝑖𝑝𝑜 = 𝑡𝑖𝑝𝑜; 𝑛
𝑛𝑡𝑟𝑎𝑠𝑒𝑛𝑎) { 𝑐𝑜𝑢𝑡 << "𝐼𝑛𝑔𝑟𝑒𝑠𝑒 𝑛𝑜𝑚𝑏𝑟𝑒: "; 𝑐𝑖𝑛 >> 𝑛𝑜𝑚𝑏𝑟𝑒; 𝑐𝑖𝑛.𝑖𝑔𝑛𝑜𝑟𝑒(𝑛𝑢𝑚𝑒𝑟𝑖𝑐_𝑙𝑖𝑚𝑖𝑡𝑠<𝑠𝑡𝑟𝑒𝑎𝑚𝑠𝑖𝑧𝑒>::𝑚𝑎𝑥(), ′\𝑛′); // 𝐿𝑖𝑚𝑝𝑖𝑎
𝑛𝑢𝑙𝑙𝑝𝑡𝑟) { 𝑖𝑓 (𝑎𝑐𝑡𝑢𝑎𝑙−>𝑛𝑜𝑚𝑏𝑟𝑒 == 𝑛𝑜𝑚𝑏𝑟𝑒 && 𝑎𝑐𝑡𝑢𝑎𝑙−>𝑐𝑜𝑛𝑡𝑟𝑎𝑠𝑒𝑛𝑎 == 𝑐𝑜𝑛𝑡𝑟𝑎𝑠𝑒𝑛𝑎) { 𝑟𝑒𝑡𝑢𝑟𝑛 𝑡𝑟𝑢𝑒; } 𝑎𝑐𝑡𝑢𝑎𝑙 = 𝑎
𝑓𝑒𝑟𝑚𝑒𝑟𝑎𝑣𝑜𝑖𝑑 𝑚𝑎𝑛𝑒𝑗𝑎𝑟𝑀𝑒𝑛𝑢𝐸𝑛𝑓𝑒𝑟𝑚𝑒𝑟𝑎(𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒& 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒, 𝑣𝑒𝑐𝑡𝑜𝑟<𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒>& 𝑙𝑖𝑠𝑡𝑎𝐸𝑠𝑝𝑒𝑟𝑎) { 𝑖𝑛𝑡 𝑜𝑝𝑐𝑖𝑜𝑛; 𝑑𝑜 { 𝑐𝑜𝑢𝑡 <<
𝑡 << "𝐼𝑛𝑔𝑟𝑒𝑠𝑒 𝑢𝑛𝑎 𝑜𝑝𝑐𝑖𝑜𝑛: "; 𝑐𝑖𝑛 >> 𝑜𝑝𝑐𝑖𝑜𝑛; 𝑠𝑤𝑖𝑡𝑐ℎ (𝑜𝑝𝑐𝑖𝑜𝑛) { 𝑐𝑎𝑠𝑒 1: 𝑟𝑒𝑔𝑖𝑠𝑡𝑟𝑎𝑟𝐷𝑎𝑡𝑜𝑠𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒(𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒);
𝐴𝑠𝑖𝑔𝑛𝑎𝑛𝑑𝑜 𝑒𝑠𝑝𝑒𝑐𝑖𝑎𝑙𝑖𝑑𝑎𝑑 𝑦 𝑚𝑒𝑑𝑖𝑐𝑜..." << 𝑒𝑛𝑑𝑙; 𝑎𝑠𝑖𝑔𝑛𝑎𝑟𝐸𝑠𝑝𝑒𝑐𝑖𝑎𝑙𝑖𝑑𝑎𝑑𝑌𝑀𝑒𝑑𝑖𝑐𝑜(𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒); 𝑏𝑟𝑒𝑎𝑘; 𝑐𝑎𝑠𝑒 6:
𝑝𝑐𝑖𝑜𝑛 != 8);}// 𝐹𝑢𝑛𝑐𝑖𝑜𝑛 𝑝𝑎𝑟𝑎 𝑚𝑜𝑠𝑡𝑟𝑎𝑟 𝑒𝑙 𝑚𝑒𝑛𝑢 𝑦 𝑔𝑒𝑠𝑡𝑖𝑜𝑛𝑎𝑟 𝑒𝑙 𝑖𝑛𝑔𝑟𝑒𝑠𝑜 𝑑𝑒 𝑢𝑠𝑢𝑎𝑟𝑖𝑜𝑠𝑣𝑜𝑖𝑑 𝑚𝑜𝑠𝑡𝑟𝑎𝑟𝑀𝑒𝑛𝑢𝐼𝑛𝑔𝑟𝑒𝑠𝑜(𝑈𝑠𝑢𝑎𝑟𝑖𝑜∗& 𝑙𝑖𝑠𝑡𝑎𝑀
𝑒𝑟𝑚𝑒𝑟𝑖𝑎" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "5. 𝑆𝑎𝑙𝑖𝑟" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "𝐼𝑛𝑔𝑟𝑒𝑠𝑒 𝑢𝑛𝑎 𝑜𝑝𝑐𝑖𝑜𝑛: "; 𝑐𝑖𝑛 >> 𝑜𝑝𝑐𝑖𝑜𝑛; 𝑖𝑓 (𝑐𝑖𝑛.𝑓𝑎𝑖𝑙()) {
𝑛𝑎)) { 𝑐𝑜𝑢𝑡 << "𝐴𝑐𝑐𝑒𝑠𝑜 𝑐𝑜𝑛𝑐𝑒𝑑𝑖𝑑𝑜 𝑎𝑙 𝑚𝑒𝑑𝑖𝑐𝑜" << 𝑒𝑛𝑑𝑙; 𝑚𝑎𝑛𝑒𝑗𝑎𝑟𝑀𝑒𝑛𝑢𝑀𝑒𝑑𝑖𝑐𝑜(𝑟𝑒𝑐𝑒𝑡𝑎𝑠); 𝑐𝑟𝑒𝑑𝑒𝑛
𝑛𝑐𝑒𝑑𝑖𝑑𝑜 𝑎𝑙 𝑒𝑛𝑓𝑒𝑟𝑚𝑒𝑟𝑜" << 𝑒𝑛𝑑𝑙; 𝑚𝑎𝑛𝑒𝑗𝑎𝑟𝑀𝑒𝑛𝑢𝐸𝑛𝑓𝑒𝑟𝑚𝑒𝑟𝑎(𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒, 𝑙𝑖𝑠𝑡𝑎𝐸𝑠𝑝𝑒𝑟𝑎); 𝑐𝑟𝑒𝑑𝑒𝑛𝑐𝑖𝑎𝑙𝑒𝑠𝑉𝑎𝑙𝑖𝑑𝑎𝑠
4: { 𝑠𝑡𝑟𝑖𝑛𝑔 𝑛𝑜𝑚𝑏𝑟𝑒, 𝑐𝑜𝑛𝑡𝑟𝑎𝑠𝑒𝑛𝑎; 𝑝𝑒𝑑𝑖𝑟𝐷𝑎𝑡𝑜𝑠(𝑛𝑜𝑚𝑏𝑟𝑒, 𝑐𝑜𝑛𝑡𝑟𝑎𝑠𝑒𝑛𝑎); 𝑎𝑔𝑟𝑒𝑔𝑎𝑟𝑈𝑠𝑢𝑎𝑟𝑖𝑜(𝑙𝑖𝑠𝑡𝑎𝐸𝑛𝑓𝑒𝑟𝑚𝑒𝑟𝑎𝑠, "𝑒
𝑎𝑡𝑎𝑚𝑖𝑒𝑛𝑡𝑜;};// 𝐸𝑠𝑡𝑟𝑢𝑐𝑡𝑢𝑟𝑎 𝑝𝑎𝑟𝑎 𝑎𝑙𝑚𝑎𝑐𝑒𝑛𝑎𝑟 𝑙𝑜𝑠 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒𝑠 𝑦 𝑠𝑢 ℎ𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙 𝑚𝑒𝑑𝑖𝑐𝑜𝑚𝑎𝑝<𝑠𝑡𝑟𝑖𝑛𝑔, 𝑣𝑒𝑐𝑡𝑜𝑟<𝐻𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙𝑀𝑒𝑑𝑖𝑐𝑜>> ℎ𝑖𝑠𝑡𝑜
𝑁𝑜𝑚𝑏𝑟𝑒.𝑓𝑖𝑛𝑑(𝑛𝑜𝑚𝑏𝑟𝑒𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒) != ℎ𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙𝑃𝑜𝑟𝑁𝑜𝑚𝑏𝑟𝑒.𝑒𝑛𝑑()) { 𝑟𝑒𝑡𝑢𝑟𝑛 ℎ𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙𝑃𝑜𝑟𝑁𝑜𝑚𝑏𝑟𝑒[𝑛𝑜𝑚𝑏𝑟𝑒𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒]; } 𝑒𝑙𝑠𝑒 {
𝑎𝑡𝑜 𝑑𝑑/𝑚𝑚/𝑎𝑎𝑎𝑎): " << ℎ𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙[𝑖].𝑓𝑒𝑐ℎ𝑎𝐶𝑜𝑛𝑠𝑢𝑙𝑡𝑎 << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "𝑀𝑜𝑡𝑖𝑣𝑜 𝑑𝑒 𝑐𝑜𝑛𝑠𝑢𝑙𝑡𝑎: " << ℎ𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙[𝑖].𝑚𝑜𝑡𝑖𝑣𝑜𝐶𝑜𝑛𝑠𝑢
){ 𝑖𝑓 (𝑖𝑛𝑑𝑖𝑐𝑒 < ℎ𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙𝑃𝑜𝑟𝑁𝑜𝑚𝑏𝑟𝑒[𝑛𝑜𝑚𝑏𝑟𝑒𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒].𝑠𝑖𝑧𝑒()) { ℎ𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙𝑃𝑜𝑟𝑁𝑜𝑚𝑏𝑟𝑒[𝑛𝑜𝑚𝑏𝑟𝑒𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒][𝑖𝑛𝑑𝑖𝑐𝑒] = 𝑛𝑢𝑒𝑣
𝑐𝑜𝑢𝑡 << "𝐸𝑙 ℎ𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙 𝑚𝑒𝑑𝑖𝑐𝑜 𝑒𝑠𝑡𝑎 𝑣𝑎𝑐𝑖𝑜." << 𝑒𝑛𝑑𝑙; } 𝑒𝑙𝑠𝑒 { 𝑓𝑜𝑟 (𝑠𝑖𝑧𝑒_𝑡 𝑖 = 0; 𝑖 < ℎ𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙.𝑠𝑖𝑧𝑒(); ++𝑖) { 𝑠𝑖𝑧𝑒_𝑡 𝑏𝑎𝑠𝑒𝐼𝑛
𝐹𝑢𝑛𝑐𝑖𝑜𝑛 𝑝𝑎𝑟𝑎 𝑚𝑎𝑛𝑒𝑗𝑎𝑟 𝑙𝑎 𝑎𝑐𝑡𝑢𝑎𝑙𝑖𝑧𝑎𝑐𝑖𝑜𝑛 𝑑𝑒𝑙 ℎ𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙 𝑚𝑒𝑑𝑖𝑐𝑜𝑣𝑜𝑖𝑑 𝑚𝑎𝑛𝑒𝑗𝑎𝑟𝐴𝑐𝑡𝑢𝑎𝑙𝑖𝑧𝑎𝑐𝑖𝑜𝑛𝐻𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙𝑀𝑒𝑑𝑖𝑐𝑜() { 𝑠𝑡𝑟𝑖𝑛𝑔 𝑛𝑜𝑚𝑏𝑟𝑒𝑃𝑎
𝑛𝑜𝑚𝑏𝑟𝑒𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒); } 𝑖𝑓 (ℎ𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙𝑃𝑜𝑟𝑁𝑜𝑚𝑏𝑟𝑒.𝑓𝑖𝑛𝑑(𝑛𝑜𝑚𝑏𝑟𝑒𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒) != ℎ𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙𝑃𝑜𝑟𝑁𝑜𝑚𝑏𝑟𝑒.𝑒𝑛𝑑()) { 𝑣𝑒𝑐𝑡𝑜𝑟<𝐻𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙𝑀
𝑎𝑙𝑀𝑒𝑑𝑖𝑐𝑜& 𝑟𝑒𝑔𝑖𝑠𝑡𝑟𝑜 = ℎ𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙[𝑟𝑒𝑔𝑖𝑠𝑡𝑟𝑜𝐼𝑛𝑑𝑒𝑥]; // 𝑂𝑏𝑡𝑒𝑛𝑒𝑟 𝑒𝑙 𝑟𝑒𝑔𝑖𝑠𝑡𝑟𝑜 𝑎 𝑎𝑐𝑡𝑢𝑎𝑙𝑖𝑧𝑎𝑟 𝑠𝑤𝑖𝑡𝑐ℎ (𝑐𝑎𝑚𝑝𝑜) { 𝑐𝑎𝑠𝑒 0:
𝑐𝑎𝑠𝑒 3: 𝑐𝑜𝑢𝑡 << "𝐼𝑛𝑔𝑟𝑒𝑠𝑒 𝑒𝑙 𝑛𝑢𝑒𝑣𝑜 𝑡𝑟𝑎𝑡𝑎𝑚𝑖𝑒𝑛𝑡𝑜: "; 𝑐𝑖𝑛.𝑖𝑔𝑛𝑜𝑟𝑒(); 𝑔𝑒𝑡𝑙𝑖𝑛𝑒(𝑐𝑖𝑛, 𝑟𝑒𝑔𝑖𝑠𝑡𝑟𝑜.𝑡𝑟𝑎𝑡𝑎𝑚𝑖𝑒𝑛𝑡𝑜)
𝑝𝑖𝑡𝑎𝑙> ℎ𝑜𝑠𝑝𝑖𝑡𝑎𝑙𝑒𝑠 = { {"𝐻𝑜𝑠𝑝𝑖𝑡𝑎𝑙 𝐺𝑒𝑛𝑒𝑟𝑎𝑙 𝐶𝑒𝑛𝑡𝑟𝑎𝑙", "123−456−789"}, {"𝐶𝑙𝑖𝑛𝑖𝑐𝑎 𝑆𝑎𝑛 𝑃𝑒𝑑𝑟𝑜", "987−654−321"}, {"𝐻𝑜𝑠𝑝
(); 𝑔𝑒𝑡𝑙𝑖𝑛𝑒(𝑐𝑖𝑛, 𝑛𝑜𝑚𝑏𝑟𝑒𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒); 𝑖𝑓 (!𝑛𝑜𝑚𝑏𝑟𝑒𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑒𝑚𝑝𝑡𝑦() && 𝑖𝑠𝑎𝑙𝑝ℎ𝑎(𝑛𝑜𝑚𝑏𝑟𝑒𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒[0])) { 𝑛𝑜𝑚𝑏𝑟𝑒𝑉𝑎𝑙𝑖𝑑𝑜 =
𝑒𝑙 𝑏𝑢𝑓𝑓𝑒𝑟 𝑑𝑒 𝑒𝑛𝑡𝑟𝑎𝑑𝑎 𝑐𝑜𝑢𝑡 << "𝑂𝑝𝑐𝑖𝑜𝑛 𝑛𝑜 𝑣𝑎𝑙𝑖𝑑𝑎. 𝑃𝑜𝑟 𝑓𝑎𝑣𝑜𝑟, 𝑖𝑛𝑡𝑒𝑛𝑡𝑒 𝑛𝑢𝑒𝑣𝑎𝑚𝑒𝑛𝑡𝑒." << 𝑒𝑛𝑑𝑙; } 𝑒𝑙𝑠𝑒 { 𝑜𝑝𝑐𝑖𝑜𝑛𝑉𝑎𝑙𝑖𝑑𝑎
𝑜𝑚𝑏𝑟𝑒𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒 << "\𝑛"; 𝑎𝑟𝑐ℎ𝑖𝑣𝑜 << "𝑀𝑒𝑑𝑖𝑐𝑎𝑚𝑒𝑛𝑡𝑜: " << 𝑟𝑒𝑐𝑒𝑡𝑎.𝑚𝑒𝑑𝑖𝑐𝑎𝑚𝑒𝑛𝑡𝑜 << "\𝑛"; 𝑎𝑟𝑐ℎ𝑖𝑣𝑜 << "𝐷𝑜𝑠𝑖𝑠: " << 𝑟𝑒
𝑐𝑜𝑣𝑜𝑖𝑑 𝑚𝑎𝑛𝑒𝑗𝑎𝑟𝑀𝑒𝑛𝑢𝑀𝑒𝑑𝑖𝑐𝑜(𝑣𝑒𝑐𝑡𝑜𝑟<𝑅𝑒𝑐𝑒𝑡𝑎>& 𝑟𝑒𝑐𝑒𝑡𝑎𝑠) { 𝑖𝑛𝑡 𝑜𝑝𝑐𝑖𝑜𝑛; 𝑣𝑒𝑐𝑡𝑜𝑟<𝐻𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙𝑀𝑒𝑑𝑖𝑐𝑜> ℎ𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙; 𝐻𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙𝑀𝑒𝑑𝑖𝑐
𝑠𝑒 𝑢𝑛𝑎 𝑜𝑝𝑐𝑖𝑜𝑛: "; 𝑐𝑖𝑛 >> 𝑜𝑝𝑐𝑖𝑜𝑛; 𝑖𝑓 (𝑐𝑖𝑛.𝑓𝑎𝑖𝑙()) { // 𝐿𝑖𝑚𝑝𝑖𝑎𝑟 𝑒𝑙 𝑏𝑢𝑓𝑓𝑒𝑟 𝑑𝑒 𝑒𝑛𝑡𝑟𝑎𝑑𝑎 𝑐𝑖𝑛.𝑐𝑙𝑒𝑎𝑟(); 𝑐𝑖𝑛.𝑖𝑔𝑛𝑜𝑟𝑒(
𝑏𝑟𝑒𝑉𝑎𝑙𝑖𝑑𝑜(𝑛𝑜𝑚𝑏𝑟𝑒𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒)) { 𝑛𝑜𝑚𝑏𝑟𝑒𝑉𝑎𝑙𝑖𝑑𝑜 = 𝑡𝑟𝑢𝑒; } 𝑒𝑙𝑠𝑒 { 𝑐𝑜𝑢𝑡 << "𝑁𝑜𝑚𝑏𝑟𝑒 𝑛𝑜 𝑣𝑎𝑙𝑖𝑑𝑜. 𝑆𝑜𝑙𝑜 𝑠𝑒 𝑝𝑒𝑟𝑚𝑖𝑡𝑒𝑛 𝑙𝑒𝑡𝑟𝑎
𝑔𝑒𝑡𝑙𝑖𝑛𝑒(𝑐𝑖𝑛, 𝑛𝑢𝑒𝑣𝑜𝑅𝑒𝑔𝑖𝑠𝑡𝑟𝑜.𝑡𝑟𝑎𝑡𝑎𝑚𝑖𝑒𝑛𝑡𝑜); 𝑎𝑔𝑟𝑒𝑔𝑎𝑟𝑅𝑒𝑔𝑖𝑠𝑡𝑟𝑜𝐻𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙(𝑛𝑜𝑚𝑏𝑟𝑒𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒, 𝑛𝑢𝑒𝑣𝑜𝑅𝑒𝑔𝑖𝑠𝑡𝑟𝑜); 𝑐𝑜𝑢
𝑢𝑡 << "𝑁𝑜 𝑠𝑒 𝑒𝑛𝑐𝑜𝑛𝑡𝑟𝑜 ℎ𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙 𝑚𝑒𝑑𝑖𝑐𝑜 𝑝𝑎𝑟𝑎 " << 𝑛𝑜𝑚𝑏𝑟𝑒𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒 << 𝑒𝑛𝑑𝑙; } 𝑏𝑟𝑒𝑎𝑘; } 𝑐𝑎𝑠𝑒 3:
𝑢𝑎𝑟𝑖𝑜𝑠 𝑝𝑟𝑒𝑑𝑒𝑡𝑒𝑟𝑚𝑖𝑛𝑎𝑑𝑜𝑠 𝑎𝑔𝑟𝑒𝑔𝑎𝑟𝑈𝑠𝑢𝑎𝑟𝑖𝑜(𝑙𝑖𝑠𝑡𝑎𝑀𝑒𝑑𝑖𝑐𝑜𝑠, "𝑚𝑒𝑑𝑖𝑐𝑜", "𝐴𝑛𝑎", "123456"); 𝑎𝑔𝑟𝑒𝑔𝑎𝑟𝑈𝑠𝑢𝑎𝑟𝑖𝑜(𝑙𝑖𝑠𝑡𝑎𝐸𝑛𝑓𝑒𝑟𝑚𝑒𝑟𝑎𝑠, "𝑒𝑛
 Tabla 3
Distribución de personas según el nivel de satisfacción con los productos recibidos anteriormente
Distribución de personas según su nivel de satisfacción con los productos recibidos anteriormente
Niveles de satisfacción fi hi pi
Muy satisfecho 28 0.16 15.56%
Satisfecho 120 0.67 66.67%
Neutral 28 0.16 15.56%
Insatisfecho 0 0.00 0.00%
Muy insatisfecho 4 0.02 2.22%
Total general 180 1.00 100%
Fuente: Inti S.A.C.

Tabla 4
Interpretación de la distribución de personas según el nivel de satisfacción con los productos recibidos anteriormente
𝑓_2=120 De las 180 personas, 120 se sienten satisfechas con los productos recibidos anteriormente de sus
ℎ_3=0.16 0.16 es la proporción de personas que se sienten neutrales con los productos recibidos de sus com
𝑃_5=2.22 2.22% de las personas se sienten muy insatisfechos con los productos recibidos anteriormente de
Fuente: Elaboración propia

Figura 2
Distribución porcentual de personas según el nivel de satisfacción con los productos recibidos anteriormente

Distribución de personas según porcentaje su nivel de satisfacción

con los productos recibidos
70.00% 66.67%

60.00%
Porcentaje de Personas

50.00%

40.00%

30.00%

20.00% 15.56% 15.56%

10.00%
2.22%
0.00%
0.00%
Muy satisfecho Satisfecho Neutral Insatisfecho Muy insatisfecho

Niveles de satisfación

Fuente: Inti S.A.C.

Se observa que el 15.56% de las personas se encuentran muy satisfechas con los productos recibidos anteriormente de sus com
en línea y un 66.67%, están satisfechas. Asimismo, un 15.56% de las personas se sienten neutrales, 0% de las personas se
encuentran insatisfechas y 2.22% de las personas están muy insatisfechas. Esto indica que la mayoría de las personas tienen un
de satisfacción positivo con los productos recibidos.
 Se observa que el 15.56% de las personas se encuentran muy satisfechas con los productos recibidos anteriormente de sus com
en línea y un 66.67%, están satisfechas. Asimismo, un 15.56% de las personas se sienten neutrales, 0% de las personas se
encuentran insatisfechas y 2.22% de las personas están muy insatisfechas. Esto indica que la mayoría de las personas tienen un
de satisfacción positivo con los productos recibidos.

𝑐𝑜𝑙𝑎𝑠#𝑖𝑛𝑐𝑙𝑢𝑑𝑒 <𝑠𝑡𝑎𝑐𝑘> // 𝑃𝑎𝑟𝑎 𝑝𝑖𝑙𝑎𝑠𝑢𝑠𝑖𝑛𝑔 𝑛𝑎𝑚𝑒𝑠𝑝𝑎𝑐𝑒 𝑠𝑡𝑑;// 𝐸𝑠𝑡𝑟𝑢𝑐𝑡𝑢𝑟𝑎 𝑝𝑎𝑟𝑎 𝑎𝑙𝑚𝑎𝑐𝑒𝑛𝑎𝑟 𝑙𝑜𝑠 𝑑𝑎𝑡𝑜𝑠 𝑑𝑒 𝑙𝑜𝑠 𝑢𝑠𝑢𝑎𝑟𝑖𝑜𝑠𝑠𝑡𝑟𝑢𝑐𝑡 𝑈𝑠𝑢
𝑡ℎ()) 𝑟𝑒𝑡𝑢𝑟𝑛 𝑡𝑟𝑢𝑒; 𝑖𝑓 (!𝑖𝑠𝑎𝑙𝑝ℎ𝑎(𝑠𝑡𝑟[𝑖𝑛𝑑𝑒𝑥]) && 𝑠𝑡𝑟[𝑖𝑛𝑑𝑒𝑥] != ′ ′) 𝑟𝑒𝑡𝑢𝑟𝑛 𝑓𝑎𝑙𝑠𝑒; 𝑟𝑒𝑡𝑢𝑟𝑛 𝑒𝑠𝑆𝑜𝑙𝑜𝐿𝑒𝑡𝑟𝑎𝑠𝑌𝐸𝑠𝑝𝑎𝑐𝑖𝑜𝑠(𝑠𝑡𝑟, 𝑖𝑛𝑑𝑒𝑥 + 1);}
𝐹𝑢𝑛𝑐𝑖𝑜𝑛 𝑝𝑎𝑟𝑎 𝑚𝑎𝑛𝑒𝑗𝑎𝑟 𝑙𝑎 𝑎𝑠𝑖𝑔𝑛𝑎𝑐𝑖𝑜𝑛 𝑑𝑒 𝑟𝑒𝑐𝑒𝑡𝑎𝑠𝑣𝑜𝑖𝑑 𝑎𝑠𝑖𝑔𝑛𝑎𝑟𝑅𝑒𝑐𝑒𝑡𝑎(𝑣𝑒𝑐𝑡𝑜𝑟<𝑅𝑒𝑐𝑒𝑡𝑎>& 𝑟𝑒𝑐𝑒𝑡𝑎𝑠) { 𝑅𝑒𝑐𝑒𝑡𝑎 𝑛𝑢𝑒𝑣𝑎𝑅𝑒𝑐𝑒𝑡𝑎; 𝑏𝑜𝑜𝑙
𝑤ℎ𝑖𝑙𝑒 (!𝑒𝑛𝑡𝑟𝑎𝑑𝑎𝑉𝑎𝑙𝑖𝑑𝑎); // 𝑉𝑎𝑙𝑖𝑑𝑎𝑟 𝑚𝑒𝑑𝑖𝑐𝑎𝑚𝑒𝑛𝑡𝑜 𝑑𝑜 { 𝑐𝑜𝑢𝑡 << "𝐼𝑛𝑔𝑟𝑒𝑠𝑒 𝑚𝑒𝑑𝑖𝑐𝑎𝑚𝑒𝑛𝑡𝑜: "; 𝑔𝑒𝑡𝑙𝑖𝑛𝑒(𝑐𝑖𝑛, 𝑛𝑢𝑒𝑣𝑎𝑅𝑒𝑐𝑒𝑡𝑎.𝑚𝑒
𝑉𝑎𝑙𝑖𝑑𝑎) { 𝑐𝑜𝑢𝑡 << "𝐷𝑜𝑠𝑖𝑠 𝑖𝑛𝑐𝑜𝑟𝑟𝑒𝑐𝑡𝑎. 𝑆𝑜𝑙𝑜 𝑠𝑒 𝑝𝑒𝑟𝑚𝑖𝑡𝑒𝑛 𝑙𝑒𝑡𝑟𝑎𝑠, 𝑛𝑢𝑚𝑒𝑟𝑜𝑠 𝑦 𝑒𝑠𝑝𝑎𝑐𝑖𝑜𝑠. 𝑉𝑢𝑒𝑙𝑣𝑎 𝑎 𝑖𝑛𝑔𝑟𝑒𝑠𝑎𝑟." << 𝑒𝑛𝑑𝑙; } }𝑤
; 𝑐𝑖𝑛.𝑖𝑔𝑛𝑜𝑟𝑒(); // 𝐿𝑖𝑚𝑝𝑖𝑎𝑟 𝑒𝑙 𝑏𝑢𝑓𝑓𝑒𝑟 𝑑𝑒 𝑒𝑛𝑡𝑟𝑎𝑑𝑎 } } 𝑤ℎ𝑖𝑙𝑒 (!𝑒𝑛𝑡𝑟𝑎𝑑𝑎𝑉𝑎𝑙𝑖𝑑𝑎); // 𝑉𝑎𝑙𝑖𝑑𝑎𝑟 𝑐𝑎𝑑𝑎 𝑐𝑢𝑎𝑛𝑡𝑎𝑠 ℎ𝑜𝑟𝑎𝑠 𝑑𝑒𝑏𝑒 𝑡𝑜𝑚
𝑒(); // 𝐿𝑖𝑚𝑝𝑖𝑎𝑟 𝑒𝑙 𝑏𝑢𝑓𝑓𝑒𝑟 𝑑𝑒 𝑒𝑛𝑡𝑟𝑎𝑑𝑎 } } 𝑤ℎ𝑖𝑙𝑒 (!𝑒𝑛𝑡𝑟𝑎𝑑𝑎𝑉𝑎𝑙𝑖𝑑𝑎); 𝑟𝑒𝑐𝑒𝑡𝑎𝑠.𝑝𝑢𝑠ℎ_𝑏𝑎𝑐𝑘(𝑛𝑢𝑒𝑣𝑎𝑅𝑒𝑐𝑒𝑡𝑎); 𝑐𝑜𝑢𝑡 << "𝑅𝑒𝑐𝑒𝑡𝑎 𝑎𝑠𝑖
𝑙𝑜𝑎𝑡 𝑡𝑒𝑚𝑝𝑒𝑟𝑎𝑡𝑢𝑟𝑎; 𝑓𝑙𝑜𝑎𝑡 𝑝𝑟𝑒𝑠𝑖𝑜𝑛; 𝑓𝑙𝑜𝑎𝑡 𝑠𝑎𝑡𝑢𝑟𝑎𝑐𝑖𝑜𝑛; // 𝐴𝑠𝑖𝑔𝑛𝑎𝑐𝑖𝑜𝑛𝑒𝑠 𝑖𝑛𝑡 𝑒𝑠𝑝𝑒𝑐𝑖𝑎𝑙𝑖𝑑𝑎𝑑𝐴𝑠𝑖𝑔𝑛𝑎𝑑𝑎; 𝑠𝑡𝑟𝑖𝑛𝑔 𝑚𝑒𝑑𝑖𝑐𝑜𝐴𝑠𝑖𝑔𝑛𝑎
𝑒𝑙𝑢𝑙𝑎𝑟, 𝑖𝑛𝑡 𝑖𝑛𝑑𝑒𝑥 = 0) { // 𝑆𝑒 𝑎𝑠𝑢𝑚𝑒 𝑞𝑢𝑒 𝑢𝑛 𝑛𝑢𝑚𝑒𝑟𝑜 𝑑𝑒 𝑡𝑒𝑙𝑒𝑓𝑜𝑛𝑜 𝑣𝑎𝑙𝑖𝑑𝑜 𝑡𝑖𝑒𝑛𝑒 9 𝑑𝑖𝑔𝑖𝑡𝑜𝑠 𝑖𝑓 (𝑐𝑒𝑙𝑢𝑙𝑎𝑟.𝑙𝑒𝑛𝑔𝑡ℎ() != 9) 𝑟𝑒𝑡𝑢𝑟𝑛 𝑓𝑎𝑙𝑠𝑒
𝑟𝑒, 𝑖𝑛𝑑𝑒𝑥 + 1);}// 𝐹𝑢𝑛𝑐𝑖𝑜𝑛 𝑝𝑎𝑟𝑎 𝑣𝑎𝑙𝑖𝑑𝑎𝑟 𝑠𝑖 𝑒𝑙 𝑔𝑒𝑛𝑒𝑟𝑜 𝑖𝑛𝑔𝑟𝑒𝑠𝑎𝑑𝑜 𝑒𝑠 𝑣𝑎𝑙𝑖𝑑𝑜 (𝑀 𝑜 𝐹)𝑏𝑜𝑜𝑙 𝑒𝑠𝐺𝑒𝑛𝑒𝑟𝑜𝑉𝑎𝑙𝑖𝑑𝑜(𝑐ℎ𝑎𝑟 𝑔𝑒𝑛𝑒𝑟𝑜) { 𝑟𝑒𝑡𝑢𝑟𝑛 𝑔
𝑖𝑒𝑛𝑡𝑒& 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒) { 𝑐𝑜𝑢𝑡 << "𝑅𝑒𝑔𝑖𝑠𝑡𝑟𝑎𝑛𝑑𝑜 𝑑𝑎𝑡𝑜𝑠 𝑑𝑒𝑙 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒..." << 𝑒𝑛𝑑𝑙; // 𝐼𝑛𝑔𝑟𝑒𝑠𝑎𝑟 𝑒𝑙 𝑛𝑜𝑚𝑏𝑟𝑒 𝑐𝑜𝑢𝑡 << "𝑁𝑜𝑚𝑏𝑟𝑒: "; 𝑐𝑖𝑛.𝑖
𝑎𝑏𝑒𝑡𝑖𝑐𝑜𝑠." << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "𝐴𝑝𝑒𝑙𝑙𝑖𝑑𝑜: "; 𝑔𝑒𝑡𝑙𝑖𝑛𝑒(𝑐𝑖𝑛, 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑎𝑝𝑒𝑙𝑙𝑖𝑑𝑜); } // 𝐼𝑛𝑔𝑟𝑒𝑠𝑎 𝑙𝑎 𝑓𝑒𝑐ℎ𝑎 𝑑𝑒 𝑛𝑎𝑐𝑖𝑚𝑖𝑒𝑛𝑡𝑜 𝑐𝑜𝑢𝑡 <<
>> 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑒𝑠𝑡𝑎𝑑𝑜𝐶𝑖𝑣𝑖𝑙; 𝑖𝑓 (!𝑒𝑠𝐸𝑠𝑡𝑎𝑑𝑜𝐶𝑖𝑣𝑖𝑙𝑉𝑎𝑙𝑖𝑑𝑜(𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑒𝑠𝑡𝑎𝑑𝑜𝐶𝑖𝑣𝑖𝑙)) { 𝑐𝑜𝑢𝑡 << "𝐸𝑠𝑡𝑎𝑑𝑜 𝑐𝑖𝑣𝑖𝑙 𝑛𝑜 𝑣𝑎𝑙𝑖𝑑𝑜. 𝑃𝑜𝑟 𝑓𝑎𝑣𝑜
(𝑐𝑖𝑛, 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑑𝑖𝑟𝑒𝑐𝑐𝑖𝑜𝑛); // 𝐼𝑛𝑔𝑟𝑒𝑠𝑎 𝑒𝑙 𝑛𝑢𝑚𝑒𝑟𝑜 𝑑𝑒 𝑐𝑒𝑙𝑢𝑙𝑎𝑟 𝑑𝑜 { 𝑐𝑜𝑢𝑡 << "𝐶𝑒𝑙𝑢𝑙𝑎𝑟 (9 𝑑𝑖𝑔𝑖𝑡𝑜𝑠): "; 𝑐𝑖𝑛 >> 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑐𝑒𝑙𝑢𝑙𝑎
𝑐𝑜𝑢𝑡 << "2. 𝐴𝑝𝑒𝑙𝑙𝑖𝑑𝑜" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "3. 𝐹𝑒𝑐ℎ𝑎 𝑑𝑒 𝑛𝑎𝑐𝑖𝑚𝑖𝑒𝑛𝑡𝑜" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "4. 𝐺𝑒𝑛𝑒𝑟𝑜" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "5
𝑐𝑜𝑢𝑡 << "𝑁𝑜𝑚𝑏𝑟𝑒 𝑛𝑜 𝑣𝑎𝑙𝑖𝑑𝑜. 𝑃𝑜𝑟 𝑓𝑎𝑣𝑜𝑟, 𝑖𝑛𝑔𝑟𝑒𝑠𝑒 𝑠𝑜𝑙𝑜 𝑐𝑎𝑟𝑎𝑐𝑡𝑒𝑟𝑒𝑠 𝑎𝑙𝑓𝑎𝑏𝑒𝑡𝑖𝑐𝑜𝑠." << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "𝑁𝑢𝑒𝑣𝑜 𝑛𝑜𝑚𝑏𝑟𝑒
𝑏𝑟𝑒𝑎𝑘; 𝑐𝑎𝑠𝑒 3: 𝑐𝑜𝑢𝑡 << "𝑁𝑢𝑒𝑣𝑎 𝑓𝑒𝑐ℎ𝑎 𝑑𝑒 𝑛𝑎𝑐𝑖𝑚𝑖𝑒𝑛𝑡𝑜 (𝑓𝑜𝑟𝑚𝑎𝑡𝑜 𝑑𝑑/𝑚𝑚/𝑎𝑎𝑎𝑎): "; 𝑐𝑖𝑛 >> 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑓𝑒
} } 𝑤ℎ𝑖𝑙𝑒 (!𝑒𝑠𝐺𝑒𝑛𝑒𝑟𝑜𝑉𝑎𝑙𝑖𝑑𝑜(𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑔𝑒𝑛𝑒𝑟𝑜)); 𝑏𝑟𝑒𝑎𝑘; 𝑐𝑎𝑠𝑒 5: 𝑐𝑜𝑢𝑡 << "𝑁𝑢𝑒𝑣𝑜 𝑒𝑠𝑡𝑎𝑑𝑜 𝑐𝑖𝑣𝑖𝑙 (𝑆
𝑖𝑓 (!𝑒𝑠𝐷𝑛𝑖𝑉𝑎𝑙𝑖𝑑𝑜(𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑑𝑛𝑖)) { 𝑐𝑜𝑢𝑡 << "𝐷𝑁𝐼 𝑛𝑜 𝑣𝑎𝑙𝑖𝑑𝑜. 𝐼𝑛𝑡𝑒𝑛𝑡𝑒 𝑛𝑢𝑒𝑣𝑎𝑚𝑒𝑛𝑡𝑒." << 𝑒𝑛𝑑𝑙; } }
𝐶𝑒𝑙𝑢𝑙𝑎𝑟𝑉𝑎𝑙𝑖𝑑𝑜(𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑐𝑒𝑙𝑢𝑙𝑎𝑟)); 𝑏𝑟𝑒𝑎𝑘; 𝑐𝑎𝑠𝑒 9: 𝑐𝑜𝑢𝑡 << "𝑁𝑢𝑒𝑣𝑜 𝑐𝑜𝑟𝑟𝑒𝑜 𝑒𝑙𝑒𝑐𝑡𝑟𝑜𝑛𝑖𝑐𝑜: "; 𝑐𝑖𝑛 >> 𝑝𝑎𝑐𝑖𝑒
𝑑𝑒𝑙 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒 𝑑𝑜 { 𝑐𝑜𝑢𝑡 << "𝐼𝑛𝑔𝑟𝑒𝑠𝑒 𝑒𝑙 𝑛𝑜𝑚𝑏𝑟𝑒 𝑑𝑒𝑙 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒: "; 𝑔𝑒𝑡𝑙𝑖𝑛𝑒(𝑐𝑖𝑛, 𝑛𝑜𝑚𝑏𝑟𝑒𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒); 𝑖𝑓 (!𝑒𝑠𝑁𝑜𝑚𝑏𝑟𝑒𝑉𝑎𝑙𝑖𝑑𝑜(
𝑛𝑢𝑚𝑒𝑟𝑜 𝑝𝑎𝑟𝑎 𝑒𝑙 𝑝𝑒𝑠𝑜: "; } 𝑐𝑜𝑢𝑡 << "𝑇𝑎𝑙𝑙𝑎 (𝑚): "; 𝑤ℎ𝑖𝑙𝑒 (!(𝑐𝑖𝑛 >> 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑡𝑎𝑙𝑙𝑎)) { 𝑐𝑖𝑛.𝑐𝑙𝑒𝑎𝑟(); 𝑐𝑖𝑛.𝑖𝑔𝑛𝑜𝑟𝑒(𝑛𝑢𝑚𝑒𝑟𝑖𝑐_𝑙𝑖
𝑖𝑛.𝑖𝑔𝑛𝑜𝑟𝑒(𝑛𝑢𝑚𝑒𝑟𝑖𝑐_𝑙𝑖𝑚𝑖𝑡𝑠<𝑠𝑡𝑟𝑒𝑎𝑚𝑠𝑖𝑧𝑒>::𝑚𝑎𝑥(), ′\𝑛′); 𝑐𝑜𝑢𝑡 << "𝐸𝑛𝑡𝑟𝑎𝑑𝑎 𝑛𝑜 𝑣𝑎𝑙𝑖𝑑𝑎. 𝑃𝑜𝑟 𝑓𝑎𝑣𝑜𝑟, 𝑖𝑛𝑔𝑟𝑒𝑠𝑒 𝑢𝑛 𝑛𝑢𝑚𝑒𝑟𝑜 𝑝𝑎𝑟𝑎 𝑙𝑎 𝑝
𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "| " << 𝑙𝑒𝑓𝑡 << 𝑠𝑒𝑡𝑤(𝑎𝑛𝑐ℎ𝑜 − 8) << "𝐷𝑎𝑡𝑜𝑠 𝑑𝑒 𝑡𝑟𝑖𝑎𝑗𝑒 𝑑𝑒𝑙 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒:" << " |" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << 𝑠𝑡𝑟𝑖𝑛𝑔(𝑎𝑛𝑐ℎ𝑜, ′−
" << 𝑙𝑒𝑓𝑡 << 𝑠𝑒𝑡𝑤(𝑎𝑛𝑐ℎ𝑜 − 31) << 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑠𝑎𝑡𝑢𝑟𝑎𝑐𝑖𝑜𝑛 << " |" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << 𝑠𝑡𝑟𝑖𝑛𝑔(𝑎𝑛𝑐ℎ𝑜, ′−′) << 𝑒𝑛𝑑𝑙;}// 𝐹𝑢𝑛𝑐𝑖𝑜𝑛 𝑝𝑎
12) << 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑎𝑝𝑒𝑙𝑙𝑖𝑑𝑜 << " |" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "| 𝐹𝑒𝑐ℎ𝑎 𝑑𝑒 𝑛𝑎𝑐𝑖𝑚𝑖𝑒𝑛𝑡𝑜: " << 𝑙𝑒𝑓𝑡 << 𝑠𝑒𝑡𝑤(𝑎𝑛𝑐ℎ𝑜 − 26) << 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑓𝑒𝑐ℎ
𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑐𝑒𝑙𝑢𝑙𝑎𝑟 << " |" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "| 𝐶𝑜𝑟𝑟𝑒𝑜 𝑒𝑙𝑒𝑐𝑡𝑟𝑜𝑛𝑖𝑐𝑜: " << 𝑙𝑒𝑓𝑡 << 𝑠𝑒𝑡𝑤(𝑎𝑛𝑐ℎ𝑜 − 24) << 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑐𝑜𝑟𝑟𝑒𝑜 << " |" <
𝑒𝑙 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒: "; 𝑔𝑒𝑡𝑙𝑖𝑛𝑒(𝑐𝑖𝑛, 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑛𝑜𝑚𝑏𝑟𝑒); } 𝑐𝑜𝑢𝑡 << "𝐸𝑠𝑝𝑒𝑐𝑖𝑎𝑙𝑖𝑑𝑎𝑑𝑒𝑠 𝑑𝑖𝑠𝑝𝑜𝑛𝑖𝑏𝑙𝑒𝑠\𝑛"; 𝑐𝑜𝑢𝑡 << "1. 𝑀𝑒𝑑𝑖𝑐𝑖𝑛𝑎 𝑔𝑒𝑛𝑒𝑟𝑎
𝑎𝑑𝑎 = 𝑠𝑡𝑜𝑖(𝑖𝑛𝑝𝑢𝑡); 𝑖𝑓 (𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑒𝑠𝑝𝑒𝑐𝑖𝑎𝑙𝑖𝑑𝑎𝑑𝐴𝑠𝑖𝑔𝑛𝑎𝑑𝑎 >= 1 && 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑒𝑠𝑝𝑒𝑐𝑖𝑎𝑙𝑖𝑑𝑎𝑑𝐴𝑠𝑖𝑔𝑛𝑎𝑑𝑎 <= 10) { 𝑏𝑟𝑒𝑎𝑘;
𝑐𝑜𝑢𝑡 << "𝑁𝑢𝑚𝑒𝑟𝑜 𝑓𝑢𝑒𝑟𝑎 𝑑𝑒 𝑟𝑎𝑛𝑔𝑜. 𝑃𝑜𝑟 𝑓𝑎𝑣𝑜𝑟, 𝑖𝑛𝑔𝑟𝑒𝑠𝑒 𝑢𝑛 𝑛𝑢𝑚𝑒𝑟𝑜 𝑣𝑎𝑙𝑖𝑑𝑜 𝑑𝑒 𝑒𝑠𝑝𝑒𝑐𝑖𝑎𝑙𝑖𝑑𝑎𝑑." << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "𝐼𝑛𝑔𝑟𝑒
𝑒.𝑚𝑒𝑑𝑖𝑐𝑜𝐴𝑠𝑖𝑔𝑛𝑎𝑑𝑜); } 𝑐𝑜𝑢𝑡 << "𝐸𝑠𝑝𝑒𝑐𝑖𝑎𝑙𝑖𝑑𝑎𝑑 𝑦 𝑚𝑒𝑑𝑖𝑐𝑜 𝑎𝑠𝑖𝑔𝑛𝑎𝑑𝑜𝑠 𝑐𝑜𝑛 𝑒𝑥𝑖𝑡𝑜." << 𝑒𝑛𝑑𝑙;}// 𝐹𝑢𝑛𝑐𝑖𝑜𝑛 𝑝𝑎𝑟𝑎 𝑎𝑠𝑖𝑔𝑛𝑎𝑟 𝑢𝑛 𝑙𝑢𝑔𝑎𝑟 𝑒𝑛
𝑐𝑜𝑢𝑡 << "𝑁𝑖𝑣𝑒𝑙𝑒𝑠 𝑑𝑒 𝑢𝑟𝑔𝑒𝑛𝑐𝑖𝑎\𝑛" << "1. 𝑅𝑒𝑠𝑢𝑐𝑖𝑡𝑎𝑐𝑖𝑜𝑛\𝑛" << "2. 𝐸𝑚𝑒𝑟𝑔𝑒𝑛𝑐𝑖𝑎\𝑛" << "3. 𝑈𝑟𝑔𝑒𝑛𝑐𝑖𝑎\𝑛" << "4
𝑐𝑖𝑎; } 𝑎𝑢𝑡𝑜 𝑖𝑡 = 𝑓𝑖𝑛𝑑_𝑖𝑓(𝑙𝑖𝑠𝑡𝑎𝐸𝑠𝑝𝑒𝑟𝑎.𝑏𝑒𝑔𝑖𝑛(), 𝑙𝑖𝑠𝑡𝑎𝐸𝑠𝑝𝑒𝑟𝑎.𝑒𝑛𝑑(), [&𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒](𝑐𝑜𝑛𝑠𝑡 𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒 &𝑝) { 𝑟𝑒𝑡𝑢𝑟𝑛 𝑝.𝑛𝑖𝑣𝑒𝑙𝑈𝑟𝑔𝑒𝑛𝑐𝑖𝑎
𝑜(𝑛𝑜𝑚𝑏𝑟𝑒)) { 𝑐𝑜𝑢𝑡 << "𝑁𝑜𝑚𝑏𝑟𝑒 𝑛𝑜 𝑣𝑎𝑙𝑖𝑑𝑜. 𝐼𝑛𝑔𝑟𝑒𝑠𝑒 𝑠𝑜𝑙𝑜 𝑐𝑎𝑟𝑎𝑐𝑡𝑒𝑟𝑒𝑠 𝑎𝑙𝑓𝑎𝑏𝑒𝑡𝑖𝑐𝑜𝑠." << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "𝐼𝑛𝑔𝑟𝑒𝑠𝑒 𝑒𝑙 𝑛𝑜𝑚𝑏𝑟𝑒 𝑑

𝑤 𝑈𝑠𝑢𝑎𝑟𝑖𝑜; 𝑛𝑢𝑒𝑣𝑜−>𝑡𝑖𝑝𝑜 = 𝑡𝑖𝑝𝑜; 𝑛𝑢𝑒𝑣𝑜−>𝑛𝑜𝑚𝑏𝑟𝑒 = 𝑛𝑜𝑚𝑏𝑟𝑒; 𝑛𝑢𝑒𝑣𝑜−>𝑐𝑜𝑛𝑡𝑟𝑎𝑠𝑒𝑛𝑎 = 𝑐𝑜𝑛𝑡𝑟𝑎𝑠𝑒𝑛𝑎; 𝑛𝑢𝑒𝑣𝑜−>𝑠𝑖𝑔𝑢𝑖𝑒𝑛𝑡𝑒 = 𝑛𝑢

𝑠𝑡𝑟𝑒𝑎𝑚𝑠𝑖𝑧𝑒>::𝑚𝑎𝑥(), ′\𝑛′); // 𝐿𝑖𝑚𝑝𝑖𝑎𝑟 𝑒𝑙 𝑏𝑢𝑓𝑓𝑒𝑟 𝑑𝑒𝑙 𝑡𝑒𝑐𝑙𝑎𝑑𝑜 𝑐𝑜𝑢𝑡 << "𝐼𝑛𝑔𝑟𝑒𝑠𝑒 𝑐𝑜𝑛𝑡𝑟𝑎𝑠𝑒ñ𝑎 (𝑑𝑒𝑏𝑒 𝑡𝑒𝑛𝑒𝑟 𝑎𝑙 𝑚𝑒𝑛𝑜𝑠 6 𝑐𝑎𝑟𝑎𝑐𝑡𝑒𝑟𝑒𝑠)
𝑟𝑒𝑡𝑢𝑟𝑛 𝑡𝑟𝑢𝑒; } 𝑎𝑐𝑡𝑢𝑎𝑙 = 𝑎𝑐𝑡𝑢𝑎𝑙−>𝑠𝑖𝑔𝑢𝑖𝑒𝑛𝑡𝑒; } 𝑟𝑒𝑡𝑢𝑟𝑛 𝑓𝑎𝑙𝑠𝑒;}// 𝐹𝑢𝑛𝑐𝑖𝑜𝑛 𝑝𝑎𝑟𝑎 𝑙𝑖𝑏𝑒𝑟𝑎𝑟 𝑚𝑒𝑚𝑜𝑟𝑖𝑎 𝑑𝑒 𝑙𝑎 𝑙𝑖𝑠𝑡𝑎 𝑑𝑒 𝑢𝑠𝑢𝑎
𝑟𝑎) { 𝑖𝑛𝑡 𝑜𝑝𝑐𝑖𝑜𝑛; 𝑑𝑜 { 𝑐𝑜𝑢𝑡 << "\𝑛𝑀𝑒𝑛𝑢 𝑑𝑒 𝑝𝑒𝑟𝑠𝑜𝑛𝑎𝑙 𝑑𝑒 𝑒𝑛𝑓𝑒𝑟𝑚𝑒𝑟𝑖𝑎" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "1. 𝑅𝑒𝑔𝑖𝑠𝑡𝑟𝑎𝑟 𝑑𝑎𝑡𝑜𝑠 𝑑𝑒𝑙 𝑝𝑎𝑐𝑖𝑒𝑛
𝑔𝑖𝑠𝑡𝑟𝑎𝑟𝐷𝑎𝑡𝑜𝑠𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒(𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒); 𝑏𝑟𝑒𝑎𝑘; 𝑐𝑎𝑠𝑒 2: 𝑐𝑜𝑢𝑡 << "𝑅𝑒𝑔𝑖𝑠𝑡𝑟𝑜 𝑑𝑒 𝑡𝑟𝑖𝑎𝑗𝑒..." << 𝑒𝑛𝑑𝑙; 𝑟𝑒𝑔𝑖𝑠𝑡𝑟𝑎𝑟𝑇
𝑒); 𝑏𝑟𝑒𝑎𝑘; 𝑐𝑎𝑠𝑒 6: 𝑐𝑜𝑢𝑡 << "𝐴𝑐𝑡𝑢𝑎𝑙𝑖𝑧𝑎𝑛𝑑𝑜 𝑙𝑖𝑠𝑡𝑎 𝑑𝑒 𝑒𝑠𝑝𝑒𝑟𝑎 𝑑𝑒𝑝𝑒𝑛𝑑𝑖𝑒𝑛𝑑𝑜 𝑠𝑢 𝑛𝑖𝑣𝑒𝑙 𝑑𝑒 𝑒𝑚𝑒𝑟𝑔𝑒𝑛𝑐𝑖𝑎..." << 𝑒𝑛𝑑𝑙;
𝑡𝑟𝑎𝑟𝑀𝑒𝑛𝑢𝐼𝑛𝑔𝑟𝑒𝑠𝑜(𝑈𝑠𝑢𝑎𝑟𝑖𝑜∗& 𝑙𝑖𝑠𝑡𝑎𝑀𝑒𝑑𝑖𝑐𝑜𝑠, 𝑈𝑠𝑢𝑎𝑟𝑖𝑜∗& 𝑙𝑖𝑠𝑡𝑎𝐸𝑛𝑓𝑒𝑟𝑚𝑒𝑟𝑎𝑠, 𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒& 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒) { 𝑖𝑛𝑡 𝑜𝑝𝑐𝑖𝑜𝑛; 𝑣𝑒𝑐𝑡𝑜𝑟<𝑅𝑒𝑐𝑒𝑡𝑎>
𝑛 >> 𝑜𝑝𝑐𝑖𝑜𝑛; 𝑖𝑓 (𝑐𝑖𝑛.𝑓𝑎𝑖𝑙()) { // 𝐿𝑖𝑚𝑝𝑖𝑎𝑟 𝑒𝑙 𝑏𝑢𝑓𝑓𝑒𝑟 𝑑𝑒 𝑒𝑛𝑡𝑟𝑎𝑑𝑎 𝑐𝑖𝑛.𝑐𝑙𝑒𝑎𝑟(); 𝑐𝑖𝑛.𝑖𝑔𝑛𝑜𝑟𝑒(𝑛𝑢𝑚𝑒𝑟𝑖𝑐_𝑙𝑖𝑚𝑖𝑡𝑠<𝑠𝑡𝑟𝑒𝑎
 𝑜(𝑛𝑜𝑚𝑏𝑟𝑒)) { 𝑐𝑜𝑢𝑡 << "𝑁𝑜𝑚𝑏𝑟𝑒 𝑛𝑜 𝑣𝑎𝑙𝑖𝑑𝑜. 𝐼𝑛𝑔𝑟𝑒𝑠𝑒 𝑠𝑜𝑙𝑜 𝑐𝑎𝑟𝑎𝑐𝑡𝑒𝑟𝑒𝑠 𝑎𝑙𝑓𝑎𝑏𝑒𝑡𝑖𝑐𝑜𝑠." << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "𝐼𝑛𝑔𝑟𝑒𝑠𝑒 𝑒𝑙 𝑛𝑜𝑚𝑏𝑟𝑒 𝑑
𝑤 𝑈𝑠𝑢𝑎𝑟𝑖𝑜; 𝑛𝑢𝑒𝑣𝑜−>𝑡𝑖𝑝𝑜 = 𝑡𝑖𝑝𝑜; 𝑛𝑢𝑒𝑣𝑜−>𝑛𝑜𝑚𝑏𝑟𝑒 = 𝑛𝑜𝑚𝑏𝑟𝑒; 𝑛𝑢𝑒𝑣𝑜−>𝑐𝑜𝑛𝑡𝑟𝑎𝑠𝑒𝑛𝑎 = 𝑐𝑜𝑛𝑡𝑟𝑎𝑠𝑒𝑛𝑎; 𝑛𝑢𝑒𝑣𝑜−>𝑠𝑖𝑔𝑢𝑖𝑒𝑛𝑡𝑒 = 𝑛𝑢
𝑠𝑡𝑟𝑒𝑎𝑚𝑠𝑖𝑧𝑒>::𝑚𝑎𝑥(), ′\𝑛′); // 𝐿𝑖𝑚𝑝𝑖𝑎𝑟 𝑒𝑙 𝑏𝑢𝑓𝑓𝑒𝑟 𝑑𝑒𝑙 𝑡𝑒𝑐𝑙𝑎𝑑𝑜 𝑐𝑜𝑢𝑡 << "𝐼𝑛𝑔𝑟𝑒𝑠𝑒 𝑐𝑜𝑛𝑡𝑟𝑎𝑠𝑒ñ𝑎 (𝑑𝑒𝑏𝑒 𝑡𝑒𝑛𝑒𝑟 𝑎𝑙 𝑚𝑒𝑛𝑜𝑠 6 𝑐𝑎𝑟𝑎𝑐𝑡𝑒𝑟𝑒𝑠)
𝑟𝑒𝑡𝑢𝑟𝑛 𝑡𝑟𝑢𝑒; } 𝑎𝑐𝑡𝑢𝑎𝑙 = 𝑎𝑐𝑡𝑢𝑎𝑙−>𝑠𝑖𝑔𝑢𝑖𝑒𝑛𝑡𝑒; } 𝑟𝑒𝑡𝑢𝑟𝑛 𝑓𝑎𝑙𝑠𝑒;}// 𝐹𝑢𝑛𝑐𝑖𝑜𝑛 𝑝𝑎𝑟𝑎 𝑙𝑖𝑏𝑒𝑟𝑎𝑟 𝑚𝑒𝑚𝑜𝑟𝑖𝑎 𝑑𝑒 𝑙𝑎 𝑙𝑖𝑠𝑡𝑎 𝑑𝑒 𝑢𝑠𝑢𝑎
𝑟𝑎) { 𝑖𝑛𝑡 𝑜𝑝𝑐𝑖𝑜𝑛; 𝑑𝑜 { 𝑐𝑜𝑢𝑡 << "\𝑛𝑀𝑒𝑛𝑢 𝑑𝑒 𝑝𝑒𝑟𝑠𝑜𝑛𝑎𝑙 𝑑𝑒 𝑒𝑛𝑓𝑒𝑟𝑚𝑒𝑟𝑖𝑎" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "1. 𝑅𝑒𝑔𝑖𝑠𝑡𝑟𝑎𝑟 𝑑𝑎𝑡𝑜𝑠 𝑑𝑒𝑙 𝑝𝑎𝑐𝑖𝑒𝑛
𝑔𝑖𝑠𝑡𝑟𝑎𝑟𝐷𝑎𝑡𝑜𝑠𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒(𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒); 𝑏𝑟𝑒𝑎𝑘; 𝑐𝑎𝑠𝑒 2: 𝑐𝑜𝑢𝑡 << "𝑅𝑒𝑔𝑖𝑠𝑡𝑟𝑜 𝑑𝑒 𝑡𝑟𝑖𝑎𝑗𝑒..." << 𝑒𝑛𝑑𝑙; 𝑟𝑒𝑔𝑖𝑠𝑡𝑟𝑎𝑟𝑇
𝑒); 𝑏𝑟𝑒𝑎𝑘; 𝑐𝑎𝑠𝑒 6: 𝑐𝑜𝑢𝑡 << "𝐴𝑐𝑡𝑢𝑎𝑙𝑖𝑧𝑎𝑛𝑑𝑜 𝑙𝑖𝑠𝑡𝑎 𝑑𝑒 𝑒𝑠𝑝𝑒𝑟𝑎 𝑑𝑒𝑝𝑒𝑛𝑑𝑖𝑒𝑛𝑑𝑜 𝑠𝑢 𝑛𝑖𝑣𝑒𝑙 𝑑𝑒 𝑒𝑚𝑒𝑟𝑔𝑒𝑛𝑐𝑖𝑎..." << 𝑒𝑛𝑑𝑙;
𝑡𝑟𝑎𝑟𝑀𝑒𝑛𝑢𝐼𝑛𝑔𝑟𝑒𝑠𝑜(𝑈𝑠𝑢𝑎𝑟𝑖𝑜∗& 𝑙𝑖𝑠𝑡𝑎𝑀𝑒𝑑𝑖𝑐𝑜𝑠, 𝑈𝑠𝑢𝑎𝑟𝑖𝑜∗& 𝑙𝑖𝑠𝑡𝑎𝐸𝑛𝑓𝑒𝑟𝑚𝑒𝑟𝑎𝑠, 𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒& 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒) { 𝑖𝑛𝑡 𝑜𝑝𝑐𝑖𝑜𝑛; 𝑣𝑒𝑐𝑡𝑜𝑟<𝑅𝑒𝑐𝑒𝑡𝑎>
𝑛 >> 𝑜𝑝𝑐𝑖𝑜𝑛; 𝑖𝑓 (𝑐𝑖𝑛.𝑓𝑎𝑖𝑙()) { // 𝐿𝑖𝑚𝑝𝑖𝑎𝑟 𝑒𝑙 𝑏𝑢𝑓𝑓𝑒𝑟 𝑑𝑒 𝑒𝑛𝑡𝑟𝑎𝑑𝑎 𝑐𝑖𝑛.𝑐𝑙𝑒𝑎𝑟(); 𝑐𝑖𝑛.𝑖𝑔𝑛𝑜𝑟𝑒(𝑛𝑢𝑚𝑒𝑟𝑖𝑐_𝑙𝑖𝑚𝑖𝑡𝑠<𝑠𝑡𝑟𝑒𝑎
𝑀𝑒𝑑𝑖𝑐𝑜(𝑟𝑒𝑐𝑒𝑡𝑎𝑠); 𝑐𝑟𝑒𝑑𝑒𝑛𝑐𝑖𝑎𝑙𝑒𝑠𝑉𝑎𝑙𝑖𝑑𝑎𝑠 = 𝑡𝑟𝑢𝑒; } 𝑒𝑙𝑠𝑒 { 𝑐𝑜𝑢𝑡 << "𝐶𝑟𝑒𝑑𝑒𝑛𝑐𝑖𝑎𝑙𝑒𝑠 𝑑𝑒 𝑚𝑒𝑑𝑖𝑐𝑜 𝑖𝑛𝑐𝑜𝑟𝑟
𝑟𝑎); 𝑐𝑟𝑒𝑑𝑒𝑛𝑐𝑖𝑎𝑙𝑒𝑠𝑉𝑎𝑙𝑖𝑑𝑎𝑠 = 𝑡𝑟𝑢𝑒; } 𝑒𝑙𝑠𝑒 { 𝑐𝑜𝑢𝑡 << "𝐶𝑟𝑒𝑑𝑒𝑛𝑐𝑖𝑎𝑙𝑒𝑠 𝑑𝑒 𝑒𝑛𝑓𝑒𝑟𝑚𝑒𝑟𝑜 𝑖𝑛𝑐𝑜𝑟𝑟𝑒𝑐𝑡𝑎𝑠. 𝐼𝑛𝑡𝑒
𝑟𝑒𝑔𝑎𝑟𝑈𝑠𝑢𝑎𝑟𝑖𝑜(𝑙𝑖𝑠𝑡𝑎𝐸𝑛𝑓𝑒𝑟𝑚𝑒𝑟𝑎𝑠, "𝑒𝑛𝑓𝑒𝑟𝑚𝑒𝑟𝑜", 𝑛𝑜𝑚𝑏𝑟𝑒, 𝑐𝑜𝑛𝑡𝑟𝑎𝑠𝑒𝑛𝑎); 𝑐𝑜𝑢𝑡 << "𝐸𝑛𝑓𝑒𝑟𝑚𝑒𝑟𝑎 𝑟𝑒𝑔𝑖𝑠𝑡𝑟𝑎𝑑𝑎 𝑐𝑜𝑛 𝑒𝑥𝑖𝑡𝑜" << 𝑒𝑛
𝑔, 𝑣𝑒𝑐𝑡𝑜𝑟<𝐻𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙𝑀𝑒𝑑𝑖𝑐𝑜>> ℎ𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙𝑃𝑜𝑟𝑁𝑜𝑚𝑏𝑟𝑒; // 𝑈𝑠𝑎𝑛𝑑𝑜 𝑒𝑙 𝑛𝑜𝑚𝑏𝑟𝑒 𝑐𝑜𝑚𝑜 𝑐𝑙𝑎𝑣𝑒// 𝐹𝑢𝑛𝑐𝑖𝑜𝑛 𝑝𝑎𝑟𝑎 𝑎𝑛𝑎𝑑𝑖𝑟 𝑢𝑛 𝑛𝑢𝑒𝑣𝑜 𝑟𝑒𝑔𝑖𝑠𝑡𝑟𝑜
𝑚𝑏𝑟𝑒[𝑛𝑜𝑚𝑏𝑟𝑒𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒]; } 𝑒𝑙𝑠𝑒 { 𝑟𝑒𝑡𝑢𝑟𝑛 {}; // 𝐻𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙 𝑛𝑜 𝑒𝑛𝑐𝑜𝑛𝑡𝑟𝑎𝑑𝑜 }}// 𝐹𝑢𝑛𝑐𝑖𝑜𝑛 𝑝𝑎𝑟𝑎 𝑚𝑜𝑠𝑡𝑟𝑎𝑟 𝑒𝑙 ℎ𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙 𝑚𝑒𝑑𝑖𝑐𝑜 𝑑𝑒 𝑢𝑛
𝑠𝑢𝑙𝑡𝑎: " << ℎ𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙[𝑖].𝑚𝑜𝑡𝑖𝑣𝑜𝐶𝑜𝑛𝑠𝑢𝑙𝑡𝑎 << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "𝐷𝑖𝑎𝑔𝑛𝑜𝑠𝑡𝑖𝑐𝑜: " << ℎ𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙[𝑖].𝑑𝑖𝑎𝑔𝑛𝑜𝑠𝑡𝑖𝑐𝑜 << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡
𝑟𝑒[𝑛𝑜𝑚𝑏𝑟𝑒𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒][𝑖𝑛𝑑𝑖𝑐𝑒] = 𝑛𝑢𝑒𝑣𝑜𝑅𝑒𝑔𝑖𝑠𝑡𝑟𝑜; 𝑐𝑜𝑢𝑡 << "𝑅𝑒𝑔𝑖𝑠𝑡𝑟𝑜 𝑎𝑐𝑡𝑢𝑎𝑙𝑖𝑧𝑎𝑑𝑜 𝑐𝑜𝑛 𝑒𝑥𝑖𝑡𝑜." << 𝑒𝑛𝑑𝑙; } 𝑒𝑙𝑠𝑒 { 𝑐𝑜𝑢𝑡 <
𝑖𝑎𝑙.𝑠𝑖𝑧𝑒(); ++𝑖) { 𝑠𝑖𝑧𝑒_𝑡 𝑏𝑎𝑠𝑒𝐼𝑛𝑑𝑒𝑥 = 𝑖 ∗ 4; 𝑐𝑜𝑢𝑡 << 𝑏𝑎𝑠𝑒𝐼𝑛𝑑𝑒𝑥 + 1 << ". 𝐹𝑒𝑐ℎ𝑎 𝑑𝑒 𝑐𝑜𝑛𝑠𝑢𝑙𝑡𝑎 (𝑓𝑜𝑟𝑚𝑎𝑡𝑜 𝑑𝑑/𝑚𝑚/𝑎𝑎𝑎𝑎):
𝑡𝑜𝑟𝑖𝑎𝑙𝑀𝑒𝑑𝑖𝑐𝑜() { 𝑠𝑡𝑟𝑖𝑛𝑔 𝑛𝑜𝑚𝑏𝑟𝑒𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒; 𝑐𝑜𝑢𝑡 << "𝐼𝑛𝑔𝑟𝑒𝑠𝑒 𝑒𝑙 𝑛𝑜𝑚𝑏𝑟𝑒 𝑑𝑒𝑙 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒: "; 𝑐𝑖𝑛.𝑖𝑔𝑛𝑜𝑟𝑒(); 𝑔𝑒𝑡𝑙𝑖𝑛𝑒(𝑐𝑖𝑛, 𝑛𝑜𝑚𝑏𝑟𝑒𝑃
𝑏𝑟𝑒.𝑒𝑛𝑑()) { 𝑣𝑒𝑐𝑡𝑜𝑟<𝐻𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙𝑀𝑒𝑑𝑖𝑐𝑜>& ℎ𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙 = ℎ𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙𝑃𝑜𝑟𝑁𝑜𝑚𝑏𝑟𝑒[𝑛𝑜𝑚𝑏𝑟𝑒𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒]; 𝑚𝑜𝑠𝑡𝑟𝑎𝑟𝐻𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙𝑀𝑒𝑑𝑖𝑐𝑜𝐶𝑜
𝑤𝑖𝑡𝑐ℎ (𝑐𝑎𝑚𝑝𝑜) { 𝑐𝑎𝑠𝑒 0: 𝑐𝑜𝑢𝑡 << "𝐼𝑛𝑔𝑟𝑒𝑠𝑒 𝑙𝑎 𝑛𝑢𝑒𝑣𝑎 𝑓𝑒𝑐ℎ𝑎 𝑑𝑒 𝑐𝑜𝑛𝑠𝑢𝑙𝑡𝑎 (𝑓𝑜𝑟𝑚𝑎𝑡𝑜 𝑑𝑑/𝑚𝑚/𝑎𝑎𝑎𝑎): "; 𝑐𝑖𝑛
𝑔𝑒𝑡𝑙𝑖𝑛𝑒(𝑐𝑖𝑛, 𝑟𝑒𝑔𝑖𝑠𝑡𝑟𝑜.𝑡𝑟𝑎𝑡𝑎𝑚𝑖𝑒𝑛𝑡𝑜); 𝑏𝑟𝑒𝑎𝑘; 𝑑𝑒𝑓𝑎𝑢𝑙𝑡: 𝑐𝑜𝑢𝑡 << "𝑂𝑝𝑐𝑖𝑜𝑛 𝑛𝑜 𝑣𝑎𝑙𝑖𝑑𝑎. 𝑃𝑜𝑟 𝑓𝑎𝑣𝑜𝑟, 𝑖𝑛𝑡𝑒𝑛𝑡𝑒 𝑛
𝑒𝑑𝑟𝑜", "987−654−321"}, {"𝐻𝑜𝑠𝑝𝑖𝑡𝑎𝑙 𝑑𝑒𝑙 𝐸𝑠𝑡𝑒", "456−789−123"}, {"𝐶𝑙𝑖𝑛𝑖𝑐𝑎 𝑆𝑎𝑛𝑡𝑎 𝑀𝑎𝑟𝑖𝑎", "321−654−987"} }; 𝑐𝑜𝑢𝑡 << "
𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒[0])) { 𝑛𝑜𝑚𝑏𝑟𝑒𝑉𝑎𝑙𝑖𝑑𝑜 = 𝑡𝑟𝑢𝑒; } 𝑒𝑙𝑠𝑒 { 𝑐𝑜𝑢𝑡 << "𝑁𝑜𝑚𝑏𝑟𝑒 𝑛𝑜 𝑣𝑎𝑙𝑖𝑑𝑜. 𝑃𝑜𝑟 𝑓𝑎𝑣𝑜𝑟, 𝑖𝑛𝑡𝑒𝑛𝑡𝑒 𝑛𝑢𝑒𝑣𝑎𝑚𝑒𝑛𝑡𝑒." << 𝑒𝑛
𝑒𝑛𝑑𝑙; } 𝑒𝑙𝑠𝑒 { 𝑜𝑝𝑐𝑖𝑜𝑛𝑉𝑎𝑙𝑖𝑑𝑎 = 𝑡𝑟𝑢𝑒; } } 𝑐𝑜𝑢𝑡 << "𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒 " << 𝑛𝑜𝑚𝑏𝑟𝑒𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒 << " 𝑡𝑟𝑎𝑠𝑙𝑎𝑑𝑎𝑑𝑜 𝑎 " << ℎ𝑜𝑠𝑝𝑖𝑡𝑎
𝑛"; 𝑎𝑟𝑐ℎ𝑖𝑣𝑜 << "𝐷𝑜𝑠𝑖𝑠: " << 𝑟𝑒𝑐𝑒𝑡𝑎.𝑑𝑜𝑠𝑖𝑠 << "\𝑛"; 𝑎𝑟𝑐ℎ𝑖𝑣𝑜 << "𝑁𝑢𝑚𝑒𝑟𝑜 𝑑𝑒 𝑑𝑖𝑎𝑠: " << 𝑟𝑒𝑐𝑒𝑡𝑎.𝑛𝑢𝑚𝑒𝑟𝑜𝐷𝑖𝑎𝑠 << "\𝑛";
𝑀𝑒𝑑𝑖𝑐𝑜> ℎ𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙; 𝐻𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙𝑀𝑒𝑑𝑖𝑐𝑜 𝑛𝑢𝑒𝑣𝑜𝑅𝑒𝑔𝑖𝑠𝑡𝑟𝑜; 𝑑𝑜 { 𝑐𝑜𝑢𝑡 << "\𝑛𝑀𝑒𝑛𝑢 𝑑𝑒 𝑝𝑒𝑟𝑠𝑜𝑛𝑎𝑙 𝑚𝑒𝑑𝑖𝑐𝑜" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "1.
𝑑𝑎 𝑐𝑖𝑛.𝑐𝑙𝑒𝑎𝑟(); 𝑐𝑖𝑛.𝑖𝑔𝑛𝑜𝑟𝑒(𝑛𝑢𝑚𝑒𝑟𝑖𝑐_𝑙𝑖𝑚𝑖𝑡𝑠<𝑠𝑡𝑟𝑒𝑎𝑚𝑠𝑖𝑧𝑒>::𝑚𝑎𝑥(), ′\𝑛′); 𝑐𝑜𝑢𝑡 << "𝐸𝑛𝑡𝑟𝑎𝑑𝑎 𝑛𝑜 𝑣𝑎𝑙𝑖𝑑𝑎. 𝑃𝑜𝑟 𝑓𝑎𝑣𝑜𝑟, 𝑖
𝑏𝑟𝑒 𝑛𝑜 𝑣𝑎𝑙𝑖𝑑𝑜. 𝑆𝑜𝑙𝑜 𝑠𝑒 𝑝𝑒𝑟𝑚𝑖𝑡𝑒𝑛 𝑙𝑒𝑡𝑟𝑎𝑠 𝑦 𝑒𝑠𝑝𝑎𝑐𝑖𝑜𝑠." << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "𝐼𝑛𝑔𝑟𝑒𝑠𝑒 𝑒𝑙 𝑛𝑜𝑚𝑏𝑟𝑒 𝑑𝑒𝑙 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒: "; } } 𝐻𝑖
𝑎𝑐𝑖𝑒𝑛𝑡𝑒, 𝑛𝑢𝑒𝑣𝑜𝑅𝑒𝑔𝑖𝑠𝑡𝑟𝑜); 𝑐𝑜𝑢𝑡 << "𝐻𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙 𝑚𝑒𝑑𝑖𝑐𝑜 𝑐𝑟𝑒𝑎𝑑𝑜 𝑐𝑜𝑛 𝑒𝑥𝑖𝑡𝑜." << 𝑒𝑛𝑑𝑙; 𝑏𝑟𝑒𝑎𝑘; } 𝑐𝑎𝑠𝑒 2: {
𝑏𝑟𝑒𝑎𝑘; } 𝑐𝑎𝑠𝑒 3: 𝑚𝑎𝑛𝑒𝑗𝑎𝑟𝐴𝑐𝑡𝑢𝑎𝑙𝑖𝑧𝑎𝑐𝑖𝑜𝑛𝐻𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙𝑀𝑒𝑑𝑖𝑐𝑜(); 𝑏𝑟𝑒𝑎𝑘; 𝑐𝑎𝑠𝑒 4: 𝑎𝑠𝑖𝑔𝑛𝑎𝑟𝑅𝑒𝑐𝑒
𝑒𝑔𝑎𝑟𝑈𝑠𝑢𝑎𝑟𝑖𝑜(𝑙𝑖𝑠𝑡𝑎𝐸𝑛𝑓𝑒𝑟𝑚𝑒𝑟𝑎𝑠, "𝑒𝑛𝑓𝑒𝑟𝑚𝑒𝑟𝑎", "𝐹𝑎𝑏𝑟𝑖𝑧𝑧𝑖𝑜", "123456"); 𝑚𝑜𝑠𝑡𝑟𝑎𝑟𝑀𝑒𝑛𝑢𝐼𝑛𝑔𝑟𝑒𝑠𝑜(𝑙𝑖𝑠𝑡𝑎𝑀𝑒𝑑𝑖𝑐𝑜𝑠, 𝑙𝑖𝑠𝑡𝑎𝐸𝑛𝑓𝑒𝑟𝑚𝑒𝑟𝑎
os anteriormente

s productos recibidos anteriormente

tisfechas con los productos recibidos anteriormente de sus compras en líne
se sienten neutrales con los productos recibidos de sus compras en línea p
insatisfechos con los productos recibidos anteriormente de sus compras en

tos recibidos anteriormente

atisfacción

2.22%

Muy insatisfecho

con los productos recibidos anteriormente de sus compras

sonas se sienten neutrales, 0% de las personas se
s. Esto indica que la mayoría de las personas tienen un nivel
 con los productos recibidos anteriormente de sus compras
sonas se sienten neutrales, 0% de las personas se
s. Esto indica que la mayoría de las personas tienen un nivel

𝑎 𝑎𝑙𝑚𝑎𝑐𝑒𝑛𝑎𝑟 𝑙𝑜𝑠 𝑑𝑎𝑡𝑜𝑠 𝑑𝑒 𝑙𝑜𝑠 𝑢𝑠𝑢𝑎𝑟𝑖𝑜𝑠𝑠𝑡𝑟𝑢𝑐𝑡 𝑈𝑠𝑢𝑎𝑟𝑖𝑜 { 𝑠𝑡𝑟𝑖𝑛𝑔 𝑡𝑖𝑝𝑜; // ′𝑚𝑒𝑑𝑖𝑐𝑜′ 𝑜 ′𝑒𝑛𝑓𝑒𝑟𝑚𝑒𝑟𝑎′ 𝑠𝑡𝑟𝑖𝑛𝑔 𝑛𝑜𝑚𝑏𝑟𝑒; 𝑠𝑡𝑟𝑖𝑛𝑔 𝑐𝑜𝑛𝑡𝑟𝑎
𝑟𝑒𝑡𝑢𝑟𝑛 𝑒𝑠𝑆𝑜𝑙𝑜𝐿𝑒𝑡𝑟𝑎𝑠𝑌𝐸𝑠𝑝𝑎𝑐𝑖𝑜𝑠(𝑠𝑡𝑟, 𝑖𝑛𝑑𝑒𝑥 + 1);}// 𝐹𝑢𝑛𝑐𝑖𝑜𝑛 𝑟𝑒𝑐𝑢𝑟𝑠𝑖𝑣𝑎 𝑝𝑎𝑟𝑎 𝑣𝑎𝑙𝑖𝑑𝑎𝑟 𝑞𝑢𝑒 𝑢𝑛𝑎 𝑐𝑎𝑑𝑒𝑛𝑎 𝑐𝑜𝑛𝑡𝑖𝑒𝑛𝑒 𝑠𝑜𝑙𝑜 𝑙𝑒𝑡𝑟𝑎𝑠, 𝑛𝑢𝑚𝑒
𝑒𝑐𝑒𝑡𝑎>& 𝑟𝑒𝑐𝑒𝑡𝑎𝑠) { 𝑅𝑒𝑐𝑒𝑡𝑎 𝑛𝑢𝑒𝑣𝑎𝑅𝑒𝑐𝑒𝑡𝑎; 𝑏𝑜𝑜𝑙 𝑒𝑛𝑡𝑟𝑎𝑑𝑎𝑉𝑎𝑙𝑖𝑑𝑎; 𝑐𝑖𝑛.𝑖𝑔𝑛𝑜𝑟𝑒(); // 𝑃𝑎𝑟𝑎 𝑙𝑖𝑚𝑝𝑖𝑎𝑟 𝑐𝑢𝑎𝑙𝑞𝑢𝑖𝑒𝑟 𝑐𝑎𝑟𝑎𝑐𝑡𝑒𝑟 𝑝𝑒𝑛𝑑𝑖𝑒𝑛𝑡𝑒 𝑒
𝑚𝑒𝑑𝑖𝑐𝑎𝑚𝑒𝑛𝑡𝑜: "; 𝑔𝑒𝑡𝑙𝑖𝑛𝑒(𝑐𝑖𝑛, 𝑛𝑢𝑒𝑣𝑎𝑅𝑒𝑐𝑒𝑡𝑎.𝑚𝑒𝑑𝑖𝑐𝑎𝑚𝑒𝑛𝑡𝑜); 𝑒𝑛𝑡𝑟𝑎𝑑𝑎𝑉𝑎𝑙𝑖𝑑𝑎 = 𝑒𝑠𝑆𝑜𝑙𝑜𝐿𝑒𝑡𝑟𝑎𝑠𝑁𝑢𝑚𝑒𝑟𝑜𝑠𝑌𝐸𝑠𝑝𝑎𝑐𝑖𝑜𝑠(𝑛𝑢𝑒𝑣𝑎𝑅𝑒𝑐
𝑒𝑠𝑝𝑎𝑐𝑖𝑜𝑠. 𝑉𝑢𝑒𝑙𝑣𝑎 𝑎 𝑖𝑛𝑔𝑟𝑒𝑠𝑎𝑟." << 𝑒𝑛𝑑𝑙; } } 𝑤ℎ𝑖𝑙𝑒 (!𝑒𝑛𝑡𝑟𝑎𝑑𝑎𝑉𝑎𝑙𝑖𝑑𝑎); // 𝑉𝑎𝑙𝑖𝑑𝑎𝑟 𝑛𝑢𝑚𝑒𝑟𝑜 𝑑𝑒 𝑑𝑖𝑎𝑠 𝑑𝑜 { 𝑐𝑜𝑢𝑡 << "𝐼𝑛𝑔𝑟𝑒𝑠𝑒
𝑎𝑙𝑖𝑑𝑎); // 𝑉𝑎𝑙𝑖𝑑𝑎𝑟 𝑐𝑎𝑑𝑎 𝑐𝑢𝑎𝑛𝑡𝑎𝑠 ℎ𝑜𝑟𝑎𝑠 𝑑𝑒𝑏𝑒 𝑡𝑜𝑚𝑎𝑟𝑠𝑒 𝑑𝑜 { 𝑐𝑜𝑢𝑡 << "𝐼𝑛𝑔𝑟𝑒𝑠𝑒 𝑐𝑎𝑑𝑎 𝑐𝑢𝑎𝑛𝑡𝑎𝑠 ℎ𝑜𝑟𝑎𝑠 𝑑𝑒𝑏𝑒 𝑡𝑜𝑚𝑎𝑟𝑠𝑒: "; 𝑐𝑖𝑛 >
𝑝𝑢𝑠ℎ_𝑏𝑎𝑐𝑘(𝑛𝑢𝑒𝑣𝑎𝑅𝑒𝑐𝑒𝑡𝑎); 𝑐𝑜𝑢𝑡 << "𝑅𝑒𝑐𝑒𝑡𝑎 𝑎𝑠𝑖𝑔𝑛𝑎𝑑𝑎 𝑐𝑜𝑛 𝑒𝑥𝑖𝑡𝑜." << 𝑒𝑛𝑑𝑙;}// 𝐸𝑠𝑡𝑢𝑐𝑡𝑢𝑟𝑎 𝑝𝑎𝑟𝑎 𝑎𝑙𝑚𝑎𝑐𝑒𝑛𝑎𝑟 𝑑𝑎𝑡𝑜𝑠 𝑑𝑒 ℎ𝑜𝑠𝑝𝑖𝑡𝑎𝑙𝑒𝑠
𝑡 𝑒𝑠𝑝𝑒𝑐𝑖𝑎𝑙𝑖𝑑𝑎𝑑𝐴𝑠𝑖𝑔𝑛𝑎𝑑𝑎; 𝑠𝑡𝑟𝑖𝑛𝑔 𝑚𝑒𝑑𝑖𝑐𝑜𝐴𝑠𝑖𝑔𝑛𝑎𝑑𝑜; 𝑖𝑛𝑡 𝑛𝑖𝑣𝑒𝑙𝑈𝑟𝑔𝑒𝑛𝑐𝑖𝑎;};// 𝐹𝑢𝑛𝑐𝑖𝑜𝑛 𝑟𝑒𝑐𝑢𝑟𝑠𝑖𝑣𝑎 𝑝𝑎𝑟𝑎 𝑣𝑎𝑙𝑖𝑑𝑎𝑟 𝑠𝑖 𝑢𝑛 𝑛𝑢𝑚𝑒𝑟𝑜 𝑑𝑒 𝐷
9 𝑑𝑖𝑔𝑖𝑡𝑜𝑠 𝑖𝑓 (𝑐𝑒𝑙𝑢𝑙𝑎𝑟.𝑙𝑒𝑛𝑔𝑡ℎ() != 9) 𝑟𝑒𝑡𝑢𝑟𝑛 𝑓𝑎𝑙𝑠𝑒; 𝑖𝑓 (𝑖𝑛𝑑𝑒𝑥 == 𝑐𝑒𝑙𝑢𝑙𝑎𝑟.𝑙𝑒𝑛𝑔𝑡ℎ()) 𝑟𝑒𝑡𝑢𝑟𝑛 𝑡𝑟𝑢𝑒; 𝑖𝑓 (!𝑖𝑠𝑑𝑖𝑔𝑖𝑡(𝑐𝑒𝑙𝑢𝑙𝑎𝑟[𝑖𝑛𝑑𝑒𝑥])) 𝑟
𝐹)𝑏𝑜𝑜𝑙 𝑒𝑠𝐺𝑒𝑛𝑒𝑟𝑜𝑉𝑎𝑙𝑖𝑑𝑜(𝑐ℎ𝑎𝑟 𝑔𝑒𝑛𝑒𝑟𝑜) { 𝑟𝑒𝑡𝑢𝑟𝑛 𝑔𝑒𝑛𝑒𝑟𝑜 == ′𝑀′ || 𝑔𝑒𝑛𝑒𝑟𝑜 == ′𝑚′ || 𝑔𝑒𝑛𝑒𝑟𝑜 == ′𝐹′ || 𝑔𝑒𝑛𝑒𝑟𝑜 == ′𝑓′;}// 𝐹𝑢𝑛𝑐𝑖𝑜𝑛 𝑝
𝐼𝑛𝑔𝑟𝑒𝑠𝑎𝑟 𝑒𝑙 𝑛𝑜𝑚𝑏𝑟𝑒 𝑐𝑜𝑢𝑡 << "𝑁𝑜𝑚𝑏𝑟𝑒: "; 𝑐𝑖𝑛.𝑖𝑔𝑛𝑜𝑟𝑒(); // 𝐿𝑖𝑚𝑝𝑖𝑎𝑟 𝑒𝑙 𝑏𝑢𝑓𝑓𝑒𝑟 𝑑𝑒𝑙 𝑡𝑒𝑐𝑙𝑎𝑑𝑜 𝑔𝑒𝑡𝑙𝑖𝑛𝑒(𝑐𝑖𝑛, 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑛𝑜𝑚𝑏𝑟𝑒); 𝑤ℎ
} // 𝐼𝑛𝑔𝑟𝑒𝑠𝑎 𝑙𝑎 𝑓𝑒𝑐ℎ𝑎 𝑑𝑒 𝑛𝑎𝑐𝑖𝑚𝑖𝑒𝑛𝑡𝑜 𝑐𝑜𝑢𝑡 << "𝐹𝑒𝑐ℎ𝑎 𝑑𝑒 𝑛𝑎𝑐𝑖𝑚𝑖𝑒𝑛𝑡𝑜 (𝑓𝑜𝑟𝑚𝑎𝑡𝑜 𝑑𝑑/𝑚𝑚/𝑎𝑎𝑎𝑎): "; 𝑐𝑖𝑛 >> 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑓𝑒𝑐ℎ𝑎𝑁𝑎
{ 𝑐𝑜𝑢𝑡 << "𝐸𝑠𝑡𝑎𝑑𝑜 𝑐𝑖𝑣𝑖𝑙 𝑛𝑜 𝑣𝑎𝑙𝑖𝑑𝑜. 𝑃𝑜𝑟 𝑓𝑎𝑣𝑜𝑟, 𝑖𝑛𝑔𝑟𝑒𝑠𝑒 ′𝑆′, ′𝐶′, ′𝑉′ 𝑜 ′𝐷′." << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "𝐸𝑠𝑡𝑎𝑑𝑜 𝑐𝑖𝑣𝑖𝑙 (𝑆/𝐶/𝑉/𝐷): ";
𝐶𝑒𝑙𝑢𝑙𝑎𝑟 (9 𝑑𝑖𝑔𝑖𝑡𝑜𝑠): "; 𝑐𝑖𝑛 >> 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑐𝑒𝑙𝑢𝑙𝑎𝑟; 𝑖𝑓 (!𝑒𝑠𝐶𝑒𝑙𝑢𝑙𝑎𝑟𝑉𝑎𝑙𝑖𝑑𝑜(𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑐𝑒𝑙𝑢𝑙𝑎𝑟)) { 𝑐𝑜𝑢𝑡 << "𝐶𝑒𝑙𝑢𝑙𝑎𝑟 𝑛𝑜 𝑣𝑎𝑙𝑖𝑑
𝑐𝑜𝑢𝑡 << "4. 𝐺𝑒𝑛𝑒𝑟𝑜" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "5. 𝐸𝑠𝑡𝑎𝑑𝑜 𝑐𝑖𝑣𝑖𝑙" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "6. 𝐷𝑁𝐼" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "7. 𝐷𝑖𝑟𝑒𝑐𝑐𝑖𝑜
𝑜𝑠." << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "𝑁𝑢𝑒𝑣𝑜 𝑛𝑜𝑚𝑏𝑟𝑒: "; } } 𝑤ℎ𝑖𝑙𝑒 (!𝑒𝑠𝑁𝑜𝑚𝑏𝑟𝑒𝑉𝑎𝑙𝑖𝑑𝑜(𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑛𝑜𝑚𝑏𝑟𝑒)); 𝑏𝑟
𝑚𝑎𝑡𝑜 𝑑𝑑/𝑚𝑚/𝑎𝑎𝑎𝑎): "; 𝑐𝑖𝑛 >> 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑓𝑒𝑐ℎ𝑎𝑁𝑎𝑐𝑖𝑚𝑖𝑒𝑛𝑡𝑜; 𝑏𝑟𝑒𝑎𝑘; 𝑐𝑎𝑠𝑒 4: 𝑐𝑜𝑢𝑡 << "𝑁𝑢�
𝑐𝑎𝑠𝑒 5: 𝑐𝑜𝑢𝑡 << "𝑁𝑢𝑒𝑣𝑜 𝑒𝑠𝑡𝑎𝑑𝑜 𝑐𝑖𝑣𝑖𝑙 (𝑆/𝐶/𝑉/𝐷): "; 𝑑𝑜 { 𝑐𝑖𝑛 >> 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑒𝑠𝑡𝑎𝑑𝑜𝐶𝑖𝑣𝑖𝑙; 𝑖𝑓 (!𝑒𝑠
𝑒𝑛𝑡𝑒 𝑛𝑢𝑒𝑣𝑎𝑚𝑒𝑛𝑡𝑒." << 𝑒𝑛𝑑𝑙; } } 𝑤ℎ𝑖𝑙𝑒 (!𝑒𝑠𝐷𝑛𝑖𝑉𝑎𝑙𝑖𝑑𝑜(𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑑𝑛𝑖)); 𝑏𝑟𝑒𝑎𝑘; 𝑐𝑎𝑠𝑒 7: 𝑐𝑜𝑢𝑡 <<
𝑁𝑢𝑒𝑣𝑜 𝑐𝑜𝑟𝑟𝑒𝑜 𝑒𝑙𝑒𝑐𝑡𝑟𝑜𝑛𝑖𝑐𝑜: "; 𝑐𝑖𝑛 >> 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑐𝑜𝑟𝑟𝑒𝑜; 𝑏𝑟𝑒𝑎𝑘; 𝑐𝑎𝑠𝑒 10: 𝑐𝑜𝑢𝑡 << "𝑆𝑎𝑙𝑖𝑒𝑛𝑑𝑜 𝑑𝑒 𝑙𝑎 𝑎𝑐𝑡𝑢𝑎
𝑐𝑖𝑛, 𝑛𝑜𝑚𝑏𝑟𝑒𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒); 𝑖𝑓 (!𝑒𝑠𝑁𝑜𝑚𝑏𝑟𝑒𝑉𝑎𝑙𝑖𝑑𝑜(𝑛𝑜𝑚𝑏𝑟𝑒𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒)) { 𝑐𝑜𝑢𝑡 << "𝐸𝑙 𝑛𝑜𝑚𝑏𝑟𝑒 𝑑𝑒𝑏𝑒 𝑐𝑜𝑛𝑡𝑒𝑛𝑒𝑟 𝑠𝑜𝑙𝑜 𝑙𝑒𝑡𝑟𝑎𝑠." << 𝑒
𝑎𝑙𝑙𝑎)) { 𝑐𝑖𝑛.𝑐𝑙𝑒𝑎𝑟(); 𝑐𝑖𝑛.𝑖𝑔𝑛𝑜𝑟𝑒(𝑛𝑢𝑚𝑒𝑟𝑖𝑐_𝑙𝑖𝑚𝑖𝑡𝑠<𝑠𝑡𝑟𝑒𝑎𝑚𝑠𝑖𝑧𝑒>::𝑚𝑎𝑥(), ′\𝑛′); 𝑐𝑜𝑢𝑡 << "𝐸𝑛𝑡𝑟𝑎𝑑𝑎 𝑛𝑜 𝑣𝑎𝑙𝑖𝑑𝑎. 𝑃𝑜𝑟 𝑓𝑎𝑣𝑜𝑟, 𝑖𝑛
𝑣𝑎𝑙𝑖𝑑𝑎. 𝑃𝑜𝑟 𝑓𝑎𝑣𝑜𝑟, 𝑖𝑛𝑔𝑟𝑒𝑠𝑒 𝑢𝑛 𝑛𝑢𝑚𝑒𝑟𝑜 𝑝𝑎𝑟𝑎 𝑙𝑎 𝑝𝑟𝑒𝑠𝑖𝑜𝑛 𝑎𝑟𝑡𝑒𝑟𝑖𝑎𝑙: "; } 𝑐𝑜𝑢𝑡 << "𝑆𝑎𝑡𝑢𝑟𝑎𝑐𝑖𝑜𝑛 𝑑𝑒 𝑜𝑥𝑖𝑔𝑒𝑛𝑜 (%): "; 𝑤ℎ𝑖𝑙𝑒 (!(𝑐𝑖𝑛 >>
𝑛𝑡𝑒:" << " |" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << 𝑠𝑡𝑟𝑖𝑛𝑔(𝑎𝑛𝑐ℎ𝑜, ′−′) << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "| 𝑃𝑒𝑠𝑜 (𝑘𝑔): " << 𝑙𝑒𝑓𝑡 << 𝑠𝑒𝑡𝑤(𝑎𝑛𝑐ℎ𝑜 − 17) << 𝑝𝑎𝑐𝑖𝑒𝑛𝑡
𝑢𝑡 << 𝑠𝑡𝑟𝑖𝑛𝑔(𝑎𝑛𝑐ℎ𝑜, ′−′) << 𝑒𝑛𝑑𝑙;}// 𝐹𝑢𝑛𝑐𝑖𝑜𝑛 𝑝𝑎𝑟𝑎 𝑚𝑜𝑠𝑡𝑟𝑎𝑟 𝑙𝑜𝑠 𝑑𝑎𝑡𝑜𝑠 𝑑𝑒𝑙 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒 𝑒𝑛 𝑢𝑛 𝑐𝑢𝑎𝑑𝑟𝑜𝑣𝑜𝑖𝑑 𝑚𝑜𝑠𝑡𝑟𝑎𝑟𝐷𝑎𝑡𝑜𝑠𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒(𝑐𝑜
<< 𝑙𝑒𝑓𝑡 << 𝑠𝑒𝑡𝑤(𝑎𝑛𝑐ℎ𝑜 − 26) << 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑓𝑒𝑐ℎ𝑎𝑁𝑎𝑐𝑖𝑚𝑖𝑒𝑛𝑡𝑜 << " |" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "| 𝐺𝑒𝑛𝑒𝑟𝑜: " << 𝑙𝑒𝑓𝑡 << 𝑠𝑒𝑡𝑤(𝑎𝑛𝑐ℎ𝑜 −
< 𝑠𝑒𝑡𝑤(𝑎𝑛𝑐ℎ𝑜 − 24) << 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑐𝑜𝑟𝑟𝑒𝑜 << " |" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << 𝑠𝑡𝑟𝑖𝑛𝑔(𝑎𝑛𝑐ℎ𝑜, ′−′) << 𝑒𝑛𝑑𝑙;}// 𝐹𝑢𝑛𝑐𝑖𝑜𝑛 𝑝𝑎𝑟𝑎 𝑎𝑠𝑖𝑔𝑛𝑎𝑟 𝑒𝑠𝑝𝑒𝑐
𝑒𝑠 𝑑𝑖𝑠𝑝𝑜𝑛𝑖𝑏𝑙𝑒𝑠\𝑛"; 𝑐𝑜𝑢𝑡 << "1. 𝑀𝑒𝑑𝑖𝑐𝑖𝑛𝑎 𝑔𝑒𝑛𝑒𝑟𝑎𝑙\𝑛"; 𝑐𝑜𝑢𝑡 << "2. 𝑂𝑏𝑠𝑡𝑒𝑡𝑟𝑖𝑐𝑖𝑎\𝑛"; 𝑐𝑜𝑢𝑡 << "3. 𝑃𝑜𝑑𝑜𝑙𝑜𝑔𝑖𝑎\𝑛"; 𝑐𝑜𝑢𝑡 << "4. 𝑃𝑒
𝑒𝑠𝑝𝑒𝑐𝑖𝑎𝑙𝑖𝑑𝑎𝑑𝐴𝑠𝑖𝑔𝑛𝑎𝑑𝑎 <= 10) { 𝑏𝑟𝑒𝑎𝑘; } 𝑒𝑙𝑠𝑒 { 𝑐𝑜𝑢𝑡 << "𝑁𝑢𝑚𝑒𝑟𝑜 𝑛𝑜 𝑣𝑎𝑙𝑖𝑑𝑜. 𝑃𝑜𝑟 𝑓𝑎𝑣𝑜𝑟, 𝑖𝑛𝑔𝑟𝑒𝑠𝑒 𝑢𝑛 𝑛𝑢𝑚𝑒𝑟𝑜 𝑣
𝑑𝑒 𝑒𝑠𝑝𝑒𝑐𝑖𝑎𝑙𝑖𝑑𝑎𝑑." << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "𝐼𝑛𝑔𝑟𝑒𝑠𝑒 𝑒𝑙 𝑛𝑢𝑚𝑒𝑟𝑜 𝑐𝑜𝑟𝑟𝑒𝑠𝑝𝑜𝑛𝑑𝑖𝑒𝑛𝑡𝑒 𝑎 𝑙𝑎 𝑒𝑠𝑝𝑒𝑐𝑖𝑎𝑙𝑖𝑑𝑎𝑑 𝑎𝑠𝑖𝑔𝑛𝑎𝑑𝑎: "; } } 𝑐𝑜𝑢𝑡 <
." << 𝑒𝑛𝑑𝑙;}// 𝐹𝑢𝑛𝑐𝑖𝑜𝑛 𝑝𝑎𝑟𝑎 𝑎𝑠𝑖𝑔𝑛𝑎𝑟 𝑢𝑛 𝑙𝑢𝑔𝑎𝑟 𝑒𝑛 𝑙𝑎 𝑙𝑖𝑠𝑡𝑎 𝑑𝑒 𝑒𝑠𝑝𝑒𝑟𝑎 𝑎𝑙 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒𝑣𝑜𝑖𝑑 𝑙𝑢𝑔𝑎𝑟𝐸𝑛𝐿𝑖𝑠𝑡𝑎𝐸𝑠𝑝𝑒𝑟𝑎(𝑣𝑒𝑐𝑡𝑜𝑟<𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒> &𝑙
𝑚𝑒𝑟𝑔𝑒𝑛𝑐𝑖𝑎\𝑛" << "3. 𝑈𝑟𝑔𝑒𝑛𝑐𝑖𝑎\𝑛" << "4. 𝑈𝑟𝑔𝑒𝑛𝑐𝑖𝑎 𝑚𝑒𝑛𝑜𝑟\𝑛" << "5. 𝑆𝑖𝑛 𝑢𝑟𝑔𝑒𝑛𝑐𝑖𝑎\𝑛" << "𝐼𝑛𝑑𝑖𝑞𝑢𝑒 𝑒𝑙 𝑛𝑖𝑣𝑒𝑙 𝑑𝑒 𝑢
(𝑐𝑜𝑛𝑠𝑡 𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒 &𝑝) { 𝑟𝑒𝑡𝑢𝑟𝑛 𝑝.𝑛𝑖𝑣𝑒𝑙𝑈𝑟𝑔𝑒𝑛𝑐𝑖𝑎 > 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑛𝑖𝑣𝑒𝑙𝑈𝑟𝑔𝑒𝑛𝑐𝑖𝑎; }); 𝑙𝑖𝑠𝑡𝑎𝐸𝑠𝑝𝑒𝑟𝑎.𝑖𝑛𝑠𝑒𝑟𝑡(𝑖𝑡, 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒); 𝑐𝑜𝑢𝑡 <<
𝑖𝑐𝑜𝑠." << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "𝐼𝑛𝑔𝑟𝑒𝑠𝑒 𝑒𝑙 𝑛𝑜𝑚𝑏𝑟𝑒 𝑑𝑒𝑙 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒: "; 𝑔𝑒𝑡𝑙𝑖𝑛𝑒(𝑐𝑖𝑛, 𝑛𝑜𝑚𝑏𝑟𝑒); } 𝑎𝑢𝑡𝑜 𝑖𝑡 = 𝑓𝑖𝑛𝑑_𝑖𝑓(𝑙𝑖𝑠𝑡𝑎𝐸𝑠𝑝𝑒𝑟𝑎.𝑏𝑒𝑔

𝑡𝑟𝑎𝑠𝑒𝑛𝑎 = 𝑐𝑜𝑛𝑡𝑟𝑎𝑠𝑒𝑛𝑎; 𝑛𝑢𝑒𝑣𝑜−>𝑠𝑖𝑔𝑢𝑖𝑒𝑛𝑡𝑒 = 𝑛𝑢𝑙𝑙𝑝𝑡𝑟; 𝑟𝑒𝑡𝑢𝑟𝑛 𝑛𝑢𝑒𝑣𝑜;}// 𝐹𝑢𝑛𝑐𝑖𝑜𝑛 𝑝𝑎𝑟𝑎 𝑎ñ𝑎𝑑𝑖𝑟 𝑢𝑛 𝑢𝑠𝑢𝑎𝑟𝑖𝑜 𝑎 𝑙𝑎 𝑙𝑖𝑠𝑡𝑎𝑣𝑜𝑖𝑑 𝑎𝑔𝑟𝑒𝑔
𝑐𝑜𝑛𝑡𝑟𝑎𝑠𝑒ñ𝑎 (𝑑𝑒𝑏𝑒 𝑡𝑒𝑛𝑒𝑟 𝑎𝑙 𝑚𝑒𝑛𝑜𝑠 6 𝑐𝑎𝑟𝑎𝑐𝑡𝑒𝑟𝑒𝑠): "; 𝑐𝑖𝑛 >> 𝑐𝑜𝑛𝑡𝑟𝑎𝑠𝑒𝑛𝑎; 𝑤ℎ𝑖𝑙𝑒(𝑐𝑜𝑛𝑡𝑟𝑎𝑠𝑒𝑛𝑎.𝑙𝑒𝑛𝑔𝑡ℎ() < 6) { 𝑐𝑜𝑢𝑡 << "𝐿𝑎 𝑐𝑜
𝑢𝑛𝑐𝑖𝑜𝑛 𝑝𝑎𝑟𝑎 𝑙𝑖𝑏𝑒𝑟𝑎𝑟 𝑚𝑒𝑚𝑜𝑟𝑖𝑎 𝑑𝑒 𝑙𝑎 𝑙𝑖𝑠𝑡𝑎 𝑑𝑒 𝑢𝑠𝑢𝑎𝑟𝑖𝑜𝑠𝑣𝑜𝑖𝑑 𝑙𝑖𝑏𝑒𝑟𝑎𝑟𝑀𝑒𝑚𝑜𝑟𝑖𝑎(𝑈𝑠𝑢𝑎𝑟𝑖𝑜∗& 𝑐𝑎𝑏𝑒𝑧𝑎) { 𝑤ℎ𝑖𝑙𝑒 (𝑐𝑎𝑏𝑒𝑧𝑎 != 𝑛𝑢𝑙𝑙𝑝𝑡𝑟) {
𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "1. 𝑅𝑒𝑔𝑖𝑠𝑡𝑟𝑎𝑟 𝑑𝑎𝑡𝑜𝑠 𝑑𝑒𝑙 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "2. 𝑇𝑟𝑖𝑎𝑗𝑒" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "3. 𝐴𝑐𝑡𝑢𝑎𝑙𝑖𝑧𝑎𝑟 𝑑𝑎𝑡𝑜𝑠
𝑅𝑒𝑔𝑖𝑠𝑡𝑟𝑜 𝑑𝑒 𝑡𝑟𝑖𝑎𝑗𝑒..." << 𝑒𝑛𝑑𝑙; 𝑟𝑒𝑔𝑖𝑠𝑡𝑟𝑎𝑟𝑇𝑟𝑖𝑎𝑗𝑒(𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒); 𝑏𝑟𝑒𝑎𝑘; 𝑐𝑎𝑠𝑒 3: 𝑐𝑜𝑢𝑡 << "𝐴𝑐𝑡𝑢𝑎𝑙𝑖𝑧𝑎𝑛𝑑𝑜 𝑑𝑎
𝑒𝑝𝑒𝑛𝑑𝑖𝑒𝑛𝑑𝑜 𝑠𝑢 𝑛𝑖𝑣𝑒𝑙 𝑑𝑒 𝑒𝑚𝑒𝑟𝑔𝑒𝑛𝑐𝑖𝑎..." << 𝑒𝑛𝑑𝑙; 𝑙𝑢𝑔𝑎𝑟𝐸𝑛𝐿𝑖𝑠𝑡𝑎𝐸𝑠𝑝𝑒𝑟𝑎(𝑙𝑖𝑠𝑡𝑎𝐸𝑠𝑝𝑒𝑟𝑎, 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒); 𝑏𝑟𝑒𝑎𝑘; 𝑐𝑎𝑠𝑒 7
𝑒𝑛𝑡𝑒& 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒) { 𝑖𝑛𝑡 𝑜𝑝𝑐𝑖𝑜𝑛; 𝑣𝑒𝑐𝑡𝑜𝑟<𝑅𝑒𝑐𝑒𝑡𝑎> 𝑟𝑒𝑐𝑒𝑡𝑎𝑠; 𝑑𝑜 { 𝑐𝑜𝑢𝑡 << "∗∗∗" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "𝑃𝑜𝑙𝑖𝑐𝑙𝑖𝑛𝑖𝑐𝑜 𝑆𝑎𝑛 𝑉𝑖𝑐𝑒𝑛
𝑛.𝑐𝑙𝑒𝑎𝑟(); 𝑐𝑖𝑛.𝑖𝑔𝑛𝑜𝑟𝑒(𝑛𝑢𝑚𝑒𝑟𝑖𝑐_𝑙𝑖𝑚𝑖𝑡𝑠<𝑠𝑡𝑟𝑒𝑎𝑚𝑠𝑖𝑧𝑒>::𝑚𝑎𝑥(), ′\𝑛′); 𝑐𝑜𝑢𝑡 << "𝐸𝑛𝑡𝑟𝑎𝑑𝑎 𝑛𝑜 𝑣𝑎𝑙𝑖𝑑𝑎. 𝑃𝑜𝑟 𝑓𝑎𝑣𝑜𝑟, 𝑖𝑛𝑔𝑟𝑒𝑠𝑒 𝑢𝑛
 𝑖𝑐𝑜𝑠." << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "𝐼𝑛𝑔𝑟𝑒𝑠𝑒 𝑒𝑙 𝑛𝑜𝑚𝑏𝑟𝑒 𝑑𝑒𝑙 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒: "; 𝑔𝑒𝑡𝑙𝑖𝑛𝑒(𝑐𝑖𝑛, 𝑛𝑜𝑚𝑏𝑟𝑒); } 𝑎𝑢𝑡𝑜 𝑖𝑡 = 𝑓𝑖𝑛𝑑_𝑖𝑓(𝑙𝑖𝑠𝑡𝑎𝐸𝑠𝑝𝑒𝑟𝑎.𝑏𝑒𝑔
𝑡𝑟𝑎𝑠𝑒𝑛𝑎 = 𝑐𝑜𝑛𝑡𝑟𝑎𝑠𝑒𝑛𝑎; 𝑛𝑢𝑒𝑣𝑜−>𝑠𝑖𝑔𝑢𝑖𝑒𝑛𝑡𝑒 = 𝑛𝑢𝑙𝑙𝑝𝑡𝑟; 𝑟𝑒𝑡𝑢𝑟𝑛 𝑛𝑢𝑒𝑣𝑜;}// 𝐹𝑢𝑛𝑐𝑖𝑜𝑛 𝑝𝑎𝑟𝑎 𝑎ñ𝑎𝑑𝑖𝑟 𝑢𝑛 𝑢𝑠𝑢𝑎𝑟𝑖𝑜 𝑎 𝑙𝑎 𝑙𝑖𝑠𝑡𝑎𝑣𝑜𝑖𝑑 𝑎𝑔𝑟𝑒𝑔
𝑐𝑜𝑛𝑡𝑟𝑎𝑠𝑒ñ𝑎 (𝑑𝑒𝑏𝑒 𝑡𝑒𝑛𝑒𝑟 𝑎𝑙 𝑚𝑒𝑛𝑜𝑠 6 𝑐𝑎𝑟𝑎𝑐𝑡𝑒𝑟𝑒𝑠): "; 𝑐𝑖𝑛 >> 𝑐𝑜𝑛𝑡𝑟𝑎𝑠𝑒𝑛𝑎; 𝑤ℎ𝑖𝑙𝑒(𝑐𝑜𝑛𝑡𝑟𝑎𝑠𝑒𝑛𝑎.𝑙𝑒𝑛𝑔𝑡ℎ() < 6) { 𝑐𝑜𝑢𝑡 << "𝐿𝑎 𝑐𝑜
𝑢𝑛𝑐𝑖𝑜𝑛 𝑝𝑎𝑟𝑎 𝑙𝑖𝑏𝑒𝑟𝑎𝑟 𝑚𝑒𝑚𝑜𝑟𝑖𝑎 𝑑𝑒 𝑙𝑎 𝑙𝑖𝑠𝑡𝑎 𝑑𝑒 𝑢𝑠𝑢𝑎𝑟𝑖𝑜𝑠𝑣𝑜𝑖𝑑 𝑙𝑖𝑏𝑒𝑟𝑎𝑟𝑀𝑒𝑚𝑜𝑟𝑖𝑎(𝑈𝑠𝑢𝑎𝑟𝑖𝑜∗& 𝑐𝑎𝑏𝑒𝑧𝑎) { 𝑤ℎ𝑖𝑙𝑒 (𝑐𝑎𝑏𝑒𝑧𝑎 != 𝑛𝑢𝑙𝑙𝑝𝑡𝑟) {
𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "1. 𝑅𝑒𝑔𝑖𝑠𝑡𝑟𝑎𝑟 𝑑𝑎𝑡𝑜𝑠 𝑑𝑒𝑙 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "2. 𝑇𝑟𝑖𝑎𝑗𝑒" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "3. 𝐴𝑐𝑡𝑢𝑎𝑙𝑖𝑧𝑎𝑟 𝑑𝑎𝑡𝑜𝑠
𝑅𝑒𝑔𝑖𝑠𝑡𝑟𝑜 𝑑𝑒 𝑡𝑟𝑖𝑎𝑗𝑒..." << 𝑒𝑛𝑑𝑙; 𝑟𝑒𝑔𝑖𝑠𝑡𝑟𝑎𝑟𝑇𝑟𝑖𝑎𝑗𝑒(𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒); 𝑏𝑟𝑒𝑎𝑘; 𝑐𝑎𝑠𝑒 3: 𝑐𝑜𝑢𝑡 << "𝐴𝑐𝑡𝑢𝑎𝑙𝑖𝑧𝑎𝑛𝑑𝑜 𝑑𝑎
𝑒𝑝𝑒𝑛𝑑𝑖𝑒𝑛𝑑𝑜 𝑠𝑢 𝑛𝑖𝑣𝑒𝑙 𝑑𝑒 𝑒𝑚𝑒𝑟𝑔𝑒𝑛𝑐𝑖𝑎..." << 𝑒𝑛𝑑𝑙; 𝑙𝑢𝑔𝑎𝑟𝐸𝑛𝐿𝑖𝑠𝑡𝑎𝐸𝑠𝑝𝑒𝑟𝑎(𝑙𝑖𝑠𝑡𝑎𝐸𝑠𝑝𝑒𝑟𝑎, 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒); 𝑏𝑟𝑒𝑎𝑘; 𝑐𝑎𝑠𝑒 7
𝑒𝑛𝑡𝑒& 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒) { 𝑖𝑛𝑡 𝑜𝑝𝑐𝑖𝑜𝑛; 𝑣𝑒𝑐𝑡𝑜𝑟<𝑅𝑒𝑐𝑒𝑡𝑎> 𝑟𝑒𝑐𝑒𝑡𝑎𝑠; 𝑑𝑜 { 𝑐𝑜𝑢𝑡 << "∗∗∗" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "𝑃𝑜𝑙𝑖𝑐𝑙𝑖𝑛𝑖𝑐𝑜 𝑆𝑎𝑛 𝑉𝑖𝑐𝑒𝑛
𝑛.𝑐𝑙𝑒𝑎𝑟(); 𝑐𝑖𝑛.𝑖𝑔𝑛𝑜𝑟𝑒(𝑛𝑢𝑚𝑒𝑟𝑖𝑐_𝑙𝑖𝑚𝑖𝑡𝑠<𝑠𝑡𝑟𝑒𝑎𝑚𝑠𝑖𝑧𝑒>::𝑚𝑎𝑥(), ′\𝑛′); 𝑐𝑜𝑢𝑡 << "𝐸𝑛𝑡𝑟𝑎𝑑𝑎 𝑛𝑜 𝑣𝑎𝑙𝑖𝑑𝑎. 𝑃𝑜𝑟 𝑓𝑎𝑣𝑜𝑟, 𝑖𝑛𝑔𝑟𝑒𝑠𝑒 𝑢𝑛
𝑐𝑜𝑢𝑡 << "𝐶𝑟𝑒𝑑𝑒𝑛𝑐𝑖𝑎𝑙𝑒𝑠 𝑑𝑒 𝑚𝑒𝑑𝑖𝑐𝑜 𝑖𝑛𝑐𝑜𝑟𝑟𝑒𝑐𝑡𝑎𝑠. 𝐼𝑛𝑡𝑒𝑛𝑡𝑒 𝑛𝑢𝑒𝑣𝑎𝑚𝑒𝑛𝑡𝑒." << 𝑒𝑛𝑑𝑙; } } 𝑤ℎ𝑖𝑙𝑒 (!𝑐𝑟𝑒𝑑𝑒𝑛𝑐𝑖𝑎𝑙𝑒𝑠
<< "𝐶𝑟𝑒𝑑𝑒𝑛𝑐𝑖𝑎𝑙𝑒𝑠 𝑑𝑒 𝑒𝑛𝑓𝑒𝑟𝑚𝑒𝑟𝑜 𝑖𝑛𝑐𝑜𝑟𝑟𝑒𝑐𝑡𝑎𝑠. 𝐼𝑛𝑡𝑒𝑛𝑡𝑒 𝑛𝑢𝑒𝑣𝑎𝑚𝑒𝑛𝑡𝑒." << 𝑒𝑛𝑑𝑙; } } 𝑤ℎ𝑖𝑙𝑒 (!𝑐𝑟𝑒𝑑𝑒𝑛𝑐𝑖𝑎𝑙𝑒𝑠𝑉𝑎𝑙𝑖𝑑𝑎𝑠);
𝑜𝑢𝑡 << "𝐸𝑛𝑓𝑒𝑟𝑚𝑒𝑟𝑎 𝑟𝑒𝑔𝑖𝑠𝑡𝑟𝑎𝑑𝑎 𝑐𝑜𝑛 𝑒𝑥𝑖𝑡𝑜" << 𝑒𝑛𝑑𝑙; 𝑏𝑟𝑒𝑎𝑘; } 𝑐𝑎𝑠𝑒 5: 𝑐𝑜𝑢𝑡 << "𝑆𝑎𝑙𝑖𝑒𝑛𝑑𝑜..." << 𝑒𝑛𝑑𝑙;
𝑜 𝑐𝑙𝑎𝑣𝑒// 𝐹𝑢𝑛𝑐𝑖𝑜𝑛 𝑝𝑎𝑟𝑎 𝑎𝑛𝑎𝑑𝑖𝑟 𝑢𝑛 𝑛𝑢𝑒𝑣𝑜 𝑟𝑒𝑔𝑖𝑠𝑡𝑟𝑜 𝑎𝑙 ℎ𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙 𝑚𝑒𝑑𝑖𝑐𝑜𝑣𝑜𝑖𝑑 𝑎𝑔𝑟𝑒𝑔𝑎𝑟𝑅𝑒𝑔𝑖𝑠𝑡𝑟𝑜𝐻𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙(𝑐𝑜𝑛𝑠𝑡 𝑠𝑡𝑟𝑖𝑛𝑔& 𝑛𝑜𝑚𝑏𝑟𝑒𝑃𝑎𝑐
/ 𝐹𝑢𝑛𝑐𝑖𝑜𝑛 𝑝𝑎𝑟𝑎 𝑚𝑜𝑠𝑡𝑟𝑎𝑟 𝑒𝑙 ℎ𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙 𝑚𝑒𝑑𝑖𝑐𝑜 𝑑𝑒 𝑢𝑛 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒𝑣𝑜𝑖𝑑 𝑚𝑜𝑠𝑡𝑟𝑎𝑟𝐻𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙𝑀𝑒𝑑𝑖𝑐𝑜(𝑐𝑜𝑛𝑠𝑡 𝑣𝑒𝑐𝑡𝑜𝑟<𝐻𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙𝑀𝑒𝑑𝑖𝑐𝑜>& ℎ𝑖𝑠
" << ℎ𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙[𝑖].𝑑𝑖𝑎𝑔𝑛𝑜𝑠𝑡𝑖𝑐𝑜 << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "𝑇𝑟𝑎𝑡𝑎𝑚𝑖𝑒𝑛𝑡𝑜: " << ℎ𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙[𝑖].𝑡𝑟𝑎𝑡𝑎𝑚𝑖𝑒𝑛𝑡𝑜 << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << 𝑒𝑛𝑑𝑙;
𝑧𝑎𝑑𝑜 𝑐𝑜𝑛 𝑒𝑥𝑖𝑡𝑜." << 𝑒𝑛𝑑𝑙; } 𝑒𝑙𝑠𝑒 { 𝑐𝑜𝑢𝑡 << "𝐸𝑙 𝑖𝑛𝑑𝑖𝑐𝑒 𝑒𝑠𝑝𝑒𝑐𝑖𝑓𝑖𝑐𝑎𝑑𝑜 𝑒𝑠𝑡𝑎 𝑓𝑢𝑒𝑟𝑎 𝑑𝑒 𝑟𝑎𝑛𝑔𝑜." << 𝑒𝑛𝑑𝑙; } } 𝑒𝑙𝑠𝑒 { 𝑐𝑜𝑢
< ". 𝐹𝑒𝑐ℎ𝑎 𝑑𝑒 𝑐𝑜𝑛𝑠𝑢𝑙𝑡𝑎 (𝑓𝑜𝑟𝑚𝑎𝑡𝑜 𝑑𝑑/𝑚𝑚/𝑎𝑎𝑎𝑎): " << ℎ𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙[𝑖].𝑓𝑒𝑐ℎ𝑎𝐶𝑜𝑛𝑠𝑢𝑙𝑡𝑎 << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << 𝑏𝑎𝑠𝑒𝐼𝑛𝑑𝑒𝑥 + 2 << ". 𝑀
𝑎𝑐𝑖𝑒𝑛𝑡𝑒: "; 𝑐𝑖𝑛.𝑖𝑔𝑛𝑜𝑟𝑒(); 𝑔𝑒𝑡𝑙𝑖𝑛𝑒(𝑐𝑖𝑛, 𝑛𝑜𝑚𝑏𝑟𝑒𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒); 𝑤ℎ𝑖𝑙𝑒(!𝑒𝑠𝑁𝑜𝑚𝑏𝑟𝑒𝑉𝑎𝑙𝑖𝑑𝑜(𝑛𝑜𝑚𝑏𝑟𝑒
𝑛𝑜𝑚𝑏𝑟𝑒𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒]; 𝑚𝑜𝑠𝑡𝑟𝑎𝑟𝐻𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙𝑀𝑒𝑑𝑖𝑐𝑜𝐶𝑜𝑛𝐼𝑛𝑑𝑖𝑐𝑒𝑠(ℎ𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙); 𝑠𝑖𝑧𝑒_𝑡 𝑖𝑛𝑑𝑖𝑐𝑒; 𝑐𝑜𝑢𝑡 << "𝐼𝑛𝑔𝑟𝑒𝑠𝑒 𝑒𝑙 𝑛𝑢𝑚𝑒𝑟𝑜 𝑑𝑒 𝑖𝑛𝑑𝑖𝑐
𝑜𝑛𝑠𝑢𝑙𝑡𝑎 (𝑓𝑜𝑟𝑚𝑎𝑡𝑜 𝑑𝑑/𝑚𝑚/𝑎𝑎𝑎𝑎): "; 𝑐𝑖𝑛 >> 𝑟𝑒𝑔𝑖𝑠𝑡𝑟𝑜.𝑓𝑒𝑐ℎ𝑎𝐶𝑜𝑛𝑠𝑢𝑙𝑡𝑎; 𝑏𝑟𝑒𝑎𝑘; 𝑐𝑎𝑠𝑒 1: 𝑐𝑜𝑢𝑡 <<
𝑐𝑜𝑢𝑡 << "𝑂𝑝𝑐𝑖𝑜𝑛 𝑛𝑜 𝑣𝑎𝑙𝑖𝑑𝑎. 𝑃𝑜𝑟 𝑓𝑎𝑣𝑜𝑟, 𝑖𝑛𝑡𝑒𝑛𝑡𝑒 𝑛𝑢𝑒𝑣𝑎𝑚𝑒𝑛𝑡𝑒." << 𝑒𝑛𝑑𝑙; 𝑟𝑒𝑡𝑢𝑟𝑛; } 𝑎𝑐𝑡𝑢𝑎𝑙𝑖𝑧𝑎𝑟𝑅𝑒𝑔𝑖𝑠𝑡𝑟𝑜𝐻𝑖𝑠𝑡𝑜𝑟
𝑐𝑎 𝑆𝑎𝑛𝑡𝑎 𝑀𝑎𝑟𝑖𝑎", "321−654−987"} }; 𝑐𝑜𝑢𝑡 << "𝐿𝑖𝑠𝑡𝑎 𝑑𝑒 ℎ𝑜𝑠𝑝𝑖𝑡𝑎𝑙𝑒𝑠 𝑑𝑖𝑠𝑝𝑜𝑛𝑖𝑏𝑙𝑒𝑠 𝑝𝑎𝑟𝑎 𝑡𝑟𝑎𝑠𝑙𝑎𝑑𝑜:" << 𝑒𝑛𝑑𝑙; 𝑓𝑜𝑟 (𝑠𝑖𝑧𝑒_𝑡 𝑖 = 0; 𝑖 <
𝑛𝑜 𝑣𝑎𝑙𝑖𝑑𝑜. 𝑃𝑜𝑟 𝑓𝑎𝑣𝑜𝑟, 𝑖𝑛𝑡𝑒𝑛𝑡𝑒 𝑛𝑢𝑒𝑣𝑎𝑚𝑒𝑛𝑡𝑒." << 𝑒𝑛𝑑𝑙; } } 𝑖𝑛𝑡 𝑜𝑝𝑐𝑖𝑜𝑛; 𝑏𝑜𝑜𝑙 𝑜𝑝𝑐𝑖𝑜𝑛𝑉𝑎𝑙𝑖𝑑𝑎 = 𝑓𝑎𝑙𝑠𝑒; 𝑤ℎ𝑖𝑙𝑒 (!𝑜𝑝𝑐𝑖𝑜𝑛𝑉𝑎𝑙𝑖𝑑𝑎) {
𝑛𝑜𝑚𝑏𝑟𝑒𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒 << " 𝑡𝑟𝑎𝑠𝑙𝑎𝑑𝑎𝑑𝑜 𝑎 " << ℎ𝑜𝑠𝑝𝑖𝑡𝑎𝑙𝑒𝑠[𝑜𝑝𝑐𝑖𝑜𝑛 − 1].𝑛𝑜𝑚𝑏𝑟𝑒 << " 𝑐𝑜𝑛 𝑐𝑜𝑛𝑡𝑎𝑐𝑡𝑜 " << ℎ𝑜𝑠𝑝𝑖𝑡𝑎𝑙𝑒𝑠[𝑜𝑝𝑐𝑖𝑜𝑛 − 1].𝑐𝑜𝑛𝑡𝑎𝑐𝑡
𝑚𝑒𝑟𝑜 𝑑𝑒 𝑑𝑖𝑎𝑠: " << 𝑟𝑒𝑐𝑒𝑡𝑎.𝑛𝑢𝑚𝑒𝑟𝑜𝐷𝑖𝑎𝑠 << "\𝑛"; 𝑎𝑟𝑐ℎ𝑖𝑣𝑜 << "𝐶𝑎𝑑𝑎 𝑐𝑢𝑎𝑛𝑡𝑎𝑠 ℎ𝑜𝑟𝑎𝑠: " << 𝑟𝑒𝑐𝑒𝑡𝑎.𝑐𝑎𝑑𝑎𝐶𝑢𝑎𝑛𝑡𝑎𝑠𝐻𝑜𝑟𝑎𝑠 << "\𝑛
𝑛𝑢 𝑑𝑒 𝑝𝑒𝑟𝑠𝑜𝑛𝑎𝑙 𝑚𝑒𝑑𝑖𝑐𝑜" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "1. 𝐶𝑟𝑒𝑎𝑟 ℎ𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙 𝑚𝑒𝑑𝑖𝑐𝑜 𝑝𝑎𝑟𝑎 𝑢𝑛 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "2. 𝐵𝑢𝑠𝑐𝑎𝑟 ℎ𝑖𝑠
); 𝑐𝑜𝑢𝑡 << "𝐸𝑛𝑡𝑟𝑎𝑑𝑎 𝑛𝑜 𝑣𝑎𝑙𝑖𝑑𝑎. 𝑃𝑜𝑟 𝑓𝑎𝑣𝑜𝑟, 𝑖𝑛𝑔𝑟𝑒𝑠𝑒 𝑢𝑛 𝑛𝑢𝑚𝑒𝑟𝑜 𝑣𝑎𝑙𝑖𝑑𝑜." << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑛𝑡𝑖𝑛𝑢𝑒; } 𝑠𝑤𝑖𝑡𝑐ℎ (𝑜𝑝𝑐𝑖𝑜𝑛) {
𝑟𝑒𝑠𝑒 𝑒𝑙 𝑛𝑜𝑚𝑏𝑟𝑒 𝑑𝑒𝑙 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒: "; } } 𝐻𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙𝑀𝑒𝑑𝑖𝑐𝑜 𝑛𝑢𝑒𝑣𝑜𝑅𝑒𝑔𝑖𝑠𝑡𝑟𝑜; 𝑐𝑜𝑢𝑡 << "𝐹𝑒𝑐ℎ𝑎 𝑑𝑒 𝑐𝑜𝑛𝑠𝑢𝑙𝑡𝑎 (𝑓𝑜𝑟𝑚𝑎𝑡𝑜 𝑑
<< 𝑒𝑛𝑑𝑙; 𝑏𝑟𝑒𝑎𝑘; } 𝑐𝑎𝑠𝑒 2: { 𝑠𝑡𝑟𝑖𝑛𝑔 𝑛𝑜𝑚𝑏𝑟𝑒𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒; 𝑐𝑜𝑢𝑡 << "𝐼𝑛𝑔𝑟𝑒𝑠𝑒 𝑒𝑙 𝑛𝑜𝑚𝑏𝑟𝑒 𝑑𝑒𝑙 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒: "
𝑏𝑟𝑒𝑎𝑘; 𝑐𝑎𝑠𝑒 4: 𝑎𝑠𝑖𝑔𝑛𝑎𝑟𝑅𝑒𝑐𝑒𝑡𝑎(𝑟𝑒𝑐𝑒𝑡𝑎𝑠); 𝑏𝑟𝑒𝑎𝑘; 𝑐𝑎𝑠𝑒 5: 𝑚𝑎𝑛𝑒𝑗𝑎𝑟𝑇𝑟𝑎𝑠𝑙𝑎𝑑𝑜(); 𝑏𝑟
𝑡𝑟𝑎𝑟𝑀𝑒𝑛𝑢𝐼𝑛𝑔𝑟𝑒𝑠𝑜(𝑙𝑖𝑠𝑡𝑎𝑀𝑒𝑑𝑖𝑐𝑜𝑠, 𝑙𝑖𝑠𝑡𝑎𝐸𝑛𝑓𝑒𝑟𝑚𝑒𝑟𝑎𝑠, 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒); // 𝐿𝑖𝑏𝑒𝑟𝑎𝑟 𝑚𝑒𝑚𝑜𝑟𝑖𝑎 𝑑𝑒 𝑙𝑎𝑠 𝑙𝑖𝑠𝑡𝑎𝑠 𝑑𝑒 𝑢𝑠𝑢𝑎𝑟𝑖𝑜𝑠 𝑙𝑖𝑏𝑒𝑟𝑎𝑟𝑀𝑒𝑚𝑜𝑟𝑖𝑎
𝑠𝑡𝑟𝑖𝑛𝑔 𝑛𝑜𝑚𝑏𝑟𝑒; 𝑠𝑡𝑟𝑖𝑛𝑔 𝑐𝑜𝑛𝑡𝑟𝑎𝑠𝑒𝑛𝑎; 𝑈𝑠𝑢𝑎𝑟𝑖𝑜∗ 𝑠𝑖𝑔𝑢𝑖𝑒𝑛𝑡𝑒;};// 𝐸𝑠𝑡𝑟𝑢𝑐𝑡𝑢𝑟𝑎 𝑝𝑎𝑟𝑎 𝑎𝑙𝑚𝑎𝑐𝑒𝑛𝑎𝑟 𝑙𝑎𝑠 𝑟𝑒𝑐𝑒𝑡𝑎𝑠𝑠𝑡𝑟𝑢𝑐𝑡 𝑅𝑒𝑐𝑒𝑡𝑎 { 𝑠𝑡𝑟𝑖𝑛𝑔 𝑛
𝑛𝑎 𝑐𝑜𝑛𝑡𝑖𝑒𝑛𝑒 𝑠𝑜𝑙𝑜 𝑙𝑒𝑡𝑟𝑎𝑠, 𝑛𝑢𝑚𝑒𝑟𝑜𝑠 𝑦 𝑒𝑠𝑝𝑎𝑐𝑖𝑜𝑠𝑏𝑜𝑜𝑙 𝑒𝑠𝑆𝑜𝑙𝑜𝐿𝑒𝑡𝑟𝑎𝑠𝑁𝑢𝑚𝑒𝑟𝑜𝑠𝑌𝐸𝑠𝑝𝑎𝑐𝑖𝑜𝑠(𝑐𝑜𝑛𝑠𝑡 𝑠𝑡𝑟𝑖𝑛𝑔& 𝑠𝑡𝑟, 𝑖𝑛𝑡 𝑖𝑛𝑑𝑒𝑥 = 0) { 𝑖𝑓 (𝑖𝑛𝑑𝑒𝑥
𝑢𝑎𝑙𝑞𝑢𝑖𝑒𝑟 𝑐𝑎𝑟𝑎𝑐𝑡𝑒𝑟 𝑝𝑒𝑛𝑑𝑖𝑒𝑛𝑡𝑒 𝑒𝑛 𝑒𝑙 𝑏𝑢𝑓𝑓𝑒𝑟 𝑑𝑒 𝑒𝑛𝑡𝑟𝑎𝑑𝑎 // 𝑉𝑎𝑙𝑖𝑑𝑎𝑟 𝑛𝑜𝑚𝑏𝑟𝑒 𝑑𝑒𝑙 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒 𝑑𝑜 { 𝑐𝑜𝑢𝑡 << "𝐼𝑛𝑔𝑟𝑒𝑠𝑒 𝑛𝑜𝑚𝑏𝑟𝑒 𝑑𝑒𝑙
𝑁𝑢𝑚𝑒𝑟𝑜𝑠𝑌𝐸𝑠𝑝𝑎𝑐𝑖𝑜𝑠(𝑛𝑢𝑒𝑣𝑎𝑅𝑒𝑐𝑒𝑡𝑎.𝑚𝑒𝑑𝑖𝑐𝑎𝑚𝑒𝑛𝑡𝑜); 𝑖𝑓 (!𝑒𝑛𝑡𝑟𝑎𝑑𝑎𝑉𝑎𝑙𝑖𝑑𝑎) { 𝑐𝑜𝑢𝑡 << "𝑀𝑒𝑑𝑖𝑐𝑎𝑚𝑒𝑛𝑡𝑜 𝑖𝑛𝑐𝑜𝑟𝑟𝑒𝑐𝑡𝑜. 𝑆𝑜𝑙𝑜 𝑠𝑒 𝑝𝑒𝑟𝑚
𝑎𝑠 𝑑𝑜 { 𝑐𝑜𝑢𝑡 << "𝐼𝑛𝑔𝑟𝑒𝑠𝑒 𝑛𝑢𝑚𝑒𝑟𝑜 𝑑𝑒 𝑑𝑖𝑎𝑠 𝑞𝑢𝑒 𝑑𝑒𝑏𝑒 𝑡𝑜𝑚𝑎𝑟𝑠𝑒: "; 𝑐𝑖𝑛 >> 𝑛𝑢𝑒𝑣𝑎𝑅𝑒𝑐𝑒𝑡𝑎.𝑛𝑢𝑚𝑒𝑟𝑜𝐷𝑖𝑎𝑠; 𝑖𝑓 (𝑐𝑖𝑛.𝑓𝑎𝑖𝑙() || 𝑛𝑢
𝑜𝑟𝑎𝑠 𝑑𝑒𝑏𝑒 𝑡𝑜𝑚𝑎𝑟𝑠𝑒: "; 𝑐𝑖𝑛 >> 𝑛𝑢𝑒𝑣𝑎𝑅𝑒𝑐𝑒𝑡𝑎.𝑐𝑎𝑑𝑎𝐶𝑢𝑎𝑛𝑡𝑎𝑠𝐻𝑜𝑟𝑎𝑠; 𝑖𝑓 (𝑐𝑖𝑛.𝑓𝑎𝑖𝑙() || 𝑛𝑢𝑒𝑣𝑎𝑅𝑒𝑐𝑒𝑡𝑎.𝑐𝑎𝑑𝑎𝐶𝑢𝑎𝑛𝑡𝑎𝑠𝐻𝑜𝑟𝑎𝑠 <= 0) {
𝑚𝑎𝑐𝑒𝑛𝑎𝑟 𝑑𝑎𝑡𝑜𝑠 𝑑𝑒 ℎ𝑜𝑠𝑝𝑖𝑡𝑎𝑙𝑒𝑠 𝑑𝑒 𝑡𝑟𝑎𝑠𝑙𝑎𝑑𝑜𝑠𝑡𝑟𝑢𝑐𝑡 𝐻𝑜𝑠𝑝𝑖𝑡𝑎𝑙 { 𝑠𝑡𝑟𝑖𝑛𝑔 𝑛𝑜𝑚𝑏𝑟𝑒; 𝑠𝑡𝑟𝑖𝑛𝑔 𝑐𝑜𝑛𝑡𝑎𝑐𝑡𝑜;};// 𝐸𝑠𝑡𝑟𝑢𝑐𝑡𝑢𝑟𝑎 𝑝𝑎𝑟𝑎 𝑎𝑙𝑚𝑎𝑐𝑒𝑛𝑎𝑟
𝑎𝑟𝑎 𝑣𝑎𝑙𝑖𝑑𝑎𝑟 𝑠𝑖 𝑢𝑛 𝑛𝑢𝑚𝑒𝑟𝑜 𝑑𝑒 𝐷𝑁𝐼 𝑒𝑠 𝑣𝑎𝑙𝑖𝑑𝑜𝑏𝑜𝑜𝑙 𝑒𝑠𝐷𝑛𝑖𝑉𝑎𝑙𝑖𝑑𝑜(𝑐𝑜𝑛𝑠𝑡 𝑠𝑡𝑟𝑖𝑛𝑔& 𝑑𝑛𝑖, 𝑖𝑛𝑡 𝑖𝑛𝑑𝑒𝑥 = 0) { // 𝑆𝑒 𝑎𝑠𝑢𝑚𝑒 𝑞𝑢𝑒 𝑢𝑛 𝐷𝑁𝐼 𝑣𝑎𝑙𝑖𝑑𝑜
𝑖𝑓 (!𝑖𝑠𝑑𝑖𝑔𝑖𝑡(𝑐𝑒𝑙𝑢𝑙𝑎𝑟[𝑖𝑛𝑑𝑒𝑥])) 𝑟𝑒𝑡𝑢𝑟𝑛 𝑓𝑎𝑙𝑠𝑒; 𝑟𝑒𝑡𝑢𝑟𝑛 𝑒𝑠𝐶𝑒𝑙𝑢𝑙𝑎𝑟𝑉𝑎𝑙𝑖𝑑𝑜(𝑐𝑒𝑙𝑢𝑙𝑎𝑟, 𝑖𝑛𝑑𝑒𝑥 + 1);}// 𝐹𝑢𝑛𝑐𝑖𝑜𝑛 𝑟𝑒𝑐𝑢𝑟𝑠𝑖𝑣𝑎 𝑝𝑎𝑟𝑎 𝑣𝑎𝑙𝑖𝑑𝑎𝑟 𝑠𝑖 𝑒
| 𝑔𝑒𝑛𝑒𝑟𝑜 == ′𝑓′;}// 𝐹𝑢𝑛𝑐𝑖𝑜𝑛 𝑝𝑎𝑟𝑎 𝑣𝑎𝑙𝑖𝑑𝑎𝑟 𝑠𝑖 𝑒𝑙 𝑒𝑠𝑡𝑎𝑑𝑜 𝑐𝑖𝑣𝑖𝑙 𝑖𝑛𝑔𝑟𝑒𝑠𝑎𝑑𝑜 𝑒𝑠 𝑣𝑎𝑙𝑖𝑑𝑜 (𝑆, 𝐶, 𝑉 𝑜 𝐷)𝑏𝑜𝑜𝑙 𝑒𝑠𝐸𝑠𝑡𝑎𝑑𝑜𝐶𝑖𝑣𝑖𝑙𝑉𝑎𝑙𝑖𝑑𝑜(𝑐ℎ𝑎𝑟 𝑒𝑠𝑡𝑎
𝑛𝑒(𝑐𝑖𝑛, 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑛𝑜𝑚𝑏𝑟𝑒); 𝑤ℎ𝑖𝑙𝑒 (!𝑒𝑠𝑁𝑜𝑚𝑏𝑟𝑒𝑉𝑎𝑙𝑖𝑑𝑜(𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑛𝑜𝑚𝑏𝑟𝑒)) { 𝑐𝑜𝑢𝑡 << "𝑁𝑜𝑚𝑏𝑟𝑒 𝑛𝑜 𝑣𝑎𝑙𝑖𝑑𝑜. 𝐼𝑛𝑔𝑟𝑒𝑠𝑒 𝑠𝑜𝑙𝑜 𝑐𝑎𝑟𝑎𝑐𝑡𝑒
): "; 𝑐𝑖𝑛 >> 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑓𝑒𝑐ℎ𝑎𝑁𝑎𝑐𝑖𝑚𝑖𝑒𝑛𝑡𝑜; // 𝐼𝑛𝑔𝑟𝑒𝑠𝑎 𝑒𝑙 𝑔𝑒𝑛𝑒𝑟𝑜 𝑐𝑜𝑢𝑡 << "𝐺𝑒𝑛𝑒𝑟𝑜 (𝑀/𝐹): "; 𝑑𝑜 { 𝑐𝑖𝑛 >> 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑔𝑒𝑛𝑒𝑟𝑜;
< "𝐸𝑠𝑡𝑎𝑑𝑜 𝑐𝑖𝑣𝑖𝑙 (𝑆/𝐶/𝑉/𝐷): "; } } 𝑤ℎ𝑖𝑙𝑒 (!𝑒𝑠𝐸𝑠𝑡𝑎𝑑𝑜𝐶𝑖𝑣𝑖𝑙𝑉𝑎𝑙𝑖𝑑𝑜(𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑒𝑠𝑡𝑎𝑑𝑜𝐶𝑖𝑣𝑖𝑙)); 𝑑𝑜 { 𝑐𝑜𝑢𝑡 << "𝐷𝑁𝐼 (8 𝑑𝑖𝑔𝑖𝑡𝑜𝑠): ";
𝑐𝑜𝑢𝑡 << "𝐶𝑒𝑙𝑢𝑙𝑎𝑟 𝑛𝑜 𝑣𝑎𝑙𝑖𝑑𝑜. 𝐼𝑛𝑡𝑒𝑛𝑡𝑒 𝑛𝑢𝑒𝑣𝑎𝑚𝑒𝑛𝑡𝑒." << 𝑒𝑛𝑑𝑙; } } 𝑤ℎ𝑖𝑙𝑒 (!𝑒𝑠𝐶𝑒𝑙𝑢𝑙𝑎𝑟𝑉𝑎𝑙𝑖𝑑𝑜(𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑐𝑒𝑙𝑢𝑙𝑎𝑟)); 𝑐𝑜𝑢𝑡 << "
𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "7. 𝐷𝑖𝑟𝑒𝑐𝑐𝑖𝑜𝑛" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "8. 𝐶𝑒𝑙𝑢𝑙𝑎𝑟" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "9. 𝐶𝑜𝑟𝑟𝑒𝑜 𝑒𝑙𝑒𝑐𝑡𝑟𝑜𝑛𝑖𝑐𝑜" << 𝑒𝑛𝑑𝑙; 𝑐𝑜
(𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑛𝑜𝑚𝑏𝑟𝑒)); 𝑏𝑟𝑒𝑎𝑘; 𝑐𝑎𝑠𝑒 2: 𝑐𝑜𝑢𝑡 << "𝑁𝑢𝑒𝑣𝑜 𝑎𝑝𝑒𝑙𝑙𝑖𝑑𝑜: "; 𝑑𝑜 { 𝑔𝑒𝑡𝑙𝑖𝑛𝑒(𝑐𝑖𝑛, 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑎
𝑐𝑜𝑢𝑡 << "𝑁𝑢�
𝑒.𝑒𝑠𝑡𝑎𝑑𝑜𝐶𝑖𝑣𝑖𝑙; 𝑖𝑓 (!𝑒𝑠𝐸𝑠𝑡𝑎𝑑𝑜𝐶𝑖𝑣𝑖𝑙𝑉𝑎𝑙𝑖𝑑𝑜(𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑒𝑠𝑡𝑎𝑑𝑜𝐶𝑖𝑣𝑖𝑙)) { 𝑐𝑜𝑢𝑡 << "𝐸𝑠𝑡𝑎𝑑𝑜 𝑐𝑖𝑣𝑖𝑙 𝑛𝑜 𝑣𝑎𝑙𝑖𝑑𝑜. 𝑃𝑜𝑟 𝑓𝑎𝑣𝑜
𝑘; 𝑐𝑎𝑠𝑒 7: 𝑐𝑜𝑢𝑡 << "𝑁𝑢𝑒𝑣𝑎 𝑑𝑖𝑟𝑒𝑐𝑐𝑖𝑜𝑛: "; 𝑐𝑖𝑛.𝑖𝑔𝑛𝑜𝑟𝑒(); // 𝐿𝑖𝑚𝑝𝑖𝑎𝑟 𝑒𝑙 𝑏𝑢𝑓𝑓𝑒𝑟 𝑔𝑒𝑡𝑙𝑖𝑛𝑒(𝑐𝑖𝑛, 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑑𝑖𝑟𝑒
𝑐𝑜𝑢𝑡 << "𝑆𝑎𝑙𝑖𝑒𝑛𝑑𝑜 𝑑𝑒 𝑙𝑎 𝑎𝑐𝑡𝑢𝑎𝑙𝑖𝑧𝑎𝑐𝑖𝑜𝑛 𝑑𝑒 𝑑𝑎𝑡𝑜𝑠..." << 𝑒𝑛𝑑𝑙; 𝑏𝑟𝑒𝑎𝑘; 𝑑𝑒𝑓𝑎𝑢𝑙𝑡: 𝑐𝑜𝑢𝑡 << "𝑂𝑝𝑐𝑖𝑜𝑛 𝑛𝑜 𝑣𝑎𝑙𝑖𝑑𝑎" <<
𝑒𝑏𝑒 𝑐𝑜𝑛𝑡𝑒𝑛𝑒𝑟 𝑠𝑜𝑙𝑜 𝑙𝑒𝑡𝑟𝑎𝑠." << 𝑒𝑛𝑑𝑙; } 𝑒𝑙𝑠𝑒 { 𝑛𝑜𝑚𝑏𝑟𝑒𝑉𝑎𝑙𝑖𝑑𝑜 = 𝑡𝑟𝑢𝑒; 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑛𝑜𝑚𝑏𝑟𝑒 = 𝑛𝑜𝑚𝑏𝑟𝑒𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒; // 𝐺𝑢𝑎𝑟𝑑𝑎
𝑛𝑡𝑟𝑎𝑑𝑎 𝑛𝑜 𝑣𝑎𝑙𝑖𝑑𝑎. 𝑃𝑜𝑟 𝑓𝑎𝑣𝑜𝑟, 𝑖𝑛𝑔𝑟𝑒𝑠𝑒 𝑢𝑛 𝑛𝑢𝑚𝑒𝑟𝑜 𝑝𝑎𝑟𝑎 𝑙𝑎 𝑡𝑎𝑙𝑙𝑎: "; } 𝑐𝑜𝑢𝑡 << "𝑇𝑒𝑚𝑝𝑒𝑟𝑎𝑡𝑢𝑟𝑎 (𝐶): "; 𝑤ℎ𝑖𝑙𝑒 (!(𝑐𝑖𝑛 >> 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑡𝑒
𝑥𝑖𝑔𝑒𝑛𝑜 (%): "; 𝑤ℎ𝑖𝑙𝑒 (!(𝑐𝑖𝑛 >> 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑠𝑎𝑡𝑢𝑟𝑎𝑐𝑖𝑜𝑛)) { 𝑐𝑖𝑛.𝑐𝑙𝑒𝑎𝑟(); 𝑐𝑖𝑛.𝑖𝑔𝑛𝑜𝑟𝑒(𝑛𝑢𝑚𝑒𝑟𝑖𝑐_𝑙𝑖𝑚𝑖𝑡𝑠<𝑠𝑡𝑟𝑒𝑎𝑚𝑠𝑖𝑧𝑒>::𝑚𝑎𝑥(), ′\𝑛
𝑠𝑒𝑡𝑤(𝑎𝑛𝑐ℎ𝑜 − 17) << 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑝𝑒𝑠𝑜 << " |" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "| 𝑇𝑎𝑙𝑙𝑎 (𝑚): " << 𝑙𝑒𝑓𝑡 << 𝑠𝑒𝑡𝑤(𝑎𝑛𝑐ℎ𝑜 − 17) << 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑡𝑎𝑙𝑙𝑎
𝑜𝑖𝑑 𝑚𝑜𝑠𝑡𝑟𝑎𝑟𝐷𝑎𝑡𝑜𝑠𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒(𝑐𝑜𝑛𝑠𝑡 𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒& 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒) { 𝑐𝑜𝑛𝑠𝑡 𝑖𝑛𝑡 𝑎𝑛𝑐ℎ𝑜 = 50; // 𝐴𝑛𝑐ℎ𝑜 𝑑𝑒𝑙 𝑐𝑢𝑎𝑑𝑟𝑜 𝑐𝑜𝑢𝑡 << 𝑠𝑡𝑟𝑖𝑛𝑔(𝑎𝑛𝑐ℎ𝑜, ′−
𝑜: " << 𝑙𝑒𝑓𝑡 << 𝑠𝑒𝑡𝑤(𝑎𝑛𝑐ℎ𝑜 − 10) << 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑔𝑒𝑛𝑒𝑟𝑜 << " |" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "| 𝐸𝑠𝑡𝑎𝑑𝑜 𝑐𝑖𝑣𝑖𝑙: " << 𝑙𝑒𝑓𝑡 << 𝑠𝑒𝑡𝑤(𝑎𝑛𝑐ℎ𝑜 − 1
/ 𝐹𝑢𝑛𝑐𝑖𝑜𝑛 𝑝𝑎𝑟𝑎 𝑎𝑠𝑖𝑔𝑛𝑎𝑟 𝑒𝑠𝑝𝑒𝑐𝑖𝑎𝑙𝑖𝑑𝑎𝑑 𝑦 𝑚𝑒𝑑𝑖𝑐𝑜 𝑎𝑙 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒𝑣𝑜𝑖𝑑 𝑎𝑠𝑖𝑔𝑛𝑎𝑟𝐸𝑠𝑝𝑒𝑐𝑖𝑎𝑙𝑖𝑑𝑎𝑑𝑌𝑀𝑒𝑑𝑖𝑐𝑜(𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒 &𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒) { 𝑐𝑜𝑢𝑡 <<
𝑃𝑜𝑑𝑜𝑙𝑜𝑔𝑖𝑎\𝑛"; 𝑐𝑜𝑢𝑡 << "4. 𝑃𝑒𝑑𝑖𝑎𝑡𝑟𝑖𝑎\𝑛"; 𝑐𝑜𝑢𝑡 << "5. 𝐶𝑎𝑟𝑑𝑖𝑜𝑙𝑜𝑔𝑖𝑎\𝑛"; 𝑐𝑜𝑢𝑡 << "6. 𝑂𝑑𝑜𝑛𝑡𝑜𝑙𝑜𝑔𝑖𝑎\𝑛"; 𝑐𝑜𝑢𝑡 << "7. 𝑁𝑢𝑡𝑟𝑖𝑐𝑖𝑜𝑛\
𝑜𝑟 𝑓𝑎𝑣𝑜𝑟, 𝑖𝑛𝑔𝑟𝑒𝑠𝑒 𝑢𝑛 𝑛𝑢𝑚𝑒𝑟𝑜 𝑣𝑎𝑙𝑖𝑑𝑜 𝑑𝑒 𝑒𝑠𝑝𝑒𝑐𝑖𝑎𝑙𝑖𝑑𝑎𝑑." << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "𝐼𝑛𝑔𝑟𝑒𝑠𝑒 𝑒𝑙 𝑛𝑢𝑚𝑒𝑟𝑜 𝑐𝑜𝑟𝑟𝑒𝑠𝑝𝑜𝑛𝑑𝑖𝑒𝑛𝑡𝑒 𝑎 𝑙𝑎 𝑒𝑠𝑝𝑒𝑐
𝑎𝑠𝑖𝑔𝑛𝑎𝑑𝑎: "; } } 𝑐𝑜𝑢𝑡 << "𝐼𝑛𝑔𝑟𝑒𝑠𝑒 𝑒𝑙 𝑛𝑜𝑚𝑏𝑟𝑒 𝑑𝑒𝑙 𝑚𝑒𝑑𝑖𝑐𝑜 𝑎𝑠𝑖𝑔𝑛𝑎𝑑𝑜: "; 𝑐𝑖𝑛.𝑖𝑔𝑛𝑜𝑟𝑒(); // 𝐿𝑖𝑚𝑝𝑖𝑎𝑟 𝑒𝑙 𝑏𝑢𝑓𝑓𝑒𝑟 𝑑𝑒𝑙 𝑡𝑒𝑐𝑙𝑎𝑑𝑜 𝑔
𝐸𝑠𝑝𝑒𝑟𝑎(𝑣𝑒𝑐𝑡𝑜𝑟<𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒> &𝑙𝑖𝑠𝑡𝑎𝐸𝑠𝑝𝑒𝑟𝑎, 𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒 &𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒) { 𝑐𝑜𝑢𝑡 << "𝐼𝑛𝑔𝑟𝑒𝑠𝑒 𝑒𝑙 𝑛𝑜𝑚𝑏𝑟𝑒 𝑑𝑒𝑙 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒: "; 𝑐𝑖𝑛.𝑖𝑔𝑛𝑜𝑟𝑒(); //
<< "𝐼𝑛𝑑𝑖𝑞𝑢𝑒 𝑒𝑙 𝑛𝑖𝑣𝑒𝑙 𝑑𝑒 𝑢𝑟𝑔𝑒𝑛𝑐𝑖𝑎: "; 𝑐𝑖𝑛 >> 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑛𝑖𝑣𝑒𝑙𝑈𝑟𝑔𝑒𝑛𝑐𝑖𝑎; 𝑤ℎ𝑖𝑙𝑒 (𝑐𝑖𝑛.𝑓𝑎𝑖𝑙() || 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑛𝑖𝑣𝑒𝑙𝑈𝑟𝑔𝑒𝑛𝑐𝑖𝑎 < 1 ||
𝑛𝑠𝑒𝑟𝑡(𝑖𝑡, 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒); 𝑐𝑜𝑢𝑡 << "𝐸𝑙 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒 ℎ𝑎 𝑠𝑖𝑑𝑜 𝑢𝑏𝑖𝑐𝑎𝑑𝑜 𝑒𝑛 𝑙𝑎 𝑙𝑖𝑠𝑡𝑎 𝑑𝑒 𝑒𝑠𝑝𝑒𝑟𝑎 𝑐𝑜𝑛 𝑒𝑥𝑖𝑡𝑜." << 𝑒𝑛𝑑𝑙;}// 𝐹𝑢𝑛𝑐𝑖𝑜𝑛 𝑝𝑎𝑟𝑎 𝑒𝑙𝑖𝑚𝑖𝑛𝑎𝑟
𝑜 𝑖𝑡 = 𝑓𝑖𝑛𝑑_𝑖𝑓(𝑙𝑖𝑠𝑡𝑎𝐸𝑠𝑝𝑒𝑟𝑎.𝑏𝑒𝑔𝑖𝑛(), 𝑙𝑖𝑠𝑡𝑎𝐸𝑠𝑝𝑒𝑟𝑎.𝑒𝑛𝑑(), [&𝑛𝑜𝑚𝑏𝑟𝑒](𝑐𝑜𝑛𝑠𝑡 𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒 &𝑝) { 𝑟𝑒𝑡𝑢𝑟𝑛 𝑝.𝑛𝑜𝑚𝑏𝑟𝑒 == 𝑛𝑜𝑚𝑏𝑟𝑒; });

𝑛 𝑢𝑠𝑢𝑎𝑟𝑖𝑜 𝑎 𝑙𝑎 𝑙𝑖𝑠𝑡𝑎𝑣𝑜𝑖𝑑 𝑎𝑔𝑟𝑒𝑔𝑎𝑟𝑈𝑠𝑢𝑎𝑟𝑖𝑜(𝑈𝑠𝑢𝑎𝑟𝑖𝑜∗& 𝑐𝑎𝑏𝑒𝑧𝑎, 𝑠𝑡𝑟𝑖𝑛𝑔 𝑡𝑖𝑝𝑜, 𝑠𝑡𝑟𝑖𝑛𝑔 𝑛𝑜𝑚𝑏𝑟𝑒, 𝑠𝑡𝑟𝑖𝑛𝑔 𝑐𝑜𝑛𝑡𝑟𝑎𝑠𝑒𝑛𝑎) { 𝑈𝑠𝑢𝑎𝑟𝑖𝑜∗ 𝑛𝑢𝑒𝑣𝑜
𝑡ℎ() < 6) { 𝑐𝑜𝑢𝑡 << "𝐿𝑎 𝑐𝑜𝑛𝑡𝑟𝑎𝑠𝑒ñ𝑎 𝑑𝑒𝑏𝑒 𝑡𝑒𝑛𝑒𝑟 𝑎𝑙 𝑚𝑒𝑛𝑜𝑠 6 𝑐𝑎𝑟𝑎𝑐𝑡𝑒𝑟𝑒𝑠. 𝑃𝑜𝑟 𝑓𝑎𝑣𝑜𝑟, 𝑖𝑛𝑔𝑟𝑒𝑠𝑒 𝑢𝑛𝑎 𝑐𝑜𝑛𝑡𝑟𝑎𝑠𝑒ñ𝑎 𝑣𝑎𝑙𝑖𝑑𝑎: "; 𝑐𝑖𝑛 >
𝑤ℎ𝑖𝑙𝑒 (𝑐𝑎𝑏𝑒𝑧𝑎 != 𝑛𝑢𝑙𝑙𝑝𝑡𝑟) { 𝑈𝑠𝑢𝑎𝑟𝑖𝑜∗ 𝑡𝑒𝑚𝑝 = 𝑐𝑎𝑏𝑒𝑧𝑎; 𝑐𝑎𝑏𝑒𝑧𝑎 = 𝑐𝑎𝑏𝑒𝑧𝑎−>𝑠𝑖𝑔𝑢𝑖𝑒𝑛𝑡𝑒; 𝑑𝑒𝑙𝑒𝑡𝑒 𝑡𝑒𝑚𝑝; }}// 𝐷𝑒𝑐𝑙𝑎𝑟𝑎𝑐𝑖𝑜𝑛
𝑐𝑜𝑢𝑡 << "3. 𝐴𝑐𝑡𝑢𝑎𝑙𝑖𝑧𝑎𝑟 𝑑𝑎𝑡𝑜𝑠 𝑑𝑒 𝑟𝑒𝑔𝑖𝑠𝑡𝑟𝑜" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "4. 𝑀𝑜𝑠𝑡𝑟𝑎𝑟 𝑑𝑎𝑡𝑜𝑠 𝑑𝑒𝑙 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "5. 𝐴𝑠𝑖𝑔𝑛
𝑐𝑜𝑢𝑡 << "𝐴𝑐𝑡𝑢𝑎𝑙𝑖𝑧𝑎𝑛𝑑𝑜 𝑑𝑎𝑡𝑜𝑠 𝑑𝑒 𝑟𝑒𝑔𝑖𝑠𝑡𝑟𝑜..." << 𝑒𝑛𝑑𝑙; 𝑎𝑐𝑡𝑢𝑎𝑙𝑖𝑧𝑎𝑟𝐷𝑎𝑡𝑜𝑠𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒(𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒); 𝑏𝑟𝑒𝑎𝑘; 𝑐𝑎𝑠𝑒 4
𝑡𝑒); 𝑏𝑟𝑒𝑎𝑘; 𝑐𝑎𝑠𝑒 7: 𝑐𝑜𝑢𝑡 << "𝐸𝑙𝑖𝑚𝑖𝑛𝑎𝑛𝑑𝑜 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒 𝑑𝑒 𝑙𝑖𝑠𝑡𝑎 𝑑𝑒 𝑒𝑠𝑝𝑒𝑟𝑎..." << 𝑒𝑛𝑑𝑙; 𝑒𝑙𝑖𝑚𝑖𝑛𝑎𝑟𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒𝐷𝑒
𝑜𝑢𝑡 << "𝑃𝑜𝑙𝑖𝑐𝑙𝑖𝑛𝑖𝑐𝑜 𝑆𝑎𝑛 𝑉𝑖𝑐𝑒𝑛𝑡𝑒 𝑑𝑒 𝑃𝑎𝑢𝑙" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "∗∗∗" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "1. 𝐼𝑛𝑔𝑟𝑒𝑠𝑎𝑟 𝑐𝑜𝑚𝑜 𝑝𝑒𝑟𝑠𝑜𝑛𝑎𝑙 𝑚𝑒𝑑𝑖𝑐𝑜"
𝑜 𝑣𝑎𝑙𝑖𝑑𝑎. 𝑃𝑜𝑟 𝑓𝑎𝑣𝑜𝑟, 𝑖𝑛𝑔𝑟𝑒𝑠𝑒 𝑢𝑛 𝑛𝑢𝑚𝑒𝑟𝑜 𝑣𝑎𝑙𝑖𝑑𝑜." << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑛𝑡𝑖𝑛𝑢𝑒; } 𝑠𝑤𝑖𝑡𝑐ℎ (𝑜𝑝𝑐𝑖𝑜𝑛) { 𝑐𝑎𝑠𝑒 1: { 𝑠𝑡𝑟𝑖𝑛𝑔
𝑜 𝑖𝑡 = 𝑓𝑖𝑛𝑑_𝑖𝑓(𝑙𝑖𝑠𝑡𝑎𝐸𝑠𝑝𝑒𝑟𝑎.𝑏𝑒𝑔𝑖𝑛(), 𝑙𝑖𝑠𝑡𝑎𝐸𝑠𝑝𝑒𝑟𝑎.𝑒𝑛𝑑(), [&𝑛𝑜𝑚𝑏𝑟𝑒](𝑐𝑜𝑛𝑠𝑡 𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒 &𝑝) { 𝑟𝑒𝑡𝑢𝑟𝑛 𝑝.𝑛𝑜𝑚𝑏𝑟𝑒 == 𝑛𝑜𝑚𝑏𝑟𝑒; });
𝑛 𝑢𝑠𝑢𝑎𝑟𝑖𝑜 𝑎 𝑙𝑎 𝑙𝑖𝑠𝑡𝑎𝑣𝑜𝑖𝑑 𝑎𝑔𝑟𝑒𝑔𝑎𝑟𝑈𝑠𝑢𝑎𝑟𝑖𝑜(𝑈𝑠𝑢𝑎𝑟𝑖𝑜∗& 𝑐𝑎𝑏𝑒𝑧𝑎, 𝑠𝑡𝑟𝑖𝑛𝑔 𝑡𝑖𝑝𝑜, 𝑠𝑡𝑟𝑖𝑛𝑔 𝑛𝑜𝑚𝑏𝑟𝑒, 𝑠𝑡𝑟𝑖𝑛𝑔 𝑐𝑜𝑛𝑡𝑟𝑎𝑠𝑒𝑛𝑎) { 𝑈𝑠𝑢𝑎𝑟𝑖𝑜∗ 𝑛𝑢𝑒𝑣𝑜
𝑡ℎ() < 6) { 𝑐𝑜𝑢𝑡 << "𝐿𝑎 𝑐𝑜𝑛𝑡𝑟𝑎𝑠𝑒ñ𝑎 𝑑𝑒𝑏𝑒 𝑡𝑒𝑛𝑒𝑟 𝑎𝑙 𝑚𝑒𝑛𝑜𝑠 6 𝑐𝑎𝑟𝑎𝑐𝑡𝑒𝑟𝑒𝑠. 𝑃𝑜𝑟 𝑓𝑎𝑣𝑜𝑟, 𝑖𝑛𝑔𝑟𝑒𝑠𝑒 𝑢𝑛𝑎 𝑐𝑜𝑛𝑡𝑟𝑎𝑠𝑒ñ𝑎 𝑣𝑎𝑙𝑖𝑑𝑎: "; 𝑐𝑖𝑛 >
𝑤ℎ𝑖𝑙𝑒 (𝑐𝑎𝑏𝑒𝑧𝑎 != 𝑛𝑢𝑙𝑙𝑝𝑡𝑟) { 𝑈𝑠𝑢𝑎𝑟𝑖𝑜∗ 𝑡𝑒𝑚𝑝 = 𝑐𝑎𝑏𝑒𝑧𝑎; 𝑐𝑎𝑏𝑒𝑧𝑎 = 𝑐𝑎𝑏𝑒𝑧𝑎−>𝑠𝑖𝑔𝑢𝑖𝑒𝑛𝑡𝑒; 𝑑𝑒𝑙𝑒𝑡𝑒 𝑡𝑒𝑚𝑝; }}// 𝐷𝑒𝑐𝑙𝑎𝑟𝑎𝑐𝑖𝑜𝑛
𝑐𝑜𝑢𝑡 << "3. 𝐴𝑐𝑡𝑢𝑎𝑙𝑖𝑧𝑎𝑟 𝑑𝑎𝑡𝑜𝑠 𝑑𝑒 𝑟𝑒𝑔𝑖𝑠𝑡𝑟𝑜" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "4. 𝑀𝑜𝑠𝑡𝑟𝑎𝑟 𝑑𝑎𝑡𝑜𝑠 𝑑𝑒𝑙 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "5. 𝐴𝑠𝑖𝑔𝑛
𝑐𝑜𝑢𝑡 << "𝐴𝑐𝑡𝑢𝑎𝑙𝑖𝑧𝑎𝑛𝑑𝑜 𝑑𝑎𝑡𝑜𝑠 𝑑𝑒 𝑟𝑒𝑔𝑖𝑠𝑡𝑟𝑜..." << 𝑒𝑛𝑑𝑙; 𝑎𝑐𝑡𝑢𝑎𝑙𝑖𝑧𝑎𝑟𝐷𝑎𝑡𝑜𝑠𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒(𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒); 𝑏𝑟𝑒𝑎𝑘; 𝑐𝑎𝑠𝑒 4
𝑡𝑒); 𝑏𝑟𝑒𝑎𝑘; 𝑐𝑎𝑠𝑒 7: 𝑐𝑜𝑢𝑡 << "𝐸𝑙𝑖𝑚𝑖𝑛𝑎𝑛𝑑𝑜 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒 𝑑𝑒 𝑙𝑖𝑠𝑡𝑎 𝑑𝑒 𝑒𝑠𝑝𝑒𝑟𝑎..." << 𝑒𝑛𝑑𝑙; 𝑒𝑙𝑖𝑚𝑖𝑛𝑎𝑟𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒𝐷𝑒
𝑜𝑢𝑡 << "𝑃𝑜𝑙𝑖𝑐𝑙𝑖𝑛𝑖𝑐𝑜 𝑆𝑎𝑛 𝑉𝑖𝑐𝑒𝑛𝑡𝑒 𝑑𝑒 𝑃𝑎𝑢𝑙" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "∗∗∗" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "1. 𝐼𝑛𝑔𝑟𝑒𝑠𝑎𝑟 𝑐𝑜𝑚𝑜 𝑝𝑒𝑟𝑠𝑜𝑛𝑎𝑙 𝑚𝑒𝑑𝑖𝑐𝑜"
𝑜 𝑣𝑎𝑙𝑖𝑑𝑎. 𝑃𝑜𝑟 𝑓𝑎𝑣𝑜𝑟, 𝑖𝑛𝑔𝑟𝑒𝑠𝑒 𝑢𝑛 𝑛𝑢𝑚𝑒𝑟𝑜 𝑣𝑎𝑙𝑖𝑑𝑜." << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑛𝑡𝑖𝑛𝑢𝑒; } 𝑠𝑤𝑖𝑡𝑐ℎ (𝑜𝑝𝑐𝑖𝑜𝑛) { 𝑐𝑎𝑠𝑒 1: { 𝑠𝑡𝑟𝑖𝑛𝑔
} 𝑤ℎ𝑖𝑙𝑒 (!𝑐𝑟𝑒𝑑𝑒𝑛𝑐𝑖𝑎𝑙𝑒𝑠𝑉𝑎𝑙𝑖𝑑𝑎𝑠); 𝑏𝑟𝑒𝑎𝑘; } 𝑐𝑎𝑠𝑒 2: { 𝑠𝑡𝑟𝑖𝑛𝑔 𝑛𝑜𝑚𝑏𝑟𝑒, 𝑐𝑜𝑛𝑡𝑟𝑎𝑠𝑒𝑛𝑎; 𝑏𝑜𝑜𝑙 𝑐𝑟𝑒
𝑤ℎ𝑖𝑙𝑒 (!𝑐𝑟𝑒𝑑𝑒𝑛𝑐𝑖𝑎𝑙𝑒𝑠𝑉𝑎𝑙𝑖𝑑𝑎𝑠); 𝑏𝑟𝑒𝑎𝑘; } 𝑐𝑎𝑠𝑒 3: { 𝑠𝑡𝑟𝑖𝑛𝑔 𝑛𝑜𝑚𝑏𝑟𝑒, 𝑐𝑜𝑛𝑡𝑟𝑎𝑠𝑒𝑛𝑎; 𝑝𝑒𝑑𝑖𝑟𝐷𝑎𝑡𝑜𝑠(𝑛𝑜𝑚𝑏𝑟
𝑢𝑡 << "𝑆𝑎𝑙𝑖𝑒𝑛𝑑𝑜..." << 𝑒𝑛𝑑𝑙; 𝑏𝑟𝑒𝑎𝑘; 𝑑𝑒𝑓𝑎𝑢𝑙𝑡: 𝑐𝑜𝑢𝑡 << "𝑂𝑝𝑐𝑖𝑜𝑛 𝑛𝑜 𝑣𝑎𝑙𝑖𝑑𝑎" << 𝑒𝑛𝑑𝑙; 𝑏𝑟𝑒𝑎𝑘; } } 𝑤ℎ
𝑟𝑖𝑎𝑙(𝑐𝑜𝑛𝑠𝑡 𝑠𝑡𝑟𝑖𝑛𝑔& 𝑛𝑜𝑚𝑏𝑟𝑒𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒, 𝑐𝑜𝑛𝑠𝑡 𝐻𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙𝑀𝑒𝑑𝑖𝑐𝑜& 𝑟𝑒𝑔𝑖𝑠𝑡𝑟𝑜) { ℎ𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙𝑃𝑜𝑟𝑁𝑜𝑚𝑏𝑟𝑒[𝑛𝑜𝑚𝑏𝑟𝑒𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒].𝑝𝑢𝑠ℎ_𝑏𝑎𝑐𝑘(𝑟𝑒
𝑒𝑐𝑡𝑜𝑟<𝐻𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙𝑀𝑒𝑑𝑖𝑐𝑜>& ℎ𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙) { 𝑐𝑜𝑢𝑡 << "\𝑛𝐻𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙 𝑀𝑒𝑑𝑖𝑐𝑜:" << 𝑒𝑛𝑑𝑙; 𝑖𝑓 (ℎ𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙.𝑒𝑚𝑝𝑡𝑦()) { 𝑐𝑜𝑢𝑡 << "𝐸𝑙 ℎ𝑖𝑠𝑡𝑜
<< 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << 𝑒𝑛𝑑𝑙; } }}// 𝐹𝑢𝑛𝑐𝑖𝑜𝑛 𝑝𝑎𝑟𝑎 𝑎𝑐𝑡𝑢𝑎𝑙𝑖𝑧𝑎𝑟 𝑢𝑛 𝑟𝑒𝑔𝑖𝑠𝑡𝑟𝑜 𝑒𝑠𝑝𝑒𝑐𝑖𝑓𝑖𝑐𝑜 𝑒𝑛 𝑒𝑙 ℎ𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙 𝑚𝑒𝑑𝑖𝑐𝑜𝑣𝑜𝑖𝑑 𝑎𝑐𝑡𝑢𝑎𝑙𝑖𝑧𝑎𝑟
<< 𝑒𝑛𝑑𝑙; } } 𝑒𝑙𝑠𝑒 { 𝑐𝑜𝑢𝑡 << "𝑁𝑜 𝑠𝑒 𝑒𝑛𝑐𝑜𝑛𝑡𝑟𝑜 ℎ𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙 𝑚𝑒𝑑𝑖𝑐𝑜 𝑝𝑎𝑟𝑎 " << 𝑛𝑜𝑚𝑏𝑟𝑒𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒 << 𝑒𝑛𝑑𝑙; }}// 𝐹𝑢𝑛𝑐𝑖𝑜𝑛 𝑝𝑎𝑟𝑎
𝑜𝑢𝑡 << 𝑏𝑎𝑠𝑒𝐼𝑛𝑑𝑒𝑥 + 2 << ". 𝑀𝑜𝑡𝑖𝑣𝑜 𝑑𝑒 𝑐𝑜𝑛𝑠𝑢𝑙𝑡𝑎: " << ℎ𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙[𝑖].𝑚𝑜𝑡𝑖𝑣𝑜𝐶𝑜𝑛𝑠𝑢𝑙𝑡𝑎 << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << 𝑏𝑎𝑠𝑒𝐼𝑛𝑑𝑒𝑥 + 3 << ".

< "𝐼𝑛𝑔𝑟𝑒𝑠𝑒 𝑒𝑙 𝑛𝑢𝑚𝑒𝑟𝑜 𝑑𝑒 𝑖𝑛𝑑𝑖𝑐𝑒 𝑑𝑒𝑙 𝑟𝑒𝑔𝑖𝑠𝑡𝑟𝑜 𝑞𝑢𝑒 𝑑𝑒𝑠𝑒𝑎 𝑎𝑐𝑡𝑢𝑎𝑙𝑖𝑧𝑎𝑟: "; 𝑐𝑖𝑛 >> 𝑖𝑛𝑑𝑖𝑐𝑒; 𝑖𝑓 (𝑖𝑛𝑑𝑖𝑐𝑒 > 0 && 𝑖𝑛𝑑𝑖𝑐𝑒 <= ℎ𝑖𝑠𝑡𝑜𝑟𝑖𝑎
𝑐𝑎𝑠𝑒 1: 𝑐𝑜𝑢𝑡 << "𝐼𝑛𝑔𝑟𝑒𝑠𝑒 𝑒𝑙 𝑛𝑢𝑒𝑣𝑜 𝑚𝑜𝑡𝑖𝑣𝑜 𝑑𝑒 𝑐𝑜𝑛𝑠𝑢𝑙𝑡𝑎: "; 𝑐𝑖𝑛.𝑖𝑔𝑛𝑜𝑟𝑒(); 𝑔𝑒𝑡𝑙𝑖𝑛𝑒(𝑐𝑖𝑛, 𝑟𝑒𝑔𝑖𝑠𝑡𝑟𝑜.𝑚𝑜
𝑎𝑐𝑡𝑢𝑎𝑙𝑖𝑧𝑎𝑟𝑅𝑒𝑔𝑖𝑠𝑡𝑟𝑜𝐻𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙(𝑛𝑜𝑚𝑏𝑟𝑒𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒, 𝑟𝑒𝑔𝑖𝑠𝑡𝑟𝑜𝐼𝑛𝑑𝑒𝑥, 𝑟𝑒𝑔𝑖𝑠𝑡𝑟𝑜); } 𝑒𝑙𝑠𝑒 { 𝑐𝑜𝑢𝑡 << "𝐼𝑛𝑑𝑖𝑐𝑒 𝑓𝑢𝑒𝑟𝑎 𝑑𝑒 𝑟𝑎𝑛𝑔𝑜."
<< 𝑒𝑛𝑑𝑙; 𝑓𝑜𝑟 (𝑠𝑖𝑧𝑒_𝑡 𝑖 = 0; 𝑖 < ℎ𝑜𝑠𝑝𝑖𝑡𝑎𝑙𝑒𝑠.𝑠𝑖𝑧𝑒(); ++𝑖) { 𝑐𝑜𝑢𝑡 << 𝑖 + 1 << ". 𝑁𝑜𝑚𝑏𝑟𝑒: " << ℎ𝑜𝑠𝑝𝑖𝑡𝑎𝑙𝑒𝑠[𝑖].𝑛𝑜𝑚𝑏𝑟𝑒 << ", 𝐶𝑜𝑛𝑡𝑎
𝑎𝑙𝑠𝑒; 𝑤ℎ𝑖𝑙𝑒 (!𝑜𝑝𝑐𝑖𝑜𝑛𝑉𝑎𝑙𝑖𝑑𝑎) { 𝑐𝑜𝑢𝑡 << "𝐼𝑛𝑔𝑟𝑒𝑠𝑒 𝑒𝑙 𝑛𝑢𝑚𝑒𝑟𝑜 𝑑𝑒𝑙 ℎ𝑜𝑠𝑝𝑖𝑡𝑎𝑙 𝑎𝑙 𝑞𝑢𝑒 𝑑𝑒𝑠𝑒𝑎 𝑡𝑟𝑎𝑠𝑙𝑎𝑑𝑎𝑟 𝑎𝑙 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒: "; 𝑐𝑖𝑛 >> 𝑜𝑝𝑐
ℎ𝑜𝑠𝑝𝑖𝑡𝑎𝑙𝑒𝑠[𝑜𝑝𝑐𝑖𝑜𝑛 − 1].𝑐𝑜𝑛𝑡𝑎𝑐𝑡𝑜 << 𝑒𝑛𝑑𝑙;}// 𝐹𝑢𝑛𝑐𝑖𝑜𝑛 𝑝𝑎𝑟𝑎 𝑔𝑢𝑎𝑟𝑑𝑎𝑟 𝑟𝑒𝑐𝑒𝑡𝑎𝑠 𝑒𝑛 𝑢𝑛 𝑎𝑟𝑐ℎ𝑖𝑣𝑜 .𝑡𝑥𝑡𝑣𝑜𝑖𝑑 𝑔𝑢𝑎𝑟𝑑𝑎𝑟𝑅𝑒𝑐𝑒𝑡𝑎𝑠𝐸𝑛𝐴𝑟𝑐ℎ𝑖𝑣𝑜(
𝑡𝑎.𝑐𝑎𝑑𝑎𝐶𝑢𝑎𝑛𝑡𝑎𝑠𝐻𝑜𝑟𝑎𝑠 << "\𝑛"; 𝑎𝑟𝑐ℎ𝑖𝑣𝑜 << "−−−−−−−−−−−−−−−−−−−−−−−−−−−\𝑛"; } 𝑎𝑟𝑐ℎ𝑖𝑣𝑜.𝑐𝑙𝑜𝑠𝑒();
𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "2. 𝐵𝑢𝑠𝑐𝑎𝑟 ℎ𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙 𝑚𝑒𝑑𝑖𝑐𝑜" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "3. 𝐴𝑐𝑡𝑢𝑎𝑙𝑖𝑧𝑎𝑟 ℎ𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙 𝑚𝑒𝑑𝑖𝑐𝑜" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "4. 𝐴𝑠
𝑢𝑒; } 𝑠𝑤𝑖𝑡𝑐ℎ (𝑜𝑝𝑐𝑖𝑜𝑛) { 𝑐𝑎𝑠𝑒 1: { 𝑠𝑡𝑟𝑖𝑛𝑔 𝑛𝑜𝑚𝑏𝑟𝑒𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒; 𝑏𝑜𝑜𝑙 𝑛𝑜𝑚𝑏𝑟𝑒𝑉𝑎𝑙𝑖𝑑𝑜 = 𝑓𝑎𝑙𝑠𝑒; 𝑐𝑜𝑢𝑡 << "𝐼𝑛𝑔𝑟𝑒𝑠𝑒 𝑒
𝐹𝑒𝑐ℎ𝑎 𝑑𝑒 𝑐𝑜𝑛𝑠𝑢𝑙𝑡𝑎 (𝑓𝑜𝑟𝑚𝑎𝑡𝑜 𝑑𝑑/𝑚𝑚/𝑎𝑎𝑎𝑎): "; 𝑔𝑒𝑡𝑙𝑖𝑛𝑒(𝑐𝑖𝑛, 𝑛𝑢𝑒𝑣𝑜𝑅𝑒𝑔𝑖𝑠𝑡𝑟𝑜.𝑓𝑒𝑐ℎ𝑎𝐶𝑜𝑛𝑠𝑢𝑙𝑡𝑎); 𝑐𝑜𝑢𝑡 << "𝑀𝑜𝑡𝑖𝑣𝑜 𝑑𝑒 𝑐
𝑔𝑟𝑒𝑠𝑒 𝑒𝑙 𝑛𝑜𝑚𝑏𝑟𝑒 𝑑𝑒𝑙 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒: "; 𝑐𝑖𝑛.𝑖𝑔𝑛𝑜𝑟𝑒(); 𝑔𝑒𝑡𝑙𝑖𝑛𝑒(𝑐𝑖𝑛, 𝑛𝑜𝑚𝑏𝑟𝑒𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒); 𝑣𝑒𝑐𝑡𝑜𝑟<𝐻𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙𝑀𝑒𝑑𝑖𝑐𝑜> ℎ𝑖
𝑚𝑎𝑛𝑒𝑗𝑎𝑟𝑇𝑟𝑎𝑠𝑙𝑎𝑑𝑜(); 𝑏𝑟𝑒𝑎𝑘; 𝑐𝑎𝑠𝑒 6: 𝑔𝑢𝑎𝑟𝑑𝑎𝑟𝑅𝑒𝑐𝑒𝑡𝑎𝑠𝐸𝑛𝐴𝑟𝑐ℎ𝑖𝑣𝑜(𝑟𝑒𝑐𝑒𝑡𝑎𝑠); 𝑏𝑟𝑒𝑎𝑘; 𝑐𝑎𝑠𝑒 7:
𝑑𝑒 𝑢𝑠𝑢𝑎𝑟𝑖𝑜𝑠 𝑙𝑖𝑏𝑒𝑟𝑎𝑟𝑀𝑒𝑚𝑜𝑟𝑖𝑎(𝑙𝑖𝑠𝑡𝑎𝑀𝑒𝑑𝑖𝑐𝑜𝑠); 𝑙𝑖𝑏𝑒𝑟𝑎𝑟𝑀𝑒𝑚𝑜𝑟𝑖𝑎(𝑙𝑖𝑠𝑡𝑎𝐸𝑛𝑓𝑒𝑟𝑚𝑒𝑟𝑎𝑠); 𝑟𝑒𝑡𝑢𝑟𝑛 0;}48
 𝑢𝑐𝑡 𝑅𝑒𝑐𝑒𝑡𝑎 { 𝑠𝑡𝑟𝑖𝑛𝑔 𝑛𝑜𝑚𝑏𝑟𝑒𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒; 𝑠𝑡𝑟𝑖𝑛𝑔
𝑖𝑛𝑑𝑒𝑥 = 0) { 𝑖𝑓 (𝑖𝑛𝑑𝑒𝑥 == 𝑠𝑡𝑟.𝑙𝑒𝑛𝑔𝑡ℎ()) 𝑟𝑒𝑡𝑢𝑟𝑛 𝑡𝑟𝑢𝑒; 𝑖𝑓
< "𝐼𝑛𝑔𝑟𝑒𝑠𝑒 𝑛𝑜𝑚𝑏𝑟𝑒 𝑑𝑒𝑙 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒: "; 𝑔𝑒𝑡𝑙𝑖𝑛𝑒(𝑐𝑖𝑛,
𝑛𝑐𝑜𝑟𝑟𝑒𝑐𝑡𝑜. 𝑆𝑜𝑙𝑜 𝑠𝑒 𝑝𝑒𝑟𝑚𝑖𝑡𝑒𝑛 𝑙𝑒𝑡𝑟𝑎𝑠, 𝑛𝑢𝑚𝑒𝑟𝑜𝑠 𝑦 𝑒𝑠𝑝𝑎𝑐𝑖𝑜𝑠.
; 𝑖𝑓 (𝑐𝑖𝑛.𝑓𝑎𝑖𝑙() || 𝑛𝑢𝑒𝑣𝑎𝑅𝑒𝑐𝑒𝑡𝑎.𝑛𝑢𝑚𝑒𝑟𝑜𝐷𝑖𝑎𝑠 <= 0) {
𝐶𝑢𝑎𝑛𝑡𝑎𝑠𝐻𝑜𝑟𝑎𝑠 <= 0) { 𝑐𝑖𝑛.𝑐𝑙𝑒𝑎𝑟();
𝑐𝑡𝑢𝑟𝑎 𝑝𝑎𝑟𝑎 𝑎𝑙𝑚𝑎𝑐𝑒𝑛𝑎𝑟 𝑙𝑜𝑠 𝑑𝑎𝑡𝑜𝑠 𝑑𝑒𝑙 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒𝑠𝑡𝑟𝑢𝑐𝑡
𝑢𝑚𝑒 𝑞𝑢𝑒 𝑢𝑛 𝐷𝑁𝐼 𝑣𝑎𝑙𝑖𝑑𝑜 𝑡𝑖𝑒𝑛𝑒 8 𝑑𝑖𝑔𝑖𝑡𝑜𝑠 𝑖𝑓 (𝑑𝑛𝑖.𝑙𝑒𝑛𝑔𝑡ℎ() !=
𝑟𝑠𝑖𝑣𝑎 𝑝𝑎𝑟𝑎 𝑣𝑎𝑙𝑖𝑑𝑎𝑟 𝑠𝑖 𝑒𝑙 𝑛𝑜𝑚𝑏𝑟𝑒 𝑖𝑛𝑔𝑟𝑒𝑠𝑎𝑑𝑜 𝑐𝑜𝑛𝑡𝑖𝑒𝑛𝑒
𝑜𝐶𝑖𝑣𝑖𝑙𝑉𝑎𝑙𝑖𝑑𝑜(𝑐ℎ𝑎𝑟 𝑒𝑠𝑡𝑎𝑑𝑜𝐶𝑖𝑣𝑖𝑙) { 𝑟𝑒𝑡𝑢𝑟𝑛 𝑒𝑠𝑡𝑎𝑑𝑜𝐶𝑖𝑣𝑖𝑙 == ′𝑆′
𝑜. 𝐼𝑛𝑔𝑟𝑒𝑠𝑒 𝑠𝑜𝑙𝑜 𝑐𝑎𝑟𝑎𝑐𝑡𝑒𝑟𝑒𝑠 𝑎𝑙𝑓𝑎𝑏𝑒𝑡𝑖𝑐𝑜𝑠." << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡
>> 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑔𝑒𝑛𝑒𝑟𝑜; 𝑖𝑓 (!
<< "𝐷𝑁𝐼 (8 𝑑𝑖𝑔𝑖𝑡𝑜𝑠): "; 𝑐𝑖𝑛 >> 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑑𝑛𝑖; 𝑖𝑓 (!
𝑒.𝑐𝑒𝑙𝑢𝑙𝑎𝑟)); 𝑐𝑜𝑢𝑡 << "𝐶𝑜𝑟𝑟𝑒𝑜 𝑒𝑙𝑒𝑐𝑡𝑟𝑜𝑛𝑖𝑐𝑜: "; 𝑐𝑖𝑛 >>
𝑜𝑛𝑖𝑐𝑜" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "10. 𝑆𝑎𝑙𝑖𝑟" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡
𝑔𝑒𝑡𝑙𝑖𝑛𝑒(𝑐𝑖𝑛, 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑎𝑝𝑒𝑙𝑙𝑖𝑑𝑜); 𝑖𝑓 (!

𝑣𝑖𝑙 𝑛𝑜 𝑣𝑎𝑙𝑖𝑑𝑜. 𝑃𝑜𝑟 𝑓𝑎𝑣𝑜𝑟, 𝑖𝑛𝑔𝑟𝑒𝑠𝑒 ′𝑆′, ′𝐶′, ′𝑉′ 𝑜 ′𝐷′." << 𝑒𝑛𝑑𝑙;
𝑡𝑙𝑖𝑛𝑒(𝑐𝑖𝑛, 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑑𝑖𝑟𝑒𝑐𝑐𝑖𝑜𝑛); 𝑏𝑟𝑒𝑎𝑘; 𝑐𝑎𝑠𝑒 8:
"𝑂𝑝𝑐𝑖𝑜𝑛 𝑛𝑜 𝑣𝑎𝑙𝑖𝑑𝑎" << 𝑒𝑛𝑑𝑙; 𝑏𝑟𝑒𝑎𝑘; } } 𝑤ℎ𝑖𝑙𝑒
𝑏𝑟𝑒𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒; // 𝐺𝑢𝑎𝑟𝑑𝑎𝑟 𝑒𝑙 𝑛𝑜𝑚𝑏𝑟𝑒 𝑑𝑒𝑙 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒 } }
𝑒 (!(𝑐𝑖𝑛 >> 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑡𝑒𝑚𝑝𝑒𝑟𝑎𝑡𝑢𝑟𝑎)) { 𝑐𝑖𝑛.𝑐𝑙𝑒𝑎𝑟();
𝑟𝑒𝑎𝑚𝑠𝑖𝑧𝑒>::𝑚𝑎𝑥(), ′\𝑛′); 𝑐𝑜𝑢𝑡 << "𝐸𝑛𝑡𝑟𝑎𝑑𝑎 𝑛𝑜 𝑣𝑎𝑙𝑖𝑑𝑎.
17) << 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑡𝑎𝑙𝑙𝑎 << " |" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "|
𝑢𝑡 << 𝑠𝑡𝑟𝑖𝑛𝑔(𝑎𝑛𝑐ℎ𝑜, ′−′) << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "| " << 𝑙𝑒𝑓𝑡
𝑒𝑓𝑡 << 𝑠𝑒𝑡𝑤(𝑎𝑛𝑐ℎ𝑜 − 16) << 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑒𝑠𝑡𝑎𝑑𝑜𝐶𝑖𝑣𝑖𝑙 << " |"
&𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒) { 𝑐𝑜𝑢𝑡 << "𝐼𝑛𝑔𝑟𝑒𝑠𝑒 𝑒𝑙 𝑛𝑜𝑚𝑏𝑟𝑒 𝑑𝑒𝑙 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒:
𝑐𝑜𝑢𝑡 << "7. 𝑁𝑢𝑡𝑟𝑖𝑐𝑖𝑜𝑛\𝑛"; 𝑐𝑜𝑢𝑡 << "8. 𝑇𝑒𝑟𝑎𝑝𝑖𝑎 𝑓𝑖𝑠𝑖𝑐𝑎\𝑛";
𝑒𝑠𝑝𝑜𝑛𝑑𝑖𝑒𝑛𝑡𝑒 𝑎 𝑙𝑎 𝑒𝑠𝑝𝑒𝑐𝑖𝑎𝑙𝑖𝑑𝑎𝑑 𝑎𝑠𝑖𝑔𝑛𝑎𝑑𝑎: "; } }
𝑏𝑢𝑓𝑓𝑒𝑟 𝑑𝑒𝑙 𝑡𝑒𝑐𝑙𝑎𝑑𝑜 𝑔𝑒𝑡𝑙𝑖𝑛𝑒(𝑐𝑖𝑛,
𝑛𝑡𝑒: "; 𝑐𝑖𝑛.𝑖𝑔𝑛𝑜𝑟𝑒(); // 𝐿𝑖𝑚𝑝𝑖𝑎𝑟 𝑒𝑙 𝑏𝑢𝑓𝑓𝑒𝑟 𝑑𝑒𝑙 𝑡𝑒𝑐𝑙𝑎𝑑𝑜
𝑒.𝑛𝑖𝑣𝑒𝑙𝑈𝑟𝑔𝑒𝑛𝑐𝑖𝑎 < 1 || 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒.𝑛𝑖𝑣𝑒𝑙𝑈𝑟𝑔𝑒𝑛𝑐𝑖𝑎 > 5)
𝐹𝑢𝑛𝑐𝑖𝑜𝑛 𝑝𝑎𝑟𝑎 𝑒𝑙𝑖𝑚𝑖𝑛𝑎𝑟 𝑎 𝑢𝑛 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒 𝑑𝑒 𝑙𝑎 𝑙𝑖𝑠𝑡𝑎 𝑑𝑒
𝑟𝑒 == 𝑛𝑜𝑚𝑏𝑟𝑒; }); 𝑖𝑓 (𝑖𝑡 != 𝑙𝑖𝑠𝑡𝑎𝐸𝑠𝑝𝑒𝑟𝑎.𝑒𝑛𝑑())

𝑛𝑎) { 𝑈𝑠𝑢𝑎𝑟𝑖𝑜∗ 𝑛𝑢𝑒𝑣𝑜 = 𝑐𝑟𝑒𝑎𝑟𝑈𝑠𝑢𝑎𝑟𝑖𝑜(𝑡𝑖𝑝𝑜, 𝑛𝑜𝑚𝑏𝑟𝑒,

𝑠𝑒ñ𝑎 𝑣𝑎𝑙𝑖𝑑𝑎: "; 𝑐𝑖𝑛 >> 𝑐𝑜𝑛𝑡𝑟𝑎𝑠𝑒𝑛𝑎; }}// 𝐹𝑢𝑛𝑐𝑖𝑜𝑛 𝑝𝑎𝑟𝑎
𝑚𝑝; }}// 𝐷𝑒𝑐𝑙𝑎𝑟𝑎𝑐𝑖𝑜𝑛 𝑑𝑒 𝑙𝑎 𝑓𝑢𝑛𝑐𝑖𝑜𝑛 𝑝𝑎𝑟𝑎 𝑚𝑜𝑠𝑡𝑟𝑎𝑟 𝑒𝑙
𝑙; 𝑐𝑜𝑢𝑡 << "5. 𝐴𝑠𝑖𝑔𝑛𝑎𝑟 𝑒𝑠𝑝𝑒𝑐𝑖𝑎𝑙𝑖𝑑𝑎𝑑 𝑦 𝑚𝑒𝑑𝑖𝑐𝑜" << 𝑒𝑛𝑑𝑙;
𝑏𝑟𝑒𝑎𝑘; 𝑐𝑎𝑠𝑒 4: 𝑐𝑜𝑢𝑡 << "𝑀𝑜𝑠𝑡𝑟𝑎𝑛𝑑𝑜
𝑒𝑙𝑖𝑚𝑖𝑛𝑎𝑟𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒𝐷𝑒𝐿𝑖𝑠𝑡𝑎(𝑙𝑖𝑠𝑡𝑎𝐸𝑠𝑝𝑒𝑟𝑎); 𝑏𝑟𝑒𝑎𝑘;
𝑜𝑚𝑜 𝑝𝑒𝑟𝑠𝑜𝑛𝑎𝑙 𝑚𝑒𝑑𝑖𝑐𝑜" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "2. 𝐼𝑛𝑔𝑟𝑒𝑠𝑎𝑟
𝑐𝑎𝑠𝑒 1: { 𝑠𝑡𝑟𝑖𝑛𝑔 𝑛𝑜𝑚𝑏𝑟𝑒, 𝑐𝑜𝑛𝑡𝑟𝑎𝑠𝑒𝑛𝑎; 𝑏𝑜𝑜𝑙
 𝑟𝑒 == 𝑛𝑜𝑚𝑏𝑟𝑒; }); 𝑖𝑓 (𝑖𝑡 != 𝑙𝑖𝑠𝑡𝑎𝐸𝑠𝑝𝑒𝑟𝑎.𝑒𝑛𝑑())
𝑛𝑎) { 𝑈𝑠𝑢𝑎𝑟𝑖𝑜∗ 𝑛𝑢𝑒𝑣𝑜 = 𝑐𝑟𝑒𝑎𝑟𝑈𝑠𝑢𝑎𝑟𝑖𝑜(𝑡𝑖𝑝𝑜, 𝑛𝑜𝑚𝑏𝑟𝑒,
𝑠𝑒ñ𝑎 𝑣𝑎𝑙𝑖𝑑𝑎: "; 𝑐𝑖𝑛 >> 𝑐𝑜𝑛𝑡𝑟𝑎𝑠𝑒𝑛𝑎; }}// 𝐹𝑢𝑛𝑐𝑖𝑜𝑛 𝑝𝑎𝑟𝑎
𝑚𝑝; }}// 𝐷𝑒𝑐𝑙𝑎𝑟𝑎𝑐𝑖𝑜𝑛 𝑑𝑒 𝑙𝑎 𝑓𝑢𝑛𝑐𝑖𝑜𝑛 𝑝𝑎𝑟𝑎 𝑚𝑜𝑠𝑡𝑟𝑎𝑟 𝑒𝑙
𝑙; 𝑐𝑜𝑢𝑡 << "5. 𝐴𝑠𝑖𝑔𝑛𝑎𝑟 𝑒𝑠𝑝𝑒𝑐𝑖𝑎𝑙𝑖𝑑𝑎𝑑 𝑦 𝑚𝑒𝑑𝑖𝑐𝑜" << 𝑒𝑛𝑑𝑙;
𝑏𝑟𝑒𝑎𝑘; 𝑐𝑎𝑠𝑒 4: 𝑐𝑜𝑢𝑡 << "𝑀𝑜𝑠𝑡𝑟𝑎𝑛𝑑𝑜
𝑒𝑙𝑖𝑚𝑖𝑛𝑎𝑟𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒𝐷𝑒𝐿𝑖𝑠𝑡𝑎(𝑙𝑖𝑠𝑡𝑎𝐸𝑠𝑝𝑒𝑟𝑎); 𝑏𝑟𝑒𝑎𝑘;
𝑜𝑚𝑜 𝑝𝑒𝑟𝑠𝑜𝑛𝑎𝑙 𝑚𝑒𝑑𝑖𝑐𝑜" << 𝑒𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "2. 𝐼𝑛𝑔𝑟𝑒𝑠𝑎𝑟
𝑐𝑎𝑠𝑒 1: { 𝑠𝑡𝑟𝑖𝑛𝑔 𝑛𝑜𝑚𝑏𝑟𝑒, 𝑐𝑜𝑛𝑡𝑟𝑎𝑠𝑒𝑛𝑎; 𝑏𝑜𝑜𝑙
𝑎𝑠𝑒𝑛𝑎; 𝑏𝑜𝑜𝑙 𝑐𝑟𝑒𝑑𝑒𝑛𝑐𝑖𝑎𝑙𝑒𝑠𝑉𝑎𝑙𝑖𝑑𝑎𝑠 = 𝑓𝑎𝑙𝑠𝑒; 𝑑𝑜
𝑝𝑒𝑑𝑖𝑟𝐷𝑎𝑡𝑜𝑠(𝑛𝑜𝑚𝑏𝑟𝑒, 𝑐𝑜𝑛𝑡𝑟𝑎𝑠𝑒𝑛𝑎);
𝑏𝑟𝑒𝑎𝑘; } } 𝑤ℎ𝑖𝑙𝑒 (𝑜𝑝𝑐𝑖𝑜𝑛 != 5);}// 𝐸𝑠𝑡𝑟𝑢𝑐𝑡𝑢𝑟𝑎 𝑝𝑎𝑟𝑎
𝑃𝑎𝑐𝑖𝑒𝑛𝑡𝑒].𝑝𝑢𝑠ℎ_𝑏𝑎𝑐𝑘(𝑟𝑒𝑔𝑖𝑠𝑡𝑟𝑜);}// 𝐹𝑢𝑛𝑐𝑖𝑜𝑛 𝑝𝑎𝑟𝑎 𝑏𝑢𝑠𝑐𝑎𝑟 𝑒𝑙
{ 𝑐𝑜𝑢𝑡 << "𝐸𝑙 ℎ𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙 𝑚𝑒𝑑𝑖𝑐𝑜 𝑒𝑠𝑡𝑎 𝑣𝑎𝑐𝑖𝑜." <<
𝑚𝑒𝑑𝑖𝑐𝑜𝑣𝑜𝑖𝑑 𝑎𝑐𝑡𝑢𝑎𝑙𝑖𝑧𝑎𝑟𝑅𝑒𝑔𝑖𝑠𝑡𝑟𝑜𝐻𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙(𝑐𝑜𝑛𝑠𝑡 𝑠𝑡𝑟𝑖𝑛𝑔&
𝑑𝑙; }}// 𝐹𝑢𝑛𝑐𝑖𝑜𝑛 𝑝𝑎𝑟𝑎 𝑚𝑜𝑠𝑡𝑟𝑎𝑟 𝑒𝑙 ℎ𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙 𝑚𝑒𝑑𝑖𝑐𝑜𝑣𝑜𝑖𝑑
< 𝑏𝑎𝑠𝑒𝐼𝑛𝑑𝑒𝑥 + 3 << ". 𝐷𝑖𝑎𝑔𝑛𝑜𝑠𝑡𝑖𝑐𝑜: " <<

&& 𝑖𝑛𝑑𝑖𝑐𝑒 <= ℎ𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙.𝑠𝑖𝑧𝑒() ∗ 4) { 𝑠𝑖𝑧𝑒_𝑡

𝑔𝑒𝑡𝑙𝑖𝑛𝑒(𝑐𝑖𝑛, 𝑟𝑒𝑔𝑖𝑠𝑡𝑟𝑜.𝑚𝑜𝑡𝑖𝑣𝑜𝐶𝑜𝑛𝑠𝑢𝑙𝑡𝑎); 𝑏𝑟𝑒𝑎𝑘;
𝑛𝑑𝑖𝑐𝑒 𝑓𝑢𝑒𝑟𝑎 𝑑𝑒 𝑟𝑎𝑛𝑔𝑜." << 𝑒𝑛𝑑𝑙; } } 𝑒𝑙𝑠𝑒 { 𝑐𝑜𝑢𝑡 <<
𝑖].𝑛𝑜𝑚𝑏𝑟𝑒 << ", 𝐶𝑜𝑛𝑡𝑎𝑐𝑡𝑜: " << ℎ𝑜𝑠𝑝𝑖𝑡𝑎𝑙𝑒𝑠[𝑖].𝑐𝑜𝑛𝑡𝑎𝑐𝑡𝑜 <<
𝑖𝑒𝑛𝑡𝑒: "; 𝑐𝑖𝑛 >> 𝑜𝑝𝑐𝑖𝑜𝑛; 𝑖𝑓 (𝑐𝑖𝑛.𝑓𝑎𝑖𝑙() || 𝑜𝑝𝑐𝑖𝑜𝑛 <= 0
𝑑𝑎𝑟𝑅𝑒𝑐𝑒𝑡𝑎𝑠𝐸𝑛𝐴𝑟𝑐ℎ𝑖𝑣𝑜(𝑐𝑜𝑛𝑠𝑡 𝑣𝑒𝑐𝑡𝑜𝑟<𝑅𝑒𝑐𝑒𝑡𝑎>& 𝑟𝑒𝑐𝑒𝑡𝑎𝑠)
𝑎𝑟𝑐ℎ𝑖𝑣𝑜.𝑐𝑙𝑜𝑠𝑒(); 𝑐𝑜𝑢𝑡 << "𝑅𝑒𝑐𝑒𝑡𝑎𝑠 𝑔𝑢𝑎𝑟𝑑𝑎𝑑𝑎𝑠 𝑒𝑛
𝑛𝑑𝑙; 𝑐𝑜𝑢𝑡 << "4. 𝐴𝑠𝑖𝑔𝑛𝑎𝑟 𝑟𝑒𝑐𝑒𝑡𝑎 𝑎 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒" << 𝑒𝑛𝑑𝑙;
𝑒; 𝑐𝑜𝑢𝑡 << "𝐼𝑛𝑔𝑟𝑒𝑠𝑒 𝑒𝑙 𝑛𝑜𝑚𝑏𝑟𝑒 𝑑𝑒𝑙 𝑝𝑎𝑐𝑖𝑒𝑛𝑡𝑒: ";
𝑐𝑜𝑢𝑡 << "𝑀𝑜𝑡𝑖𝑣𝑜 𝑑𝑒 𝑐𝑜𝑛𝑠𝑢𝑙𝑡𝑎: "; 𝑔𝑒𝑡𝑙𝑖𝑛𝑒(𝑐𝑖𝑛,
𝑟<𝐻𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙𝑀𝑒𝑑𝑖𝑐𝑜> ℎ𝑖𝑠𝑡𝑜𝑟𝑖𝑎𝑙 =
𝑘; 𝑐𝑎𝑠𝑒 7: 𝑐𝑜𝑢𝑡 << "𝑆𝑎𝑙𝑖𝑒𝑛𝑑𝑜... "; 𝑏𝑟𝑒𝑎𝑘;
Intervalo de confianza de una proporción poblacional - Espejo Agüero, Elar Jammir

Variable: Tipo de Producto (cualitativa nominal)

filtro: Ropa y Accesorio

Etiquetas de fila Cuenta de Tipo de producto

Belleza y skincare 22
Comestibles 20
Electrónicos 54
Fármacos y aseo personal 7
Ropa y accesorios 70
Útiles de estudio 7
Total general 180

Tabla 17
Distribucion de personas según el tipo de producto
Distribucion de personas según el tipo de producto
Tipo de producto fi hi Fi Hi
Belleza y skincare 22 0.12 22 0.12
Comestibles 20 0.11 42 0.23
Electrónicos 54 0.30 96 0.53
Fármacos y aseo personal 7 0.04 103 0.57
Ropa y accesorios 70 0.39 173 0.96
Útiles de estudio 7 0.04 180 1.00
Total general 180 1.0000
Fuente: Inti S.A.C.

Tabla 9
Distribución porcentual de personas según tipo de producto

Distribución porcentual de personas según tipo de producto

45.00%

40.00% 38.89%

35.00%
30.00%
30.00%
Porcentaje de Personas

25.00%

20.00%

15.00%
12.22%
11.11%
10.00%

5.00% 3.89% 3.89%

0.00%
Belleza y skincare Comestibles Electrónicos Fármacos y aseo Ropa y accesorios Útiles de estudio
personal

Tipo de producto
 11.11%

Po
10.00%

5.00% 3.89% 3.89%

0.00%
Belleza y skincare Comestibles Electrónicos Fármacos y aseo Ropa y accesorios Útiles de estudio
personal

Tipo de producto

Fuente: Inti S.A.C.

 INTI S.A.C. ha establecido acuerdos con su diseñador proveedor de ropa y accesorio, co
atraer personas que prefieren adquirir este tipo de productos, para de ofrecerles un diseñ
personalizado en una de las prendas o accesorios que compren el día de la inauguración
porcentaje de las personas que prefieren por este tipo de producto "ropa y accesorios" se
15%.

Se considerará un nivel de confianza del 99%. ¿Se ofrecerá un diseño personalizado en

prendas o accesorios que compre a los nuevos clientes?

𝑋: Número de personas que prefieren productos como ropa y accesorios en compras en

𝑝: Proporción poblacional de las personas que prefieren productos como ropa y accesorio
compras en línea.

1.Datos

𝑛 180
Hi% 𝑝 ̂ 0.3889
12.22%
11.11% 2. Nivel de confianza
30.00%
3.89% Nivel de confianza
38.89% 1-α 0.99
3.89% α 0.01
100.00% z α/2 0.005
1 - α/2 0.995 TABLA
Z 2.58

3. Formula

𝐼𝐶(𝑝): 𝑝 ̂±𝑧_(1−𝛼∕2) √(((𝑝 ) ̂(1−𝑝 ̂))/𝑛)

4. Remplazar
𝐼𝐶(𝑝):0.3889±2.58√((0.3889(1−0.3889))/180)

𝐼𝐶(𝑝):0.3889±2.58√0.00132032

𝐼𝐶(𝑝): 0.3889±0.1257751429

0.29515274354 0.48264725646
 0.2952 0.4826 Redondeado a 4 decimales
𝐼𝐶(𝑝):[0.2952;0.4826]

5. Conclusión
Con un nivel de confianza del 99%, el intervalo [0.2952; 0.4826] contienen la verdadera proporció
poblacional de las personas que prefieren productos como ropa y accesorios en compras en línea. P
se encuentra por encima del 15%, podemos concluir que la empresa Inti S.A.C sí ofrecerá un diseñ
personalizado en una de las prendas o accesorios que compren las personas el día de la inauguració
e ropa y accesorio, con el fin de
de ofrecerles un diseño
día de la inauguración. Sí el
"ropa y accesorios" sea mayor al

eño personalizado en una de las

sorios en compras en línea.

como ropa y accesorios en
n la verdadera proporción
s en compras en línea. Por lo tanto
A.C sí ofrecerá un diseño
s el día de la inauguración.