// Esercizi vol2p088

es01: scrivi una implementazione della funzione di libreria su stringhe che ritornano la sua lunghezza
es02: scrivi un programma che, lette due stringhe di caratteri indicanti il nome ed il cognome di una persona, le riscriva con le sole iniziali maiuscole.
es03: scrivi un programma che, data una stringa di N caratteri, la inverta (per esempio: "Paolo" diventa "oloaP")
es04: scrivi una versione ricorsiva dell'algoritmo precedente
es05: scrivi un programma che legga un numero compreso fra 0 e 100 in cifre e scriva il valore in lettere (per esempio: letto 21, scritto, "ventuno")
es06: scrivi un programma che legga una frase (massimo 80 caratteri) e calcoli la frequenza delle vocali presenti, indicando la piu` frequente e la meno frequente.
es07: scrivi un programma che legga un numero e lo visualizzi, trasformandolo in caratteri e separando le migliaia con il punto.
es08: scrivi un programma che legga una frase (massimo 80 caratteri) e sostituisca una parola presente in tale frase con un'altra, entrambe digitate dall'utente.
es09: scrivi un programma che legga una frase (massimo 80 caratteri) e scambi due parole presenti in tale frase. Per esempio in "se vado in montagna non vado al mare" con "se vado al mare non vado in montagna".
es10: scrivi un programma che verifiche la correttezza di una codifica binaria di 8 bit con codice di parità pari (la somma dei bit con valore 1 deve essere pari). Per esempio: 11001010 = corretto, 11001000 = errato.
es11: scrivi un programma che legga una frase (massimo 80 caratteri) e tolga gli spazi bianchi (per esempio "w la pappa col pomodoro" diventa "wlapappacolpomodoro")
es12: scrivi un programma che legga una frase (massimo 80 caratteri) e tolga gli spazi bianchi in eccesso, lasciando cioe` solo uno spazio bianco come separatore tra le parole (per esempio "quel  gran  genio  del  mio  amico" diventa "quel gran genio del mio amico")
es13: scrivi un programma che legga una frase e inserisca un carattere suggerito dall'utente come carattere separatore tra le parole (per esempio "ti regolerebbe il minimo" con separatore '-' diventa "ti-regolerebbe-il-minimo")
es14: scrivi un programma che verifichi se una frase e` palindroma (senza considerare gli spazi bianchi)
es15: scrivi un programma che legga una parola e la traduca in alfabeto farfallino (per esempio, "panino" diventa "pafanifinofo", "cavillo" diventa "cafavifillofo")
es16: scrivi un programma che legga da tastiera quattro stringhe che rappresentano interi, le converta in interi, le sommi e stampi la somma.
es17: scrivi un programma che legga una data nel formato "11/09/2001" e la converta nel formato "11 settembre 2001"
es18: scrivi una funzione con la seguente interfaccia void scambia(char s[]) che scambi il primo carattere della stringa s con l'ultimo.
es19: scrivi una funzione con la seguente interfaccia void concat(char s1[], char s2[], char s3[]) che ponga nella stringa s3 la concatenazione delle stringhe s1 ed s2. Per esempio, se s1="inter" e s2="faccia", al ritorno della chiamata a concat() si deve avere s3="interfaccia"
es20: scrivi una funzione con la seguente interfaccia int VocaliDispari(char s[]) che restituisca 1 se il numero di vocali presenti nella stringa e` dispari, 0 altrimenti.

Esercizi extra (non viene fornita soluzione):
es21: Scrivere le seguenti funzioni presenti in libreria:
	unsigned strlen(const char *str)
	strcpy(char *dest, const char *src);
	strcat(char *dest, const char *src);
	strcmp(const char *src2, const char *src2);
	strcasecmp(const char *src1, const char *src2);
Per assicurarsi l'univocità del nome della funzione, usare un prefisso uguale alle proprie iniziali.

// Esercizi tipo1

es1A: Scrivere una funzione che, ricevuta una stringa str ed un carattere ch, restituisca il numero delle occorrenze di ch
Prototipo richiesto:
	unsigned charcount(const char *src, const char ch);
Esempio: "taglia le aiuole", 'a' -> 3

es1B: Scrivere una funzione che, ricevuta una stringa, conti il numero di parole contenute in essa
Prototipo richiesto:
	unsigned wordcount(const char *str);
Esempio:
	"nel mezzo del cammin di nostra vita" --> 7

es1C: Scrivere una funzione che, ricevuta una stringa, ne restituisca il numero di caratteri alfabetici (esclusi spazi, caratteri speciali, cifre, punteggiatura, ecc.)
Prototipo richiesto:
	unsigned alphacount(const char * src);
Esempio:
nel mezzo del cammin di nostra vita --> 29

es1D: Scrivere una funzione che, ricevuta una stringa, ne restituisca il numero di cifre
Prototipo richiesto:
	unsigned digitscount(const char *str);
Esempio:
	"25dic2018" → 5

es1E: Scrivere una funzione che, ricevuta una stringa, ne restituisca il numero di vocali.
Prototipo richiesto:
	unsigned vowelscount(const char *str);
Esempio:
	"25dic2018" → 1

es1F: Scrivere una funzione che, ricevuta una stringa, ne restituisca il numero di consonanti.
Prototipo richiesto:
	unsigned consonantscounts(const char *str);
Esempio:	"25dic2018" → 2

es1G: Scrivere una funzione che, ricevuta una stringa, stamparne il numero di vocali e di consonanti
Prototipo richiesto:
	void alpha2count(const char *str);
Esempio:
	"nel mezzo del cammin di nostra vita" -> ...

es1H: Scrivere una funzione che, ricevute due stringhe, controlli se la seconda stringa e` contenuta nella prima
Prototipo richiesto:
	_Bool hasstrsub(const char *str, const char *strsub);
Esempi:
	"nel mezzo del cammin di nostra vita", "cammin" --> true
	"nel mezzo del cammin di nostra vita", "camin" --> false

es1I: Senza utilizzare le funzioni atoi() e itoa(), scrivere una funzione che sommi le sole cifre che compongono una stringa in input.
Prototipo richiesto:
	unsigned digitssum(const char * str);
Esempio: "125" -> 8, "Columbus 1492" -> 16

es1J: Scrivere una funzione che, ricevuta in input una stringa, determina se e` una palindrome (ignorando il case).
Prototipo richiesto:
	_Bool ispalindrome(const char * str);
Esempio: "Anna" -> 1, "RAdar" -> 1, "OttETTO" -> 1, "Ovattavo" -> 1, "Onorarono" -> 1, "Anno" -> 0.

es1K (Marco L.): Scrivere una funzione che, ricevuta una stringa, restituisca true se contiene lettere doppie, false altrimenti.
Realizzare poi una seconda versione che restituisca un puntatore alla doppia, NULL altrimenti.
Prototipo richiesto:
	_Bool hasdouble(const char *str);
	const char * hasdouble(const char * src);
Esempio: "cassa" -> true, perche` ci sono le due 's' adiacenti;
	"casa" -> false, perche` ci sono due 'a', ma non sono adiacenti.

es1j: Scrivere una funzione che, ricevuta in input una stringa, determina se contiene doppia di vocali
Prototipo richiesto:
	const char * hasvowelpair(const char * src);
Esempio:
	"urkaa" -> true, perche` ci sono le due 'a' adiacenti
	"caorle" -> false

es1L: Scrivere una funzione che, ricevuta una stringa, controlli se vi compaiono almeno tre caratteri uguali consecutivi.
Prototipo richiesto:
	const char * hastriple(const char * src);
Esempio:
	"aabbcc55wwwjj" -> restituisce un puntatore al carattere in posizione 8 (inizio della tripla);
	"aabbcc55wwjj" -> restituisce un puntatore a NULL (la tripla non trovata)

es1M: Scrivere una funzione che, ricevuta una stringa, ne restituisca il suo ultimo carattere.
Prototipo richiesto:
	char latestchar(const char * src)
Esempio:

es1N: Scrivere una funzione che, ricevute due stringhe, determini se la seconda e` un anagramma della prima.
Prototipo richiesto:
	_Bool isanagram(const char * src1, const char * src2);
