✨ Escriu un programa que mostri el següent missatge en pantalla:
Hola món!

Fes un programa que mostri una salutació personalitzada a l’usuari.

• 👤 Declara una variable per emmagatzemar el nom d’una persona.
• 🧑‍💻 Demana a l’usuari que introdueixi el seu nom.
• 💬 Mostra un missatge de salutació personalitzat en pantalla, per exemple:
  Hola, Josep!

🧮 Demana dos números decimals a l’usuari i mostra el resultat de les següents operacions:

• ➕ Suma
• ➖ Resta
• ✖️ Multiplicació
• ➗ Divisió

⚠️ Important! No és possible fer una divisió entre zero.
Si això passa, el programa ha de mostrar un missatge d’advertència i evitar el càlcul.

🧮 Demana un número decimal a l’usuari i mostra el resultat de les operacions matemàtiques següents:

• Valor absolut
• Arrel quadrada
• Potència (elevat al quadrat)
• Mòdul
• Cosinus
• Sinus
• Tangent

Fes un programa que calculi l’àrea d’un rectangle.

• 📐 Demana a l’usuari la base i l’alçada d’un rectangle.
• 🧠 Calcula la seva àrea utilitzant la fórmula: Àrea = base × alçada
• 📊 Mostra el resultat per pantalla.

Millora l’exercici 1, per ▶️ demanar a l’usuari la paraula Iniciar

• 🔹 Si s’introdueix correctament, mostrarà: Hola món!
• 🔸 Si s’introdueix qualsevol altre valor, mostrarà: Fi del programa

🚦 Demana a l’usuari que introdueixi una de les paraules següents: "Verd", "Ambre" o "Vermell". Segons el valor introduït, el programa ha de mostrar:

• 🟢 Verd → Pots passar
• 🟡 Ambre → Passa si no hi ha perill
• 🔴 Vermell → Atura’t

Fes un programa que faci el següent:

• 🔢 Demana un número enter a l’usuari.
• 📋 Mostra un missatge que indiqui si el número introduït és parell o senar.

Millora l’exercici 6, per ▶️ demanar a l’usuari la paraula clau: Iniciar i segons l’entrada de l’usuari:

• ✅ Si s’introdueix la paraula correcta, es demanarà a l’usuari un número enter positiu.
• 🔁 El missatge Hola món! es mostrarà tantes vegades com el número introduït.
• ❌ Si la paraula inicial no és vàlida o el número no és positiu, es mostrarà el missatge: Fi del programa.

Fes un programa que faci el següent:

• 🔢 Demana un número enter a l’usuari.
• 🔁 Utilitza un bucle per mostrar per pantalla els números de l’1 al número introduït de forma seqüencial.
• ⏳ Utilitza un altre bucle per mostrar per pantalla els números del número introduït a l’1 de forma decreixent.
• ❌Si el número introduït és menor que 1, mostra un missatge d’error: El número ha de ser més gran o igual a 1.

Fes un programa que faci el següent:

• 🧑‍💻 Demana a l’usuari que introdueixi cinc números enters.
• ➕ Calcula la suma total de tots ells.
• 📊 Mostra el resultat final per pantalla.

Fes un programa que faci el següent:

• 🔢 Demana tres números a l’usuari.
• 🔍 Compara els valors introduïts i mostra quin és el més gran dels tres.

Crea un programa que faci el següent:

• ✖️ Demana un número a l’usuari.
• 🔁 Mostra la seva taula de multiplicar de l’1 al 10.
• 📋 El format a mostrar ha de ser com: 1 x 1 = 1
• ❌ Si el número introduït no és vàlid, mostra un missatge d’error: El número ha de ser més gran o igual a 1.

Millora l’exercici 9, per incloure la funcionalitat bàsica dins d’un procediment, tal com s’indica a continuació:

• 🧩 Escriu un procediment que rebi com a paràmetre un número enter positiu.
• 💬 Aquest procediment ha d’imprimir Hola món! tantes vegades com indiqui el número rebut.
• 🔁 El procediment no ha de retornar cap valor, només mostrar el missatge per pantalla.

El programa principal haurà de:

• ▶️ Demanar a l’usuari la paraula Iniciar.
• ✅ Si la paraula és correcta, demanarà un número enter positiu i cridarà el procediment.
• ❌ Si s’introdueix qualsevol altre valor o el número no és vàlid, mostrarà: Fi del programa.

📝 Defineix un procediment anomenat MostrarMissatge que imprimeixi un missatge motivador per pantalla.
▶️ Crida aquest procediment des de l’algorisme principal per mostrar-lo.

Fes un programa que compleixi el següent:

• 🔢 Demana a l’usuari un número decimal.
• 🔄 Utilitza una funció d’arrodoniment per convertir-lo en un número enter.
• 📊 Mostra el resultat per pantalla.

Fes un programa que faci el següent:

• 🛒 Crea un array de 5 elements.
• ✍️ Demana a l’usuari que introdueixi una data i els productes que necessita comprar.
• 📋 En acabar, mostra la data indicada i el llistat complet per pantalla.