Esempio:
	"lavagna", "valanga" -> true

es1O: Scrivere una funzione che, ricevuta una parola o frase, determini se e` un pangramma, ovvero se contiene tutte le lettere dell'alfabeto (ignorando il case).
Prototipo richiesto:
	_Bool ispangram(const char * str);
Esempio:
	"Pranzo d'acqua fa volti sghembi" -> true
	"Quel fez sghembo copre davanti" -> true
	"Pochi sforzan quel gambo di vite" -> true
	"Qualche vago ione tipo zolfo, bromo, sodio" -> true
	"Quel vituperabile xenofobo zelante assaggia il whisky ed esclama: alleluja!" -> true
	"The quick brown fox jumps over the lazy dog" -> true

es1P: Scrivere una funzione che, ricevuta una parola o frase, determinare se e` eteroletterale, ovvero se tutte le lettere presenti compaiono una sola volta (ignorando il case).
Prototipo richiesto:
	_Bool isheteroliteral(const char * str);
Esempio:
	"bcdefg" -> true
	"bcdefg hijklmnop qrstuvwxAy" -> true
	"Tv? Quiz, Br, Flm, Dc. Oh, spenga!" -> true (si tratta di un pangramma eteroletterale)

es1Q: Scrivere una funzione che, ricevuta una frase, determinare se e` un tautogramma, ovvero se tutte le parole hanno la stessa lettera iniziale. Es.Veni, vidi, vici; composizione costruita con componenti che cominciano, categoricamente, con caratteri coincidenti
Prototipo richiesto:
	_Bool istautogram(const char * str);
Esempio:
	"Veni, vidi, vici." - > true

es1R: Scrivere una funzione che, ricevuta una frase, determinare se e` "pangrammatica ordinata", ovvero se le lettere dell'alfabeto compaiono nel loro ordine: "A baci d'effigie hai la mano, poi, qui, resa tuo vizio" ("A BaCi D'EFfiGie HaI La MaNO Poi Qui ReSa TUo ViZio").
Prototipo richiesto:
	_Bool issortedpangram(const char * src);
Esempio:
	"A baci d'effigie hai la mano, poi, qui, resa tuo vizio" -> true

es1S: Scrivere una funzione che, ricevuta una frase, determinare se e` un lipogramma, ovvero se una (ed una sola) lettera dell'alfabeto non viene mai utilizzata.
Prototipo richiesto:
	_Bool islipogram(const char * src);
Esempio:
	"abcdefghijklmnoprstuvwxyz" -> true (manca la q)

es1T: Controlla che i caratteri si trovino in ordine alfabetico (diretto)
Prototipo richiesto:
	_Bool issortedinc(const char *str);
Esempio:
	"ABCCabbc" -> true

es1U: Controlla che i caratteri si trovino in ordine alfabetico (inverso)
Prototipo richiesto:
	_Bool issorteddec(const char *str);
Esempio:
	"cbbaCCBA" -> true

es1V: data una parola o frase, determinare se e` panvocale, ovvero se contiene tutte le vocali (ignorando il case). In caso lo sia, determinare:
1) se le vocali appaiono una sola volta (eterovocale)
2) se le vocali appaiono in ordine: diretto(in italiano non ce ne sono, ma ci sono in inglese), inverso(es.fusoliera), fuori ordine(es.aiuole).

es1W: Scrivere una funzione che, ricevute due stringhe, restituisce il numero delle occorrenze della seconda nella prima.
Prototipo richiesto:
	unsigned substrcount(const char * src, const char * substr);
Esempio:
	"nel mezzo del cammin della nostra vita", "del" -> 2
es1h: Scrivere una funzione che, ricevute una stringa ed un carattere, restituisca il numero delle occorrenze del carattere nella stringa.
Prototipo richiesto:
	unsigned charscount(const char * src, const char ch);
Esempio:
	"ciao mondo", 'o' -> 3