Fes un programa que faci el següent:

• 🔢 Crea un vector (array) de 10 números.
• ✍️ Demana a l’usuari que introdueixi els valors un a un.
• 📊 Calcula i mostra la mitjana dels elements emmagatzemats a l’array.

Desenvolupa un programa que faci el següent:

• 🔢 Crea una matriu 5x5 de tipus numèric.
• 🎲 Inicialitza tota la matriu amb números aleatoris compresos entre 1 i 10.
• ➕ Recorre tota la matriu i calcula la suma total de tots els seus elements.
• 🖥️ Mostra el resultat de la suma per pantalla.

Crea un programa que permeti representar un taulell d’escacs.

• ♟️ Crea una matriu que representi el taulell d’escacs (8x8).
• 🏰 Col·loca totes les peces en les seves posicions inicials per a cada jugador. Cada jugador disposa de:
  • ♚ Un rei (R)
  • ♛ Una dama (D)
  • ♜ Dues torres (T)
  • ♞ Dos cavalls (C)
  • ♝ Dos alfilers (A)
  • ♙ Vuit peons (P)

🎨 Per distingir cada jugador, s’afegirà una lletra:

• ⬜ B per al jugador Blanc.
• ⬛ N per al jugador Negre.

📌 Per exemple, el rei del jugador blanc es representarà com B-R, i el del negre com N-R.

🎮 Escriu un programa que imprimeixi 🖥️ els números de l’1 al 100, un per línia.
🚨 Tanmateix, hauràs de substituir certs números segons aquestes regles:

• 🔺 Múltiples de 3 → mostrar "fizz"
• 🔹 Múltiples de 5 → mostrar "buzz"
• 🧨 Múltiples de 3 i 5 → mostrar "fizzbuzz"

📌 Exemple de com comença la seqüència: 1, 2, Fizz, 4

📐 Crea una única funció que rebi com a paràmetre un tipus de polígon i calculi la seva àrea segons els seus components.
✅ Només es processarà un polígon per crida.

Els polígons permesos són:

• 🔺 Triangle
• ◼️ Quadrat
• 🟥 Rectangle

🖥️ Mostra per pantalla l’àrea calculada.

🔄 Crea un programa que inverteixi l’ordre dels caràcters d’una cadena de text.
🚫 No pots utilitzar funcions pròpies del llenguatge que ja ho facin automàticament.
📌 Per exemple: "Hola món" → "nóm aloH"

💡 Crea un programa que transformi un nombre decimal al seu equivalent en binari.
🚫 No facis servir funcions incorporades del llenguatge que facin aquesta conversió automàticament.
🧮 El resultat s’haurà de calcular mitjançant lògica de programació.

✍️ Crea una funció que rebi dues cadenes com a paràmetres: str1 i str2.
🧵 La funció ha de generar dues noves cadenes:

• 🔹 out1: caràcters que estan a str1 però no a str2
• 🔸 out2: caràcters que estan a str2 però no a str1 📋 Mostra ambdós resultats per pantalla.

🔢 Escriu una funció que calculi i retorni el factorial d’un nombre enter donat.
🧠 El factorial d’un nombre n (n!) es defineix com el producte de tots els enters positius des de l’1 fins a n.
📌 Per exemple: 3! → 1 * 2 * 3 = 6

🔍 Escriu una funció que determini si un nombre és un nombre narcisista o Armstrong.
🧮 Un nombre narcisista és aquell que és igual a la suma dels seus dígits elevats a la potència del nombre de dígits.
📌 Per exemple: 371 → 3^3 + 7^3 + 1^3 = 371
👉 Més informació: nombres narcisistes

✍️ Crea una funció que rebi una cadena de text i converteixi la primera lletra de cada paraula en majúscula.
🚫 No pots usar funcions pròpies del llenguatge que ho facin directament.

⏱️ Crea una funció que rebi quatre valors enters:

• Dies
• Hores
• Minuts
• Segons

🧮 La funció ha de calcular i retornar el total equivalent en mil·lisegons.

🧩 Crea una funció que rebi dos arrays (conjunts) i determini si són conjunts disjunts, és a dir, si no comparteixen cap element en comú. ✅ Retorna true si són disjunts, o false en cas contrari.

📌 Per exemple:

• 👌 A [1,2,3] B [4,5,6] → true
• ❌ A [1,2,3] B [3,4,5] → false

🔁 Crea una funció que rebi dos arrays i un valor boolean com a paràmetres.

📌 La funció ha de retornar un nou array segons la condició:

• ✅ Si el boolean és true, retornarà els elements comuns entre ambdós arrays.
• ❌ Si és false, retornarà els elements que no es repeteixen en ambdós arrays.

🚫 No es poden utilitzar funcions pròpies del llenguatge que ho facin directament.

✏️ Crea un programa que dibuixi a la pantalla un quadrat o un triangle utilitzant asteriscs (*).
🔢 L’usuari haurà de:

• Indicar la mida del costat (enter positiu).
• Escollir si vol dibuixar un quadrat o un triangle.

📐 Crea un programa que determini si dos vectors són ortogonals (és a dir, el seu producte escalar és igual a 0).
➕ Ambdós vectors han de tenir la mateixa longitud i representar-se com a arrays.
📌 Exemple: [1, -2] i [2, 1]

📊 Crea una funció que ordeni una llista de nombres segons el criteri indicat.
La funció ha de rebre:

• Una llista de nombres.
• Un paràmetre de tipus text: "Asc" per ordre ascendent o "Desc" per ordre descendent.

🚫 No es permet utilitzar funcions pròpies del llenguatge que realitzin l’ordenació automàticament.

🔤 Crea una funció que rebi un text i compti el nombre de vocals (tant majúscules com minúscules).
📊 Mostra el resultat per pantalla.

🖼️ Crea una funció que rebi un text i mostri cada paraula en una línia, tancada en un marc d’asteriscs.

📌 Exemple:

Entrada: "Hola, Món !"
Sortida:

**********
* Hola,  *
* Món    *
* !      *
**********

🏛️ Crea un programa que converteixi nombres romans a enters.

• 📜 L’usuari ha d’introduir un nombre romà vàlid (per exemple, XII, IV, XXI).
• 🔢 El programa ha de retornar el valor enter corresponent.
  🚫 No es poden usar funcions del llenguatge que facin la conversió automàticament.

🏛️ Crea un programa que converteixi nombres enters a nombres romans.

• 🔢 L’usuari ha d’introduir un nombre enter positiu (per exemple, 1, 4, 10).
• 📜 El programa ha de retornar el nombre romà corresponent.
  🚫 No es poden usar funcions del llenguatge que facin la conversió automàticament.

📅 Crea una funció que rebi un any (nombre enter) i determini si és de traspàs o no.
ℹ️ Recorda que un any és de traspàs si és divisible per 4, però no per 100, excepte si també és divisible per 400.

🔢 Donat un array de nombres, troba el segon nombre més gran de la llista.
⚠️ Assegura’t de contemplar que no tots els nombres siguin iguals i que l’array tingui almenys dos valors diferents.

💻 Crea un programa que converteixi un nombre binari al seu equivalent en decimal.
🚫 No es poden utilitzar funcions pròpies del llenguatge que ho facin automàticament.

⚡ Crea una funció que calculi el voltatge segons la Llei d’Ohm.

La funció ha de:

• Rebre la intensitat (I) i la resistència (R)
• Calcular i retornar el voltatge (V = I × R)
• Retornar un missatge d’error si els valors són invàlids o insuficients

🌡️ Crea una funció que converteixi graus Celsius a Fahrenheit, i viceversa.

La funció ha de:

• Rebre el valor de la temperatura i la seva unitat d’origen
• Retornar el valor convertit a la unitat de destí
• Mostrar un missatge d’error si les dades són incorrectes o falten

🔤 Crea una funció que rebi un text i retorni la vocal més repetida.

⚠️ Tingues en compte:

• Majúscules i minúscules (no s’han de distingir)
• Vocals amb accent s’han de tractar com a equivalents (per exemple: á → a)
• En cas d’empat, pots retornar qualsevol de les vocals empatades
• Si no hi ha vocals, retorna buit

🎄 Crea una funció que rebi una data i analitzi la seva relació amb el calendari d’advent (de l’1 al 24 de desembre).

La funció ha de contemplar els següents casos:

• 📦 Si la data està dins del calendari: retornar el regal del dia i quants dies queden per acabar-lo.
• ⏳ Si la data és anterior a l’1 de desembre: indicar quants dies falten per començar.
• 📅 Si la data és posterior al 24 de desembre: indicar quants dies han passat des del seu final.

🔐 Crea una funció que permeti xifrar i desxifrar text utilitzant l’algoritme de la xifrat Karaca.

El procés consisteix en:

• 🔄 Substituir cada vocal per un número:
  a → 0, e → 1, i → 2, o → 3, u → 4
• ✅ Les consonants roman sense canvis
• ➕ Afegir una seqüència extra al final (per exemple, aca)
• 🔁 Invertir la cadena resultant

📌 Exemple:
Entrada: "Hola Mundo"
Resultat: "odnuM 3l0Haca"

📏 Crea un programa que permeti convertir entre diferents unitats de mesura.

• 🧮 L’usuari ha de poder triar entre:
  • Longitud (metres, quilòmetres, milles)
  • Pes (grams, quilograms, lliures)
  • Temperatura (Celsius, Fahrenheit)
• 🔄 El programa ha de sol·licitar el valor a convertir i la unitat d’origen i de destí.
• 📊 Mostra el resultat de la conversió per pantalla.

🎮 Crea un programa que permeti jugar a una versió simplificada del Sudoku, utilitzant una matriu de 3x3.