es1i: Scrivere una funzione che, ricevute una stringa ed una stringa di delimitatori, restituisca il numero dei token (rispetto a quell'insieme di delimitatori).
Prototipo richiesto:
	unsigned tokenscount(const char * str, const char * str2);
Esempio:
	"ciao mondo;crudele", ",;" -> "ciao\nmondo\ncrudele"
/*
es1X: Scrivere una funzione che, ricevute due stringhe, restituisca un puntatore alla più corta (o alla prima stringa se sono di uguale lunghezza).
Prototipo richiesto:
	const char *getshorter(const char * str1, const char * str2);
Esempio:
	"ciao mondo", "ebbene si" -> "ebbene si"
*/

/*
es1Y: Scrivere una funzione che, ricevute due stringhe, restituisca un puntatore alla più lunga (la prima se sono di uguale lunghezza).
Prototipo richiesto:
	const char *getlonger(const char * str1, const char * str2);
Esempio:
	"ciao mondo", "ebbene si" -> "ciao mondo"
*/

/*
es1Z: Scrivere una funzione che, ricevute due stringhe, restituisca la minore (la prima se sono uguali).
Prototipo richiesto:
	const char *getlesser(const char * str1, const char * str2);
Esempio:
	"ciao mondo", "ebbene si" -> "ciao mondo"
*/

/*
es1a: Scrivere una funzione che, ricevute due stringhe, restituisca la maggiore (la prima se sono uguali).
Prototipo richiesto:
	const char *getgreater(const char * str1, const char * str2);
Esempio:
	"ciao mondo", "ebbene si" -> "ebbene si"
*/

/*
es1b: Scrivere una funzione che, ricevuta una stringa in input verifichi se essa contiene almeno una 'A' (maiuscola o minuscola) entro i primi 10 caratteri.
Attenzione: gestire correttamente il caso in cui la stringa abbia lunghezza inferiore a 10.
Prototipo richiesto:
	_Bool hasA(const char * str);
Esempio: "accidenti" -> true, "perdindirindina" -> false
*/

/*
es1c: Scrivere una funzione che, ricevuta una stringa str, verifichi se questa è composta di due parti uguali, trascurando il carattere centrale se la lunghezza è dispari.
Prototipo richiesto:
	_Bool twoequals(const char * str);
Esempio: "CiaoCiao" -> true, "CiaoXCiao" -> true
*/

/*
es1d: Scrivere una funzione che, ricevuta una stringa, conti quante sono le parole (sequenze di lettere dell'alfabeto) che la compongono e la lunghezza media delle parole stesse.
Prototipo richiesto:
	float wordavglength(const char * str);
Esempi:
	"Ieri... sono andato a mangiare all'una!" -> ci sono 7 parole e la lunghezza media è 4.14 caratteri.
	"nel mezzo del cammin di nostra vita" -> ci sono 7 parole e la lunghezza media è 4.142857 caratteri.
*/

/*
es1e: Scrivere una funzione che, ricevuta una stringa, restituisca la lunghezza della parola più lunga
Prototipo richiesto:
	size_t wordmaxlength(const char * str);
Esempio:
	"nel mezzo del cammin di nostra vita" -> 6
*/

/*
es1f: Scrivere una funzione che, ricevuta una stringa, restituisca il numero delle coppie di caratteri "fuori ordine alfabetico".
Prototipo richiesto:
	unsigned outoforder(const char *str);
Esempio:
	"nel mezzo del cammin di nostra vita" -> 15
*/
/*
es1g: Scrivere una funzione che, ricevuta in input una stringa con parentesi aperte e chiuse, verifichi se è "ben parentesizzata".
Prototipo richiesto:
	_Bool isparenthesized(const char * const str);
Esempio:
	"{(<><>){{()[<>]<>}}}" -> true
*/

es1k: Scrivere una funzione che, ricevuta in input una stringa, restituisca se è monovocalica
Prototipo richiesto:
	_Bool ismonovowel(const char * const str);
Esempio: spazzacampagna e cascara sagrada, schecchereccherebbe, disintirizzitissimi, contropropongono, gulugulugu

es1l: Scrivere una funzione che, ricevuta in input una stringa, restituisca se è monoconsonantica
Prototipo richiesto:
	_Bool ismonoconsonant(const char * const str);
Esempio: abbaiai, acciaccaci, cacciuccaccio, addio, diodo, fuffa, aggeggiai, ahio, jo-jo, kyu, alleali, mimami, ninnananna, appioppai, riirrorerai, equo, ossesso, issasse, tettoia, aiutato, viavai, wawa, ex, zozzo

es1m: Scrivere una funzione che, ricevuta in input una stringa, restituisca se è parivocalica (alterna regolarmente consonanti e vocali, con vocali in posizione pari)
Prototipo richiesto:
	_Bool isevenvowel(const char * const str);
Esempio: telecomunicatecelo, superedificatevelo, disacidificatecelo, celibato

es1n: Scrivere una funzione che, ricevuta in input una stringa, restituisca se è pariconsonantica (alterna regolarmente vocali e consonanti, con consonanti in posizione pari)
Prototipo richiesto:
	_Bool isevenconsonant(const char * const str);
Esempio: anatomopatologico

es1o: Scrivere una funzione che, ricevute in input due stringhe, restituisca se sono omovocaliche, cioè se nelle stesse posizioni hanno le stesse vocali e consonanti diverse.
Prototipo richiesto:
	_Bool isomovowel(const char * const str1, const char * const str2);
Esempio: accoltellarvelo/addormentassero, fantasticassero/rammarginarvelo, accoltellarvelo/assoggettassero, affaccendassero/accannellarvelo

es1p: Scrivere una funzione che, ricevute in input due stringhe, restituisca se sono omoconsonantiche, cioè se nelle stesse posizioni hanno le stesse consonanti e vocali diverse.
Prototipo richiesto:
	_Bool isomoconsonant(const char * const str1, const char * const str2);
Esempio: destrutturasti/distrattereste

es1q: Scrivere una funzione che, ricevuta in input una stringa, restituisca se ha le lettere in ordine alfabetico dal centro verso gli estremi
Prototipo richiesto:
	_Bool isordered3(const char * const str);
Esempio: acciottolii

es1r: Scrivere una funzione che, ricevuta in input una stringa, restituisca se ha le lettere in ordine alfabetico dagli estremi verso il centro
Prototipo richiesto:
	_Bool isordered4(const char * const str);
Esempio: sonnecchino

es1s: Scrivere una funzione che, ricevuta in input una stringa, restituisca se ha le lettere in ordine alfabetico (non decrescente)
Prototipo richiesto:
	_Bool isordered1(const char * const str);
Esempio: acceffino (con doppie), beghino (eteroletterale)

es1t: Scrivere una funzione che, ricevuta in input una stringa, restituisca se ha le lettere in ordine alfabetico inverso (non crescente)
Prototipo richiesto:
	_Bool isordered2(const char * const str);
Esempio: uronica

es1u: Scrivere una funzione che, ricevuta in input una stringa, restituisca se ha le vocali simmetriche (le vocali sono disposte in modo simmetrico, mentre non ci sono vincoli sulle consonanti)
Prototipo richiesto:
	_Bool issymmetricvowel(const char * const str);
Esempio: detestabilissimamente, sincrotrasformatori

es1v: Scrivere una funzione che, ricevuta in input una stringa, restituisca se ha le consonanti simmetriche (le consonanti sono disposte in modo simmetrico, mentre non ci sono vincoli sulle vocali)
Prototipo richiesto:
	_Bool issymmetricconsonant(const char * const str);
Esempio: allegorizzargliela, riabbraccerebbero, proteinoterapia

es1w: determinare se una coppia di parole è bifronte (realizzabile solo mediante utilizzo di un dizionario)
Prototipo richiesto:
	_Bool isbifronte(const char * const str1, const char * const str2);
Esempio: (es: evitarono/onorative)

es1x: ...
Prototipo richiesto:
	_Bool isXXX(const char * const str);
Esempio: ...

es1y: ...
Prototipo richiesto:
	_Bool isYYY(const char * const str);
Esempio: ...

es1z: ...
Prototipo richiesto:
	_Bool isZZZ(const char * const str);
Esempio: ...

es1.: Scrivere una funzione che, ricevuta una stringa str, verifichi se la stringa inizia con la sottostringa "fairtest".
Prototipo richiesto:
	unsigned startWith(const char * str, const char * substr);
Esempio: "fairtest is wonderful" → true, "what is fairtest" → false

es1.: Scrivere una funzione che, ricevuta una stringa str, verifichi se la stringa termina con la sottostringa "fairtest".
Prototipo richiesto:
	unsigned endsWith(const char * str, const char * substr);
Esempio: "fairtest is wonderful" → false, "what is fairtest" → true

es1.: Scrivere una funzione che, ricevuta una stringa str, che restituisce il numero di occorrenze della vocale più frequente.
Prototipo richiesto:
	unsigned mostfrequentvoweloccurrence(const char * str);
Esempio: "fairtest is wonderful" → 2

es1.: Scrivere una funzione che, ricevuta una stringa str, restituisce il numero di occorrenze della vocale meno frequente.
Prototipo richiesto:
	unsigned leastfrequentvoweloccurrence(const char * str);
Esempio: "fairtest is wonderful" → 1

es1.: Scrivere una funzione che, ricevuta una stringa str, determini se una stringa contiene almeno una vocale (NB: esiste una soluzione da una sola istruzione).
Prototipo richiesto:
	_Bool atleastonevowel(const char * str);

es1.: Scrivere una funzione che, ricevuta una stringa str, determini se la stringa (fornita in lowercase per ipotesi) è panvocale (NB: esiste una soluzione da una sola istruzione).
Prototipo richiesto:
	_Bool ispanvowel(const char * str);
Esempio: aiuole

es1.: Scrivere una funzione che, ricevuta una stringa str, determini se la stringa (fornita in lowercase per ipotesi) è un anagramma di "nepoti" (NB: esiste una soluzione da una sola istruzione).
Prototipo richiesto:
	_Bool isnepotilike(const char * str);
Esempio: pineto
es1.: Scrivere una funzione che, ricevuta una stringa str, restituisca il numero di caratteri DISTINTI presenti nella stringa.
Prototipo richiesto:
	unsigned distinctchars(const char * str);
Esempio: "asparago" → 6 (asprgo)

es1.: Scrivere una funzione che, ricevuta una stringa str, restituisca il numero di caratteri DIVERSI DA QUALUNQUE ALTRO presenti nella stringa.
Prototipo richiesto:
	unsigned differentchars(const char * str);
Esempio: "asparago" → 5 (sprgo)

es1.: Scrivere una funzione che, ricevuta una stringa str, dica se la stringa può rappresentare un numero ottale (NB: esiste una soluzione da una sola istruzione).
Prototipo richiesto:
	_Bool canbeoctal(const char * str);
Esempio: "2527" → true, "2827" → false

es1.: Scrivere una funzione che, ricevuta una stringa str, calcoli la qualità di una stringa (definita come la differenza fra la massima e la minima posizione nell’alfabeto delle lettere che la compongono).
Prototipo richiesto:
	unsigned strquality(const char * str);
Esempi: "ab" → 2-1=1, "abzc" → 26-1=25.

es1.: Scrivere una funzione che, ricevuta una stringa str, determini se una stringa è "buona" o "cattiva".  Una stringa è "buona" se non contiene una sequenza di 3 o più caratteri che sono uguali (ad esempio le stringhe contenenti AAA o BBBB sono cattive).
Prototipo richiesto:
	_Bool isgoodevil1(const char * str);
Esempio: ...

es1.: Scrivere una funzione che, ricevuta una stringa str, determini se una stringa è "buona" o "cattiva".  Una stringa è "buona" se non contiene una sequenza di 3 o più caratteri consecutivi che sono in ordine crescente (ad esempio le stringhe che contengono ABC o ACD sono cattive).
Prototipo richiesto:
	_Bool isgoodevil2(const char * str);
Esempio: ...

es1.: Scrivere una funzione che, ricevuta una stringa str, determini il numero di sottostringhe che iniziano per hello e terminano con world.'.
Prototipo richiesto:
	unsigned countHelloWorld(const char * str);
Esempi: "hello world hello world" → 3, "hello world hello hello world" → 4, "hello world hello hello world world" → 7

es1.: Scrivere una funzione che, ricevuta una stringa str, conti il numero di pattern del tipo "0[123456789]+0" presenti nella stringa. [la definizione del pattern segue la sintassi delle Regular Expression]
Prototipo richiesto:
	unsigned countPatterns(const char * str);
Esempi: "1510010101" -> 2, "0015101010" -> 3

es1.: Scrivere una funzione che determina se due stringhe:
- iniziano con le stesse lettere (e restituisce la sottostringa comune più lunga)
- terminano con le stesse lettere (e restituisce la sottostringa comune più lunga)
- l'inizio della prima coincide con la fine della seconda (e restituisce la sottostringa comune più lunga)
Prototipo richiesto:
	char * straaa(char * const str, const char * str1, const char * str2);
	char * strbbb(char * const str, const char * str1, const char * str2);
	char * strccc(char * const str, const char * str1, const char * str2);

// Esercizi tipo3

es3A: Scrivere una funzione che, ricevuta una stringa str, sostituisca tutte le consonanti con la vocale più vicina
Prototipo richiesto:
	char * replaceConsonants(char * const str)
Esempio: "geeksforgeeks" -> "eeeiueooeeeiu"

es3B: Scrivere una funzione che, ricevuta in input una stringa e una sottostringa, la modifichi sovrascrivendo le occorrenze della sottostringa con una sequenza di "*".
Scrivere poi una seconda funzione in modo da ottenere una sovrascrittura parziale (lasciando il primo e l'ultimo carattere)
Prototipo richiesto:
	char * censorship(char * const str, const char * forbidden);
Esempio: "Sapere delle ere è un dovere", "ere" -> "Sap*** delle *** è un dov***".
	char * partialcensorship(char * const str, const char * forbidden);
Esempio: "nel bel mezzo del cammin della nostra vita", "del" -> "nel bel mezzo d*l cammin d*lla nostra vita".

es3C: Scrivere una funzione che, ricevuta in input una stringa str, la converta in camelcase
Prototipo richiesto:
	char * camelcase(char * const str);
Esempio: "cHe bElLA gIOrnaTa" -> "Che Bella Giornata"

es3D: Scrivere una funzione che, ricevuta in input una stringa, la modifichi trasformando le vocali in maiuscolo e le consonanti in minuscolo
Prototipo richiesto:
	char * vowelUpperCase(char * const str);
Esempio:
	"nel mezzo del cammin della nostra vita" -> "nEl mEzzO dEl cAmmIn dEllA nOstrA vItA"

es3E: Scrivere una funzione che, ricevuta in input una stringa, sostituisca le cifre con il loro complemento a '9'.
Prototipo richiesto:
	char * cryptDigits(char * const str);
oppure
	char * cryptDigits(char * const dst, const char *src);
Esempio: "12 ottobre 1492" -> "87 ottobre 8507"

es3F: Scrivere una funzione che, ricevuta una stringa, la modifichi in modo che ogni vocale venga sostituita dal simbolo '$'.
Prototipo richiesto:
	char * dollarizevowels(char * const str);
oppure
	char * dollarizevowels(char * const dst, const char * src);
Esempio: "Hello, world!" --> "H$ll$, w$rld!"

es3G: Scrivere una funzione che, ricevuta una stringa, la modifichi invertendo le lettere maiuscole con le minuscole e le lettere minuscole con le maiuscole.
Prototipo richiesto:
	char * swapCase(char * const str);
oppure
	char * swapCase(char * const dst, const char *src);
Esempio: "Ciao, mi chiamo Alberto" --> "cIAO, MI CHIAMO aLBERTO"

es3H: Cifrare una stringa sostituendo alle vocali una unica vocale ricevuta in input (rispettare il case della stringa originale).
Prototipo richiesto:
	char * replacevowel(char * const str, const char newchar);
oppure
	char * replacevowel(char * const str, const char *src, const char newchar);
Esempio: "taglia le aiuole", 'u' -> "tugluu lu uuuulu"

es3I: Cifrare una stringa scambiando fra loro le vocali a ed e (rispettare il case della stringa originale).
Prototipo richiesto:
	char * swapvowels(char * const str);
oppure
	char * swapvowels(char * const str, const char *src);
Esempio: "taglia le aiuole" -> "teglie la eiuola"

es3J: Scrivere una funzione che, ricevuta una stringa, ruoti fra loro le vocali: a diventa e, e diventa i, i diventa o, o diventa u, u diventa a (rispettare il case della stringa originale).
Prototipo richiesto:
	char * rotatevowels(char * const str);
oppure
	char * rotatevowels(char * const dst, const char *src);
Esempio: "taglia le aiuole" -> "tegloe li eoauli"

es3K: Scrivere una funzione che, ricevuti una stringa str ed un numero intero n, ruoti la stringa a sx di n posizioni.
Prototipo richiesto:
	char * strrotatesx(char * const str, size_t n);
Esempio:
	"fusoliera", 2 -> "solierafu"

es3L: Scrivere una funzione che, ricevuti una stringa str ed un numero intero n, ruoti la stringa a dx di n posizioni.
Prototipo richiesto:
	char * strrotatedx(char * const str, unsigned n);
Esempio:
	"fusoliera", 2 -> "rafusolie"

es3M: Ordina i caratteri di una stringa con l'algoritmo insertionsort.
Prototipo richiesto:
	char * insertsort(char * const str);
Esempio:
	"12 ottobre 1492" -> "  112249beoortt"

es3N: Ordina i caratteri di una stringa con l'algoritmo selectionsort.
Prototipo richiesto:
	char * selectsort(char * const str);
Esempio:
	"12 ottobre 1492" -> "  112249beoortt"

es3O: Ordina i caratteri di una stringa con l'algoritmo bubblesort.
Prototipo richiesto:
	char * bubblesort(char * const str);
Esempio:
	"12 ottobre 1492" -> "  112249beoortt"
es3PA: Scrivere una funzione che converta in maiuscolo il contenuto di una stringa.
Prototipo richiesto:
	char *rfstrupr(char * const str);
Esempio: "RoMa" -> "ROMA", "aCETonE" -> "ACETONE"

es3PB: Scrivere una funzione che converta in minuscolo il contenuto di una stringa.
Prototipo richiesto:
	char *rfstrlwr(char * const str);
Esempio: "RoMa" -> "roma", "aCETonE" -> "acetone"

es3P: Scrivere una funzione che inverta il contenuto di una stringa.
Prototipo richiesto:
	char *rfstrrev(char * const str);
Esempio: "roma" -> "amor", "acetone" -> "enoteca"

es3Q: Scrivere una funzione che, ricevuta una stringa in input, inverte l'ordine delle sole vocali della stringa.
Prototipo richiesto:
	char *reversevowels(char * const str);
Esempi:
	"hello" -> "holle"
	"hello world" -> "hollo werld"

es3R: esegue un riordinamento di una stringa in un modo molto particolare (split/sort/merge)
@see https://practice.geeksforgeeks.org/problems/unusual-string-sort/0
Sia data in input una stringa composta da lettere maiuscole e minuscole. Si desidera riordinarla in modo tale che le maiuscole e le minuscole siano alternate ma ordinate.
Suggerimento: a partire dalla stringa in input, creare due stringhe, una con le maiuscole e una con le minuscole, e ordinarle separatamente. A questo punto fondere le due stringhe in una sola alternando maiuscole e minuscole.
Prototipo richiesto:
	char *unusualsort(char * const str);
Esempio:
	bAwutndekWEdkd -> AbEdWddekkntuw

es3S: Scrivere una funzione che, ricevuta una stringa, la riscriva andando a capo ad ogni parola.
In seguito, modificare l'esercizio in modo da dividere le varie parole con un singolo '\n'. In caso di spazi multipli, posizionare il '\n' al termine degli spazi, subito prima della parola successiva.
Prototipo richiesto:
	char * strsplit(char * const str);
Esempio:
nel mezzo del cammin di nostra vita -->
nel
mezzo
del
cammin
di
nostra
vita

es3T: Codice segreto nella pagina di un libro
Sono date due stringhe, una denominata msg e una denominata secret (non piu` lunga di msg) di caratteri tutti minuscoli.
Si vuole sapere se tutti i caratteri di secret sono contenuti nello stesso ordine (ma eventualmente intervallati da altri caratteri) nella stringa msg.
In caso positivo, la funzione deve restituire un puntatore al msg, dove pero` ad ogni lettera riconosciuta come facente parte di secret viene sostituita la lettera maiuscola.
In caso negativo deve restituire NULL.
Prototipo richiesto:
	char * identifica(char * const msg, const char * secret);
Esempio: msg="ma che bel castello", secret="cestello" -> "ma ChE bel caSTELLO"
	 msg="ma che bel castello", secret="costello" -> NULL


// Esercizi tipo4

es4A: Scrivere una funzione che modifichi la stringa str eliminandone tutte le occorrenze del carattere ch.
Prototipo richiesto:
	char *delchar(char * const str, const char ch);
Esempi:
	"programma", 'a' -> "progrmm"

es4B: Scrivere una funzione che, ricevuta una stringa, cancelli i caratteri corrispondenti ai caratteri alfabetici che compaiono nella stringa stessa.
Prototipo richiesto:
	char *delalphas(char * const str);
Esempio:	"25dic2018" → "252018"

es4C: Scrivere una funzione che, ricevuta una stringa, cancelli i caratteri corrispondenti alle cifre che compaiono nella stringa stessa.
Prototipo richiesto:
	char *deldigits(char * const str);
Esempio:	"25dic2018" → "dic"

es4D: Cancellare i caratteri corrispondenti alle vocali che compaiono in una stringa s ricevuta in input.
Prototipo richiesto:
	char *delvowels(char * const str);
Esempio:	"25dic2018" → "25dc2018"

es4E: Cancellare i caratteri corrispondenti alle cifre pari che compaiono in una stringa s ricevuta in input.
Prototipo richiesto:
	char *delevendigits(char * const str);
Esempio:	"25dic2018" → "5dic1"

es4F: Scrivere una funzione che, data in input una stringa, restituisca il suo acronimo (prima lettera -maiuscola- di ogni parola)
Prototipo richiesto:
	char * acronym(char * const str);
Esempio: "Organizzazione nazioni unite" -> "ONU"

es4G: Scrivere una funzione che, ricevuta in input una stringa, ne rimuova tutti i caratteri non alfabetici.
Prototipo richiesto:
	char *removeexceptalpha(char * const str);
Esempio: "12 ottobre 1492" -> "ottobre"

es4H: Scrivere una funzione che, ricevuta in input una stringa, elimini tutti gli spazi a sx.
Prototipo richiesto:
	char *strltrim(char * const str);
Esempio: "   ciao   mondo   " -> "ciao   mondo   "

es4I: Scrivere una funzione che, ricevuta in input una stringa, elimini tutti gli spazi a dx.
Prototipo richiesto:
	char *strrtrim(char * const str);
Esempio: "   ciao   mondo   " -> "   ciao   mondo"

es4J: Scrivere una funzione che, ricevuta in input una stringa, restituisca una stringa che contiene tutti i caratteri 'una volta sola' e nello stesso ordine in cui compaiono nella stringa originale
Prototipo richiesto:
	char *strunique(char * const str);
Esempio: "BAAABBCBABAB" -> "BAC"

es4K: Date due parole, effettuare un lucchetto, ovvero visualizzare una terza parola eliminando i gruppi di lettere comuni in coda alla prima e in testa alla seconda
Prototipo richiesto:
	char * lucchetto(char * const dst, const char * src1, const char * src2);
Esempio: "mais", "sale" -> "maiale"
	"posto", "stola" -> "pola"
	"luna", "nascita" -> "luscita"

es4L: Date tre parole, effettuare un lucchetto doppio, ovvero restituire una quarta parola eliminando i gruppi di lettere comuni in coda alla prima e in testa alla seconda
@see https://it.wikipedia.org/wiki/Lucchetto_(enigmistica)
Prototipo richiesto:
	char * lucchettodoppio(char * const dst, const char * src1, const char * src2, const char * const src3);
Esempio: persona / sonate / tegola -> pergola

es4M: cerniera
@see https://it.wikipedia.org/wiki/Cerniera_(enigmistica)
Prototipo richiesto:
	char * cerniera(char * const dst, const char * src1, const char * src2);
Esempio: mare / tema = rete

es4N: Data una stringa, rimuovere ricorsivamente i caratteri duplicati adiacenti dalla stringa. La stringa di output non dovrebbe avere duplicati adiacenti.
Esempi:
"azxxzy" -> "ay"
	Il primo "azxxzy" viene ridotto a "azzy".
	La stringa "azzy" contiene duplicati,  quindi viene ulteriormente ridotta a "ay".
"caaabbaacdddd" -> ""
"acaaabbbacdddd" -> "acac"

es4O: Scrivete una funzione C efficiente che prenda come argomenti due stringhe e rimuova dalla prima stringa i caratteri che sono presenti nella seconda stringa (stringa maschera).
Prototipo:
	char *strmask(char * const src, const char * mask);
Esempio: ...

es4P: Si scriva una funzione che prenda come parametri due stringhe e copi la prima stringa nella seconda, mettendo prima tutte le vocali nello stesso ordine in cui compaiono, poi tutte le consonanti, anch’esse in ordine, poi tutti gli altri caratteri (sempre in ordine).
Prototipo:
	char *strsss(char * const str);
Esempio: "Una Stringa" → "UaianStrng "


// Esercizi tipo5

es5A: Scrivere una funzione che ricevuti in input una stringa str e un carattere ch, modifichi la stringa str duplicando ogni occorrenza del carattere ch.
Prototipo richiesto:
	char *dupchar(char * const str, char ch);
Esempio:
	"12 ottobre 1492", 'o' -> "12 oottoobre 1492"

es5B: Scrivere una funzione che ricevuta in input una stringa str, duplichi le occorrenze di ogni carattere alfabetico.
Prototipo richiesto:
	char *dupalphas(char * const str);
Esempio:
	"12 ottobre 1492" -> "12 oottttoobbrree 1492"

es5C: Scrivere una funzione che ricevuta in input una stringa str, duplichi le occorrenze di ogni cifra.
Prototipo richiesto:
	char *dupdigits(char * const str);
Esempio:
	"12 ottobre 1492" -> "1122 ottobre 11449922"

es5D: Raddoppiare i caratteri corrispondenti alle vocali che compaiono in una stringa str ricevuta in input.
Nota: le vocali dovranno essere raddoppiate "inplace", senza usare stringhe di appoggio.
Prototipo richiesto:
	char *dupvowels(char * const str);
Esempio:
	"12 ottobre 1492" -> "12 oottoobree 1492"
	"uomo" --> "uuoomoo"

es5E: Scrivere una funzione che ricevuta in input una stringa str, un carattere ch ed un numero n(n>=0), sostituisca ogni occorrenza del carattere ch con n occorrenze del medesimo carattere.
Questo esercizio rappresenta quindi la sintesi dei due esercizi precedenti.
Prototipo richiesto:
	char *mulchar(char * const str, char ch, unsigned n);
Esempio:
	"12 ottobre 1492", 'o', 5 -> "12 ooooottooooobre 1492"

es5F: Scrivere una funzione che ricevuta in input una stringa str ed un numero n(n>=0), sostituisca ogni carattere alfabetico con n occorrenze del medesimo carattere.
Prototipo richiesto:
	char *mulalphas(char * const str, size_t n);
Esempio:
	"12 ottobre 1492", 5 -> "12 ooooottttttttttooooobbbbbrrrrreeeee 1492"

es5G: Scrivere una funzione che ricevuta in input una stringa str ed un numero n(n>=0), sostituisca ogni cifra con n occorrenze della medesima cifra.
Prototipo richiesto:
	char *muldigits(char * const str, size_t n);
Esempio:
	"12 ottobre 1492", 5 -> "1111122222 ottobre 11111444449999922222"

es5H: Scrivere una funzione che ricevuta in input una stringa str ed un numero n(n>=0), sostituisca ogni vocale con n occorrenze della medesima vocale.
Prototipo richiesto:
	char *mulvowels(char * const str, size_t n);
Esempio:
	"12 ottobre 1492", 5 -> "12 ooooottooooobreeeee 1492"
	"uomo", 3 --> "uuuooomooo"
	"uomo", 0 --> "m"

es5I: La strana sillabazione
Il professor Precisini, sostenendo che le regole di sillabazione della lingua italiana sono troppo complesse e piene di eccezioni, propone un nuovo e originale metodo di sillabazione.
Il metodo consiste in questo: una sillaba è una sequenza massimale di caratteri consecutivi che rispettano l'ordine alfabetico.
Per esempio, la parola ambire viene sillabata come am-bir-e: infatti la lettera a precede la lettera m, e le lettere b, i e r rispettano anch'esse l'ordine.
Analogamente, la parola sotterfugio viene sillabata come s-ott-er-fu-gio.
Dovete scrivere un programma, di nome sillaba che, ricevendo come argomento (sulla riga di comando) una parola, la sillabi. Potete assumere che la stringa in input sia costituita solo da lettere minuscole.
Prototipo richiesto:
	char * syllabify(char * const str);
Esempi: amore -> amor-e; scafroglia -> s-c-afr-o-gl-i-a

/*
es5J: Scrivere una funzione che, ricevuta in input una stringa, inserisca dopo ogni vocale la vocale successiva ('a'->'e', 'e'->'i', 'i'->'o', 'o'->'u', 'u'->'a').
Prototipo richiesto:
	char *insertnextvowel(char * const str);
Esempio: superciao -> suapeircioaeou
*/

/*
es5K: Scrivere una funzione che, ricevuta in input una stringa, la modifichi inserendo dopo ogni lettera minuscola: 0 se è una vocale e 1 se è una consonante.
Prototipo richiesto:
	char *rlebase(char * const str);
Esempio: "ColumBus 1492" -> "Co1l0u1m0Bu1s0 1492"
*/

es5L: Scrivere una funzione che restituisce una stringa formata da start caratteri pad seguiti dai caratteri della stringa str ed infine seguiti da end caratteri pad.
Prototipo richiesto:
	char *strpad(char * const str, unsigned start, unsigned end, char pad);
Esempio: strpad("giorno", 3, 2, '*') -> "***giorno**".

es5M: Scrivere una funzione che mischia due stringhe (merge), mettendo nella stringa di output un carattere preso da st1 e uno preso da st2 (alternativamente). Quando una delle due stringhe di input e` terminata, copia la coda della stringa rimanente.
Prototipo richiesto:
	char * strmix(char * const dst, const char *src1, const char *src2);
Esempio:
	"Luca", "Cordero" -> "LCuocradero"

es5N: Scrivere una funzione che, ricevuta in input una stringa e un numero intero n, esegua la centratura (aggiungendo spazi a sinistra e a destra) della stringa in un campo lungo n. In caso il numero di spazi da aggiungere sia un numero dispari, aggiungerne la metà a sx e la metà+1 a dx.
Suggerimento: mettere a sinistra la metà degli spazi.
Prototipo richiesto:
	char * strcenter(char * const str, const unsigned n);
oppure
	char * strcenter(char * const dst, const char *src, const unsigned n);
Esempio: "ciao", 10 -> "   ciao   "
Esempio: "nel mezzo", 20 -> "     nel mezzo      " (5 spazi a sinistra e 6 spazi a destra)

es5O: Scrivere una funzione che ricevuti una stringa str e un carattere c, inserisca il carattere c in testa alla stringa str
Prototipo richiesto:
	char *rfstr_push_front(char * const str, char c);
Esempio: 'a', "morale" -> "amorale"

es5P: Scrivere una funzione che ricevuti in input una stringa str e un carattere c, inserisca il carattere c in coda alla stringa
Prototipo richiesto:
	char *rfstr_push_back(char * const str, char c);
Esempio: "cast", 'a' -> "casta"
es5Q: Scrivere una funzione che ricevuta in input una stringa str contenente dele cifre, inserisca il separatore delle migliaia
Prototipo richiesto:
	char *numberformat(char * const str);
Esempio: "" -> "", "1" -> "1", "12" -> "12", "123" -> "123", "1234" -> "1.234", "123456" -> "123.456", "12345678" -> "12.345.678"


// Esercizi misti

esOA: Scrivere una funzione che, ricevuto un array di stringhe str[] e la sua lunghezza n, restituisca il prefisso comune a tutte le stringhe.
Prototipo richiesto:
	char * commonPrefix(char * const prefix, const size_t n, const char * str[]) {
Esempio:
	prefix, 3, ("ab25erz", "ab25eh", "ab25yss") -> "ab25"

esOB: Scrivere una funzione che, ricevuta in input una stringa str e un numero naturale k, restituisca il numero di parole di lunghezza k contenute nella stringa str.
Per parola si intende una sequenza di caratteri alfanumerici consecutivi di lunghezza massimale.
Prototipo richiesto:
	unsigned numParoleLungK(const char *str, const unsigned k);
Esempio:
	strcpy(str, "L'Aquila e` un uccello. L'Aquilone no.");
	numParoleLungK(str, 8) --> 1 (Aquilone)
	numParoleLungK(str, 2) --> 2

esOC: Scrivere una funzione che, ricevuta in input una stringa str, stampa per ciascuna cifra (cioè un carattere dell'insieme 0,1,2,3,4,5,6,7,8,9) presente nella stringa il numero di occorrenze. La stampa deve avvenire per cifre crescenti.
Prototipo richiesto:
	void stampaOccorrenzeCifre(const char *str);
Esempio: "3aB91cz33391a" -> la funzione deve stampare:
	la cifra 1 compare 2 volte
	la cifra 3 compare 4 volte
	la cifra 9 compare 2 volte


// altra versione di strrotatedx
Scrivere una funzione, con prototipo char * SMove(char *str, unsigned k), che modifica la stringa str spostando i primi k caratteri in coda alla stringa. Ovviamente se k è maggiore od uguale alla lunghezza di str o k <= 0 allora SMove non fa nulla.
Prototipo richiesto:
	char * SMove(char * const str, const unsigned k);
Esempio: "abcdefg", k=3 -> "defgabc".





// Giochi linguistici e simili
es4E(*): Data una stringa, stampare il suo acronimo (prima lettera -maiuscola- di ogni parola)
es1N(*): Date due stringhe, determinare se la seconda e` un anagramma della prima.
es1O(*): Data una parola o frase, determinare se e` un pangramma, ovvero se contiene tutte le lettere dell'alfabeto (ignorando il case). Es.Pranzo d'acqua fa volti sghembi; Quel fez sghembo copre davanti; Pochi sforzan quel gambo di vite; Qualche vago ione tipo zolfo, bromo, sodio; Quel vituperabile xenofobo zelante assaggia il whisky ed esclama: alleluja!; The quick brown fox jumps over the lazy dog.
es1P(*): Data una parola o frase, determinare se e` eteroletterale, ovvero se tutte le lettere presenti compaiono una sola volta (ignorando il case). Es: Tv? Quiz, Br, Flm, Dc. Oh, spenga! (si tratta di un pangramma eteroletterale).
es1Q(*): Data una frase, determinare se e` un tautogramma, ovvero se tutte le parole hanno la stessa lettera iniziale. Es.Veni, vidi, vici; composizione costruita con componenti che cominciano, categoricamente, con caratteri coincidenti
es1R: Data una frase, determinare se e` "pangrammatica ordinata", ovvero se le lettere dell'alfabeto compaiono nel loro ordine: "A baci d'effigie hai la mano, poi, qui, resa tuo vizio" (A BaCi D'EFfiGie HaI La MaNO Poi Qui ReSa TUo ViZio)".
Specifico meglio: scandisco la stringa cercando una A (ignorando qualunque altra lettera), poi (successivamente alla A) cerco una B (ignorando qualunque altra lettera), ecc. Se riesco a trovare TUTTE le lettere, la frase è ovviamente pangrammatica, ed è anche ordinata, visto che le ho trovate da sx verso dx.

es1S: Data una frase, determinare se e` un lipogramma, ovvero se una (ed una sola) lettera dell'alfabeto non viene mai utilizzata.
es4I: Date due parole, effettuare un lucchetto, ovvero visualizzare una terza parola eliminando i gruppi di lettere comuni in coda alla prima e in testa alla seconda (es: posto / stola = Pola)
es1V: Data una parola o frase, determinare se e` panvocale, ovvero se contiene tutte le vocali (ignorando il case). In caso lo sia, determinare:
1) se le vocali appaiono una sola volta (eterovocale)
2) se le vocali appaiono in ordine: diretto(in italiano non ce ne sono, ma ci sono in inglese), inverso(es.fusoliera), fuori ordine(es.aiuole).
Alcuni esempi: Aurelio, Gaudenzio, ma anche:
15 lettere: contrappuntiste, deumidificatore
14 lettere: buscherandogli, portastrumenti, pubblicheranno, sbruffonaggine;
13 lettere: funamboleschi, compravenduti, concupiscenza, consulsivante, conturbamenti, fruttivendola, inconcludenza, lungometraggi, malprovveduti, prolungamenti, pubblicassero, punzecchiando, sbudellandosi, sollucherarsi, sopravvissute, starnutiremmo;
12 lettere: abbrunimento, abbrustolire, acciucchendo, avventurismo, bachicultore, burocratiche, bustrofedica, centrifugato, conflittuale, consumatrice, crepuscolari, disturbatore, fanciullesco, fibrocellula, frustrazione, imperturbato, luteranesimo, metallurgico, ottantunenni, pennacchiuto, prosciughera`, repubblicano, sducciolera`, sgualcendosi, sopravvenuti, squinternato, stagnicolture, tetracloruri, ultramoderni, ultrasoniche;
11 lettere: accresciuto, agopuntrice, arrostiture, assolutiste, avventurosi, avvolgiture, caposervitu`, carbolineum, chiudendola, ciascheduno, compiutezza, conquistare, consecutiva, disoccupate, documentari, eurasiatico, fraudolenti, fuoriclasse, importunare, macronuclei, occultabile, oltremisura, procedurali, prosciugare, sericoltura, sopravvissute, squadrettoni, subatomiche, subordinera`, sunnominate, superattico, supersonica, tafferuglio, zoppicature;
10 lettere: acquedotti, addivenuto, adenovirus, affettuosi, apicolture, bielorussa, buffoneria, congiurera`, contumelia, curialesco, delittuosa, doppiature, eautonomia, entusiasmo, funicolare, fuoriscena, giuramento, inconsueta, irresoluta, liquefatto, lungolinea, museografi, nebulosita`, numeratori, occupatevi, persuasori, piombature, profumeria, pugilatore, quarzifero, reumatismo, riassumero`, rumoreggia, sciacquone, simulatore, sudorifera, sussiegosa, traduzione, uniformare, uranometri, videoalbum, vituperato, vituperosa, yogurtiera, zuppierona;
 9 lettere: abluzione, acetiluro, adulterio, alogenuri, autentico, autonomie, autopiste, chiesuola, coautrice, cointreau, coniugale, copiature, curiosare, evolutiva, funerario, fuorviare, fusoliera, giacquero, guidatore, impetuosa, inesausto, infuocate, ipotenusa, lunazione, maiuscole, mesosauri, mortuarie, nanocurie, neuronali, preoccupati, prepositura, reliquato, residuato, rieducato, risuonera`, subitaneo, superiora, ubriacone, umanesimo;
 8 lettere: acquieto, adeguino, aleuroni, aliquote, aquilone, aurifero, autogeni, autopsie, cauzione, cuocerai, eguaglio, equatori, equivoca, esauriro`, esaurito, giuocare, mariuole, mausolei, muoverai, ossequia, scuoiera`, suoneria;
 7 lettere: aiutero`, ausonie, autovie, cuoiaie, cuoiame, eiaculo, eufonia, euforia, eulogie, eutocia, eutonia, muoiate, sequoia, tiourea;
 6 lettere: aiuole.

esO.: inserimento stringa
Si scriva una funzione che riceva in input due stringhe e la posizione della prima stringa in cui inserire la seconda.
Prototipo richiesto:
	char *strinsert(char * const frase, const unsigned posizione, const char *parola);
Esempio, se in "nel mezzo del" inserisco "ciao" in posizione 3, ottengo "nelciao mezzo del".
N.B.: Notare che se la posizione e` superiore alla lunghezza della stringa, in caso non ha senso, per cui non fare nulla.


esO.: cancellazione stringa
Si scriva una funzione che riceva in input una stringa, la posizione da cui iniziare la cancellazione e il numero di caratteri da cancellare.
Nota: se posizione+lunghezza e` superiore alla lunghezza della stringa, occorre troncare la stringa.
Prototipo richiesto:
	char *strdelete(char * const dst, const unsigned position, const unsigned length);
Esempio: "nel mezzo del", 3, 4 (cancello 4 caratteri dalla posizione 3) -> "nelzo del".

esO.: copy(estraisottostringa)
Realizzare una funzione che estrae una sottostringa da frase partire da una determinata posizione e per una determinata lunghezza.
Casi particolari:
- Se la posizione e` maggiore della lunghezza della stringa restituire stringa vuota.
- Se la somma di posizione e lunghezza e` maggiore della lunghezza della stringa, restituire la sottostringa fino alla fine della stringa.
Prototipo richiesto:
	char *copy(char * const str, const unsigned position, const unsigned length);
Esempio: str="nel mezzo del" implica:
	copy(str, 22, 4)=""
	copy(str, 12, 4)="l"
	copy(str, 2, 4)="l me"

esO. (Marco L.): Ricevuta in input una stringa s, restituire la piu` lunga sottosequenza crescente di caratteri contigui in s.
Prototipo richiesto:
	void strlongestsubseq(char *str);
Esempio:
	.

esO.: trovare l'ennesima occorrenza di una sottostringa e restituire un puntatore alla sottostringa (o NULL in caso la sottostringa sia presente meno di n volte)
Prototipo richiesto:
	const char * getoccurrence(const char * src, const char * sub, unsigned n);
Esempio:
	.

esO.: Run Length Encoding
Scrivere una funzione che, ricevuta una stringa in input, la trasforma in una stringa equivalente in cui i caratteri multipli sono sostituiti dalla coppia (carattere, numero delle ripetizioni).
Attenzione: la lunghezza della stringa può sia aumentare che diminuire... dipende dal suo contenuto. Quindi usare le memmove.
Prototipo richiesto:
	char * rle(char * const str);
Esempio:
	eefffdddd --> e2f3d4

Transcodifica in alfabeto Morse
Prototipo richiesto:
	char * morse(char * const str);
Esempio:
	aaa sos --> .- .- .- ... --- ...

// ESERCIZI DI CRITTOGRAFIA E SIMILI

/*
esCA: Caesar Cipher
   @see https://en.wikipedia.org/wiki/Caesar_cipher

Prototipi richiesti:
	char *encryptCaesar(char *const dst, const char *src, const int offset);
	char *decryptCaesar(char *const dst, const char *src, const int offset);

Esempio (con l’offset a 3):
	"C1ao a tutti, come stat3?" -> "F1dr d wxwwl, frph vwdw3?"
*/


/*
esCB: Affine Cipher
   @see https://en.wikipedia.org/wiki/Affine_cipher

Prototipi richiesti:
	char *encryptAffine(char *const dst, const char *src, const int a, const int b);
	char *decryptAffine(char *const dst, const char *src, const int a, const int b);

Esempio (con le chiavi a = 24, b = 25):
	"C1ao a tutti, come stat3?" -> "V1zx z nlnnj, vxbr pnzn3?"
*/


/*
esCC: trasposizione colonnare
@see .
Prototipo richiesto:
	char *encryptColumnarTrasposition(char *cipher, const char *msg, const char * key);
	char *decryptColumnarTrasposition(char *msg, const char *cipher, const char * key);
Esempio:
	.
*/


/*
esCD: Baconian
@see https://en.wikipedia.org/wiki/Bacon%27s_cipher
Prototipo richiesto:
	char * encryptBaconian(char * const dst, const char * src)
	char * decryptBaconian(char * const dst, const char * src)
Esempio:
	.
*/


/*
esCE: .
Prototipo richiesto:
	char * encryptKeyword(char * const dst, const char * src, const char * encKey);
	char * decryptKeyword(char * const dst, const char * src, const char * encKey);
Esempio:
	.
*/


/*
esCF scacchiera di Polibio
@see https://it.wikipedia.org/wiki/Scacchiera_di_Polibio
Prototipo richiesto:
	char * encryptPolibio(char * const dst, const char * src);
	char * decryptPolibio(char * const dst, const char * src);
	char * encryptNichilista(char * const dst, const char * src, const char * password);
	char * decryptNichilista(char * const dst, const char * src, const char * password);
Esempio:
	"WIKIPEDIA" -> "52 24 25 24 35 15 14 24 11"
*/


/*
esCG: Railfence Cipher
   @see https://en.wikipedia.org/wiki/Rail_fence_cipher
Prototipo richiesto:
	char * encryptRailFence(char * const dst, const char * src, const int key)
	char * decryptRailFence(char * const dst, const char * src, const int key)
Esempio:
	.
*/


/*
esCH: XOR Cipher
   @see https://en.wikipedia.org/wiki/XOR_cipher
Prototipo richiesto:
	char * cryptXOR(char * const dst, const char * src, const char xorKey);
Esempio:
	.
*/


/*
esCI: Atbash Cipher
   @see https://en.wikipedia.org/wiki/Atbash

Prototipi richiesti:
	char *encryptAtbash(char *const dst, const char *src);
	char *decryptAtbash(char *const dst, const char *src);

Esempio:
	"C1ao a tutti, come stat3?" -> "X1zl z gfggr, xlnv hgzgv?"
*/


/*
esCJ: ROT13 Cipher
   @see https://en.wikipedia.org/wiki/ROT13

Prototipi richiesti:
	char *encryptROT13(char *const dst, const char *src);
	char *decryptROT13(char *const dst, const char *src);

Esempio:
	"C1ao a tutti, come stat3?" -> “P1nb n ghggv, pbzr fgng3?”
*/


/*
esCK: Corbonar Cipher
   @see https://www.laurasia.net/rarilingv/rarilingv_032.php

Prototipi richiesti:
	char *encryptCarbonaro2(char *const dst, const char *src);
	char *decryptCarbonaro2(char *const dst, const char *src);

Esempio:
	"C1ao a tutti, come stat3?" -> “G1oa o dudde, gani zdod3?”
*/


/*
esCL: cifrare(decifrare) una stringa con l'algoritmo di Vigenere (rispettare il case della stringa originale)
   @see https://en.wikipedia.org/wiki/Vigen%C3%A8re_cipher
Prototipo richiesto:
	char * cryptVigenere(char* const dst, const char* src, const char* worm, const int offset);
Esempio:
	.
*/


/*
esCM: cifrare una stringa con l'alfabeto piglatin (https://it.wikipedia.org/wiki/Pig_latin)
   @see https://en.wikipedia.org/wiki/Pig_Latin
Prototipo richiesto:
	void pigLatinWord(char * const str);
	char * pigLatinSentence(char * const dst, const char *src);
Esempio:
	"pig" -> "igpay"
	"latin" -> "atinlay"
	"eat" = "eatway" or "eatay"
	"omelet" = "omeletway" or "omeletay"
*/


/*
esCN: cifrario Pigpen
   @see https://en.wikipedia.org/wiki/Pigpen_cipher
*/


/*
esCO: cifrario Playfair
   @see https://en.wikipedia.org/wiki/Playfair_cipher
*/


/*
esO.: Scrivere una funzione che esegue una trasformazione bifronte (realizzabile solo mediante utilizzo di un dizionario)
Prototipo richiesto:
	char *bifronte(char * const str);
Esempio: "acetone"->"enoteca", "Adige"->"egida", "amitto"->"ottima", "arco"->"ocra", "arte"->"etra", "eraso"->"osare", "idem"->"medi", "onagro"->"organo", "Suez"->"Zeus", "Ares"->"sera".
*/


/*
esO.: Scrivere una funzione che converte il numero n nella base specificata in tre modi diversi
Prototipo richiesto:
	char *itoa1(unsigned n, char * const str, unsigned base) {
	char *itoa2(unsigned n, char * const str, unsigned base) {
	char *itoa3(unsigned n, char * const str, unsigned base) {
Esempio:
	13, dest, 2 -> "1101"

esO.: Scrivere una funzione che converte in binario il numero n utilizzando size cifre
Prototipo richiesto:
	char *itob(unsigned n, char * const str, size_t size);
Esempio:
	13, dest, 8 -> "00001101"

/*
esO.: Scrivere una funzione che, data in input una stringa, un carattere ch e una lunghezza len, restituisca un puntatore al carattere ch se questo compare nei primi len caratteri, NULL altrimenti.
Prototipo richiesto:
	const char *strnchr(const char *str, char ch, size_t len);
Esempio: "abbiategrassoA", 'A', 10 -> (null), "ciao", 'i', 3 -> str+1
*/

/*
Scrivere una funzione che, ricevuta in input una stringa, ...
Prototipo richiesto:
	char *reverseWords1(char * const str);
	char *reverseWords2(char * const str);
	char *reverseWords3(char * const str);
Esempio:
	"Mi piacciono le torte" -> "torte le piacciono Mi"
*/

/*
esR.: alfabeto farfallino
Prototipo richiesto:
	char * farfallinoR_rec(char * const restrict str, unsigned r);
	char * farfallinoR(char * const str);
Esempio:
	"panino" -> "pafanifinofo"
*/


es..: repeatString
	char * repeatString(char * const dest, unsigned n, const char * s);

es..: repeatChar
	char * repeatChar(char * const dest, unsigned n, char c);

// Esercizi con allocazione dinamica

esO.: Scrivere una funzione che, presi in input tre interi non negativi nA, nB, nC, restituisce una stringa allocata dinamicamente che consiste di nA caratteri A seguiti da nB caratteri B seguiti da nC caratteri C.
Prototipo richiesto:
	char *strABC(unsigned nA, unsigned nB, unsigned nC);
Esempio:
	2, 1, 4 -> "AABCCCC"

es..: strRepeatString
	char * strRepeatString(unsigned n, const char * s);

es..: strRepeatChar
	char * strRepeatChar(unsigned n, char c);

es..: lookAndSay
Scrivere una funzione che riempia una stringa come da esempi. Il valore iniziale di str è irrilevante, ma str deve essere adeguatamente dimensionata per poter ospitare il risultato
	char * lookAndSay(char * const str, unsigned n);
Esempi:
 1 -> "1"
 2 -> "11"
 3 -> "21"
 4 -> "1211"
 5 -> "111221"
 6 -> "312211"
 7 -> "13112221"
 8 -> "1113213211"
 9 -> "31131211131221"
10 -> "13211311123113112211"
11 -> "11131221133112132113212221"
12 -> "3113112221232112111312211312113211"
13 -> "1321132132111213122112311311222113111221131221"
14 -> "11131221131211131231121113112221121321132132211331222113112211"

itob