• 📐 El tauler es representa com una matriu bidimensional d’enters.
• Cada cel·la pot contenir un nombre de l’1 al 3 o estar buida (representada per 0 o un espai).
• 🔢 El programa ha de col·locar un únic nombre en una cel·la aleatòria com a pista inicial.
• 👤 Després, l’usuari introduirà els valors un a un, indicant la fila, la columna i el nombre a col·locar.
• ✅ S’ha de verificar que no hi hagi nombres repetits a la mateixa fila ni a la mateixa columna.
• 🔁 Després de cada intent, el tauler es mostrarà actualitzat amb els nombres introduïts.
• 🏁 El programa finalitzarà quan el tauler estigui complet i correcte, i mostrarà el tauler final i el nombre total d’intents.

🔐 Crea un programa que permeti jugar a endevinar un nombre secret generat aleatòriament per la màquina.

• 🎲 En començar, es generarà un nombre aleatori entre 1 i 100.
• 🎯 L’usuari intentarà endevinar-lo introduint nombres per teclat.
• 📈 Després de cada intent, el programa ha d’indicar si el nombre introduït és més gran o més petit que el nombre secret.
• 🔁 El joc continua fins que l’usuari encerti el nombre.
• 📊 Al final, es mostra el nombre total d’intents necessaris.

🧩 Crea un programa que permeti jugar a endevinar una paraula secreta.

• 📜 El programa seleccionarà una paraula aleatòria d’una llista predefinida.
• 🔤 L’usuari haurà d’endevinar la paraula introduint lletres una a una.
• ❌ Si la lletra no està a la paraula, es mostrarà un missatge d’error.
• ✅ Si la lletra està, es mostrarà la seva posició dins la paraula.
• 🏁 El joc finalitza quan l’usuari endevina totes les lletres de la paraula.

🧩 Crea un programa que permeti jugar a endevinar una paraula secreta.

• 📜 El programa sol·licitarà el nivell de dificultat (fàcil, mitjà o difícil)
• 🎚️ Segons el nivell:
  • Fàcil: seleccionarà una paraula aleatòria de com a màxim 5 lletres d’una llista definida. El nombre d’intents serà 10.
  • Mitjà: seleccionarà una paraula aleatòria entre 6 i 10 lletres d’una llista definida. El nombre d’intents serà 7.
  • Difícil: seleccionarà una paraula aleatòria de més de 10 lletres d’una llista definida. El nombre d’intents serà 5.
• 🔤 L’usuari haurà d’endevinar la paraula introduint lletres una a una.
• ❌ Si la lletra no està a la paraula, es mostrarà un missatge d’error i es descomptarà un intent.
• ✅ Si la lletra està, es mostrarà la seva posició dins la paraula.
• 🏁 El joc finalitza quan l’usuari endevina totes les lletres de la paraula o es queda sense intents.

🔄 Escriu una funció que rebi dues paraules i retorni true o false segons siguin o no anagrames.

• ✍️ Un anagrama consisteix a formar una paraula reordenant totes les lletres d’una altra paraula inicial.
• 🧠 No cal comprovar si les paraules existeixen en un diccionari.
• 🚫 Dues paraules idèntiques no es consideren anagrames.

🔍 Crea una funció que determini si un nombre enter positiu és primer.

• 📌 Un nombre primer és aquell que només és divisible per 1 i per ell mateix.
• 🚫 No pots usar funcions del llenguatge que realitzin la validació automàticament.

🧮 Escriu un programa que imprimeixi tots els nombres primers compresos entre 1 i 100.

📝 Crea un programa que compti quantes vegades es repeteix cada paraula i mostri el recompte final.

• ❌ Els signes de puntuació no formen part de la paraula.
• 🔠 Una paraula és la mateixa encara que estigui en majúscules o minúscules.
• 🚫 No es poden utilitzar funcions del llenguatge que resolguin el problema automàticament.

🔤 Crea un programa que transformi text natural a codi Morse i viceversa.

• 🔍 El programa ha de detectar automàticament el tipus d’entrada i fer la conversió.
• 📡 En Morse s’utilitza: ratlla —, punt ., un espai " " entre lletres i dos espais " " entre paraules.
• 🌐 Es pot usar l’alfabet Morse descrit a Viquipèdia – Codi Morse.

🧩 Crea un programa que verifiqui si els parèntesis, claus i claudàtors d’una expressió estan equilibrats.

• ⚖️ Equilibrat significa que s’obren i es tanquen en l’ordre correcte.
• ➖ Tots els delimitadors tenen la mateixa prioritat.

✅ Exemple equilibrat: { [ a * ( c + d ) ] - 5 }
❌ Exemple no equilibrat: { a * ( c + d ) ] - 5 }

🔁 Escriu una funció que rebi un text i retorni true o false segons sigui o no un palíndrom.

• 📖 Un palíndrom és una paraula o frase que es llegeix igual d’esquerra a dreta que de dreta a esquerra.
• 🚫 No s’han de tenir en compte els espais, signes de puntuació ni accents.
• ✅ Exemple vàlid: La ruta natural

🏃‍♂️ Crea una funció que avaluï si un/a atleta ha superat correctament una cursa d’obstacles.

Rep dos paràmetres:

• 📚 Un array de paraules: "corre" o "salta".
• 🛤️ Un string que representa la pista: "_" per terra i "|" per tanca.

✅ Si fa corre en "_" o salta en "|", està correcte i avança.
❌ Si és diferent, falla. Es considerarà cursa fallida si hi ha tres faltes consecutives.
❌ Si la pista és més llarga que les accions del corredor, es considerarà cursa fallida.
⚠️ Si les accions del corredor són més que la pista, s’ignoraran les accions sobrants.

🔄 La funció retorna un booleà indicant si ha completat correctament la cursa.

🔢 Crea dues funcions:

• 📏 Una per calcular el màxim comú divisor (MCD).
• 📐 Una altra per calcular el mínim comú múltiple (MCM).

🖥️ Des del programa principal crida les dues funcions per mostrar-ne el funcionament.

📝 Crea un programa que determini qui guanya més partides al joc de Pedra, Paper o Tisora.

• 📚 El programa obté dues llistes que representen cada jugada.
• Usa els caràcters: ✊ "R" (pedra), ✋ "P" (paper), ✌️ "S" (tisora).
• 🏆 El resultat pot ser: “Jugador 1”, “Jugador 2” o “Empat”. A més, es mostrarà 🖥️ el nombre de partides guanyades.

🥤 Simula una màquina expenedora. El programa ha de gestionar el procés de compra de productes d’una màquina expenedora, tenint en compte l’inventari, el pagament i el canvi.

• 🏧 La màquina expenedora disposa de:
  • Una matriu que representa les posicions dels productes. Cada cel·la conté un array amb tres elements:
    • El nom del producte (string).
    • El preu (nombre).
    • La quantitat disponible.
  • Un llistat de monedes que conté la màquina expenedora per donar el canvi.
• 🛒 L’usuari selecciona un producte indicant les coordenades on es troba el producte, per exemple, A1 que representa (0,0) i l’import a pagar.
• 💰 Si el producte existeix i es pot fer efectiva l’operació, la màquina retorna el nom del producte i un array amb el canvi (usant el menor nombre de monedes possible).
• ❌ Si ocorre un error (producte no vàlid, sense estoc, import insuficient o sense canvi), es mostra un missatge i es retorna tot el diners pagat.

💶 La màquina només accepta i entrega canvi en monedes de: 0.01€, 0.05€, 0.10€, 0.20€, 0.50€, 1€ i 2€.

📅 Crea una funció que, donat un any, indiqui l’element i l’animal corresponents del cicle sexagenari del zodíac xinès.

• 🔁 El cicle combina 5 elements: fusta 🌳, foc 🔥, terra ⛰️, metall ⚙️ i aigua 💧.
• I 12 animals: rata 🐀, bou 🐂, tigre 🐅, conill 🐇, drac 🐉, serp 🐍, cavall 🐎, ovella 🐑, mico 🐒, gall 🐓, gos 🐕 i porc 🐖.
• Cada element es repeteix durant dos anys consecutius.
• L’últim cicle va començar el 1984 amb Fusta 🌳 Rata 🐀.

🔍 Donat un array d’enters ordenat i sense repeticions, crea una funció que retorni els nombres que falten entre el menor i el major de l’array.

📝 Crea un programa que ordeni una llista de nombres enters utilitzant l’algoritme de Bubble Sort.

• 🧮 El programa ha de permetre introduir una llista de nombres desordenats.
• 🔄 Implementa l’algoritme pas a pas per ordenar la llista de menor a major.
• 🖥️ Mostra la llista ordenada al finalitzar.

📝 Crea un programa que ordeni una llista de nombres enters utilitzant l’algoritme de Insertion Sort.

• 🧮 El programa ha de permetre introduir una llista de nombres desordenats.
• 🔄 Implementa l’algoritme pas a pas per ordenar la llista de menor a major.
• 🖥️ Mostra la llista ordenada al finalitzar.

📝 Crea un programa que ordeni una llista de nombres enters utilitzant l’algoritme de Quick Sort.

• 🧮 El programa ha de permetre introduir una llista de nombres desordenats.
• 🔄 Implementa l’algoritme Quick Sort per ordenar la llista de menor a major.
• 🖥️ Mostra la llista ordenada al finalitzar.

🛒 Crea un programa que simuli la cua de clients esperant en un supermercat.

• 👥 Els clients arriben i s’afegeixen al final de la cua (encolar o enqueue).
• 🏪 El caixer atén els clients en ordre, traient-los del davant de la cua (desencolar o dequeue).
• 📊 El programa ha de permetre afegir nous clients i atendre els clients en l’ordre correcte.
• 🔢 Després de cada operació, mostra el nombre de clients que queden a la cua.
• ❗ Controla els casos en què s’intenti atendre un client quan la cua està buida.
• 🔁 La simulació continua fins que l’usuari decideixi finalitzar-la.

📝 Crea un programa que simuli la gestió d’una pila de plats en un restaurant.

• 🍽️ Els plats s’apilen un sobre l’altre, per això només es pot treure l’últim plat que es va col·locar (desapilar o pop).
• 🥄 El programa ha de permetre a l’usuari afegir un plat nou a la pila (apilar o push) o treure el plat superior (desapilar).
• 📊 Després de cada acció, mostra quants plats queden a la pila i el seu ordre.
• ❗ Controla els casos en què s’intenti treure un plat quan la pila està buida.
• 🔁 El programa ha de continuar fins que l’usuari decideixi acabar la simulació.

🔺 Crea una funció que dibuixi el Triangle de Pascal indicant la mida del costat.

• 🧮 Cada nombre es calcula com la suma dels dos nombres superiors.
• 📊 Mostra el triangle en format text, alineant els nombres correctament.

🎃 Crea un programa especial d’Halloween que interactuï amb els nens i nenes.

• 🕷 L’usuari tria entre “Truc” o “Tracte”.
• 👶 Es introdueix una llista de noms de nens i nenes.
• Si és “Truc” 🎭 🧛‍♂️ 😈:
  • Genera espants aleatoris 🎃 👻 💀 🕷 🕸 🦇.
  • Un espant per cada 2 lletres del nom.
  • Dos espants si el nom té dues o més “a” o “e”.
  • Tres espants si el nom té més de 10 lletres.
• Si és “Tracte” 🧁 🧺 🎒:
  • Genera dolços aleatoris 🍬 🍭 🍫 🍪.
  • Un dolç per cada 3 lletres del nom.
  • Dos dolços si el nom té una o més “i” o “u”.
  • Tres dolços si el nom té més de 8 lletres.

📊 Mostra els resultats finals amb els noms i els seus respectius espants o dolços.

⚙️ Desenvolupa un programa que simuli l’estudi de pous d’aigua i compti quantes unitats poden tenir. Donat un array de nombres enters que representen la quantitat de blocs apilats, calcula quantes unitats d’aigua queden atrapades entre ells.

• 🧱 Cada nombre indica l’alçada de blocs.
• 💧 L’aigua queda atrapada entre blocs més alts.
• 📌 Per exemple, per a l’array [2, 0, 3, 1, 6, 3, 6], el resultat és 6.

🔐 Crea un generador de contrasenyes configurables que compleixi els següents requisits:

• 🛡️ Longitud entre 8 i 16 caràcters.
• 🔢🔡 Ha d’incloure lletres, números i símbols.
• 🔠 Contenir almenys una lletra majúscula.
• 🔣 Contenir almenys un símbol (per exemple: #, _, !).

🎲 Crea un generador de nombres pseudoaleatoris entre 0 i 100 sense fer servir funcions predeterminades de random.
🧠 Has de cercar i implementar una estratègia alternativa com l’algorisme de congruència lineal o alguna fórmula matemàtica creativa.

🧮 Crea un programa capaç de representar un número en àbac.

• 📊 El número es representarà en una matriu 10 x 10.
• 🔢 Cada fila, començant de dalt a baix, representarà les unitats, desenes, centenes, milers, etc.
• 🏛️ Cada columna representarà un dígit del número.
• 📥 El número a representar ha d’estar entre 0 i 9.999.999.999.
• ❗ Si el número és vàlid, es mostrarà l’àbac corresponent.
• ❌ Si el número és invàlid, es mostrarà un missatge d’error.

📌 Per exemple, el número 1234 es representaria així:

| ⬤ | ⬤ | ⬤ | ⬤ | ⬤ | ⬤ | ⬤ | ⬤ | ― | ⬤ |
| ⬤ | ⬤ | ⬤ | ⬤ | ⬤ | ⬤ | ⬤ | ― | ⬤ | ⬤ |
| ⬤ | ⬤ | ⬤ | ⬤ | ⬤ | ⬤ | ― | ⬤ | ⬤ | ⬤ |
| ⬤ | ⬤ | ⬤ | ⬤ | ⬤ | ― | ⬤ | ⬤ | ⬤ | ⬤ |
| ⬤ | ⬤ | ⬤ | ⬤ | ⬤ | ⬤ | ⬤ | ⬤ | ⬤ | ― |
| ⬤ | ⬤ | ⬤ | ⬤ | ⬤ | ⬤ | ⬤ | ⬤ | ⬤ | ― |
| ⬤ | ⬤ | ⬤ | ⬤ | ⬤ | ⬤ | ⬤ | ⬤ | ⬤ | ― |
| ⬤ | ⬤ | ⬤ | ⬤ | ⬤ | ⬤ | ⬤ | ⬤ | ⬤ | ― |
| ⬤ | ⬤ | ⬤ | ⬤ | ⬤ | ⬤ | ⬤ | ⬤ | ⬤ | ― |
| ⬤ | ⬤ | ⬤ | ⬤ | ⬤ | ⬤ | ⬤ | ⬤ | ⬤ | ― |

🧮 Crea un programa que rebi una expressió matemàtica escrita com a cadena i calculi el seu resultat respectant l’ordre d’operacions.

• 🔢 L’expressió pot incloure nombres enters, parèntesis i els operadors +, -, * i /.
• 💬 El programa ha d’analitzar la cadena, validar la seva sintaxi i calcular el resultat correcte.
• 🧾 S’ha de respectar la jerarquia d’operadors (PEMDAS): primer parèntesis, després multiplicacions/divisions, i finalment sumes/restes.
• ❗ El programa ha d’avaluar correctament expressions anidades com:
  “(2 + 3) * (7 - 2) / (1 + 1)” → 12.5
• ❌ Si l’expressió és invàlida, es mostrarà un missatge d’error adequat.

🌀 Escriu un programa que imprimeixi els 50 primers nombres de la successió de Fibonacci començant en 0.

• 📖 La sèrie Fibonacci és una successió on cada nombre és la suma dels dos anteriors: 0, 1, 1, 2, 3, 5, 8, 13...

📈 Crea un programa que calculi el factorial d’un nombre enter no negatiu utilitzant una funció recursiva.

• ✍️ El programa ha de sol·licitar a l’usuari un nombre enter major o igual a 0.
• ↪️ La funció es definirà així:
  factorial(n) = n * factorial(n - 1)
  amb el cas base: factorial(0) = 1
• 🖥️ Mostra el resultat per pantalla.
• ⚠️ Si el nombre és negatiu, mostra un missatge d’error.

📅 Crea una funció que calculi i retorni quants dies hi ha entre dues dates, donades en format text.

• 🗓️ El format d’entrada serà "dd/MM/yyyy".
• 🔄 La diferència es calcularà de manera absoluta (sense importar l’ordre de les dates).
• ❗ Si alguna cadena no representa una data vàlida, s’ha de mostrar un missatge d’advertència.

🕹️ Crea una funció que analitzi una matriu 3x3 composta per "X" i "O", i retorni:

• "X" si van guanyar les ❌.
• "O" si van guanyar les ⭕.
• "Empat" si ningú no va guanyar.
• "Nul" si la matriu és invàlida (proporció incorrecta o van guanyar ambdós).

⚠️ Nota: la matriu pot tenir cel·les buides representades per "".

🧩 Crea un programa que permeti jugar al clàssic joc de Sudoku sobre un tauler de 9x9.

• 📐 El tauler es representarà com una matriu bidimensional d’enters.
• 🔲 Cada cel·la pot contenir un número de l’1 al 9 o estar buida (representada per 0 o un espai).
• 🗂️ El tauler es divideix en 9 subquadres de 3x3.
• 🎲 En iniciar el joc, el programa ha d’omplir entre 25 i 30 números inicials, distribuïts per tot el tauler.
• ❗ Com a restricció, ha d’haver-hi exactament dues subquadres amb un sol número inicial. Les altres poden contenir entre 2 i 5 números, però cap no ha de superar els 5.
• 👤 Un cop inicialitzat el tauler, el programa sol·licitarà a l’usuari que introdueixi els valors un a un, indicant la fila, la columna i el número desitjat.
• ✅ Abans de col·locar el número, s’ha de verificar que no estigui repetit a la mateixa fila ni a la mateixa columna.
• 🔄 Després de cada intent, es mostrarà el tauler actualitzat amb els números introduïts.
• ❌ Qualsevol error en la introducció de dades (número fora de rang, cel·la ocupada, etc.) ha de ser notificat a l’usuari.
• 🏁 El programa finalitzarà quan l’usuari completi correctament el tauler. Al final, mostrarà el tauler final i el nombre total d’intents realitzats.

⚓ Crea un programa que permeti jugar al clàssic joc Batalla naval contra la màquina.

• 🗺️ El tauler serà una matriu bidimensional de mida 10x10 (fila x columna).

• 🤖 La màquina col·locarà de forma aleatòria els vaixells, que poden ser verticals, horitzontals o diagonals. No poden haver-hi dos o més vaixells que utilitzin la mateixa cel·la.
• 🚢 La quantitat de vaixells serà:
  • 1 cuirassat de 4 cel·les
  • 2 creuers de 3 cel·les cadascun.
  • 3 destructors de 2 cel·les cadascun.
  • 4 submarins d’1 cel·la cadascun.
• 🎯 El jugador intentarà enfonsar els vaixells introduint coordenades (fila i columna).
• 💥 Després de cada intent, el programa ha d’indicar si ha estat un “impacte” o “aigua” (fallada).
• ⏳ Hi haurà un límit d’intents totals per enfonsar tots els vaixells.
• 📊 Per cada iteració, el programa mostrarà el tauler actualitzat, indicant les posicions ja atacades i els encerts. La quantitat màxima d’intents i els realitzats.
• 🏁 El joc acaba si:
  • ✅ El jugador enfonsa tots els vaixells (Guanya)
  • ❌ S’arriba al nombre màxim d’intents (Perd).
• 📈 Al finalitzar, el programa mostrarà el nombre total d’intents realitzats en la partida.

❗ Important: El jugador no té la funcionalitat de col·locar vaixells; només ha d’intentar enfonsar els vaixells col·locats aleatòriament per la màquina. La màquina no ataca al jugador. Pots representar el tauler amb caràcters o símbols per mostrar aigua, impactes i posicions no atacades.

🏰 Crea un programa que resolgui el clàssic problema de la Torre de Hanoi utilitzant recursivitat.

• 🗼 El joc consisteix en tres torres (A, B i C) i un nombre variable de discs (entre 3 i 8) apilats a la torre A, ordenats de més gran a més petit de baix cap amunt.
• 🎯 L’objectiu és traslladar tots els discs des de la torre A fins a la torre C, complint les següents regles:
  • 🔄 Només es pot moure un disc alhora.
  • 📏 Només es pot col·locar un disc sobre un altre si és més petit.
  • 🗺️ Els discs només es poden moure d’una torre a una altra (A, B, C).
• 📥 El programa ha de demanar a l’usuari el nombre de discs a resoldre.
• 📜 Ha de mostrar pas a pas cada moviment necessari per completar la solució.
• ↪️ Utilitza una funció recursiva per resoldre el problema.

Per exemple, el programa ha d’indicar a la pantalla instruccions com:

Mou disc 1 (Petit) de A a C
Mou disc 2 (Mitjà) de A a B
Mou disc 1 (Petit) de C a B
Mou disc 3 (Gran) de A a C
...

👑 Crea un programa que resolgui el clàssic problema de les N reines utilitzant l’algoritme de backtracking.

• 📏 L’objectiu és col·locar N reines en un tauler de NxN sense que cap s’atacqui entre elles.
• 🚫 Les reines no poden compartir la mateixa fila, columna ni diagonal.
• 🖥️ El programa ha de mostrar una solució vàlida (o totes si es desitja) indicant les posicions al tauler.
• 🔄 Utilitza backtracking per explorar les possibles combinacions i retrocedir quan una col·locació no és vàlida.
• 📐 L’usuari pot indicar la mida N del tauler (per exemple, 4 o 8).

👉 Més informació: Backtracking - Wikipedia.

🧭 Crea un programa que trobi un camí des de l’entrada fins a la sortida en un laberint representat com una matriu d’1s (pas) i 0s (paret).

• 🗺️ El laberint es representa amb una matriu NxM d’enters.
• 🚪 L’entrada està a l’angle superior esquerre (0, 0) i la sortida a l’angle inferior dret (N-1, M-1).
• 📥 El laberint s’inicialitza manualment com una matriu fixa, afegint 1s de forma contigua fins a la sortida. Per exemple:

  laberint = [
    [1, 1, 1, 1],
    [1, 1, 0, 1],
    [0, 1, 1, 0],
    [1, 0, 1, 1]
  ]

• 🎯 El programa ha de trobar una ruta possible des de l’entrada fins a la sortida, avançant en les quatre direccions (amunt, avall, esquerra, dreta), sense travessar parets.
• 🔄 Explora camins possibles i retrocedeix si s’arriba a un carreró sense sortida.
• 📊 Mostra el camí trobat sobre el tauler (per exemple, amb ”*” o amb coordenades).
• 🔚 És possible que el laberint tingui múltiples solucions, per això s’ha de mostrar el camí més curt.

❗ Important: Es contempla que el laberint sempre ha de tenir un camí vàlid des de l’entrada fins a la sortida. No s’han de considerar laberints sense solució.

🧬 Crea un programa que utilitzi un algoritme genètic per “evolucionar” una cadena de text aleatòria fins que coincideixi amb una paraula objectiu.

Què ha de fer el programa?

• 📝 L’usuari introdueix una paraula objectiu, per exemple: "hola".
• 🎲 El programa genera una població inicial de cadenes aleatòries de la mateixa mida que la paraula objectiu.
• 📊 A cada generació, s’avalua cada cadena amb una funció de fitness, que mesura com de semblant és a la paraula objectiu (per exemple, quantes lletres coincideixen en la posició correcta).
• 👪 S seleccionen les cadenes més aptes per a reproduir-se (selecció de pares).
• 🔄 Es realitza un creuament (crossover) entre pares per crear nous fills.
• 🎯 A cada nou fill se li pot aplicar una mutació aleatòria (canviar una lletra a l’atzar).
• 🔁 Aquest procés es repeteix generació rere generació fins que:
  • es troba la paraula exacta, o
  • s’assoleix un nombre màxim de generacions.

Has d’implementar:

• ✅ Una funció de fitness que calcula un nombre que representa com de “bona” és una cadena. Per exemple:

  Objectiu: HOLA
  Cadena:   HAZA
  Fitness:  3 lletres coincideixen (H, A, A)

• 🔍 Selecció de pares. Pots usar per exemple els 10 millors individus de la població.
• 🔗 Creuament (crossover). Combinar dues cadenes, usant per exemple meitat i meitat.
• 🎲 Mutació aleatòria: canvia una lletra a l’atzar en una cadena amb certa probabilitat.

📈 Mostra l’evolució de les generacions i el nombre de passos necessaris per arribar al resultat.