Il problema da risolvere è abbastanza intuitivo; dato un set di segmenti identificati da coppie di interi [inizio, fine] bisogna fondere tra loro i segmenti che si sovrappongono.

Primo Algoritmo:

La mia prima idea (anche se alcuni molti credits vanno a Niji) è stata quella di spostare ad uno ad uno i segmenti dal set di input a quello di output;  durante questa procedura ogni segmento che si sovrappone ai rimanenti del set di input viene fuso ed il risultato spostato in output. Alla fine di un intero ciclo di spostamento nel set di output trovano posto un numero di segmenti minore o uguale a quelli presenti nel set di input a seconda del numero di fusioni.

Con un numero di segmenti minore rispetto a quello del set di input l’algortimo procede ad un nuovo ciclo di spostamento, se invece il numero dei segmenti è lo stesso allora significa che non vi sono più fusioni da effettuare e che quindi quanto contenuto in output rappresenta il risultato definitivo.

Questo algoritmo, che in un primo momento mi era sembrato di una complessità non riducibile, si è invece rivelato computazionalmente molto più impegnativo del secondo, del quale ho tentato anche un implementazione in Erlang.

Secondo Algoritmo:

La differenza principale di questa procedura (per la quale devo ringraziare Fabio) rispetto alla precedente è l’introduzione di un elemento di ordinamento che riassetta il set di input organizzando i segmenti come se fossero poggiati su di una immaginaria linea retta. A questo punto avendo tutti i segmenti ordinati (supponiamo che [A,B,C,D] siano 4 segmenti) è possibile confrontarli a coppie di due ( A e B, B e C, ecc..) fondendo la coppia quando necessario (se A e B si sovrappongono in B dovrà essere riportato il risultato della fusione tra i due).

L’implementazione che ho sviluppato è lungi dall’essere perfetta in quanto denota tutte le mie carenze nei confronti di Erlang, del quale stò cercando di apprendere i segreti, ma dovrebbe essere sufficiente a rendere l’idea:

-module(coverage).
-export([sort_cover/1]).
-import(lists,[sort/2,foldl/3]).

sort_cover(A) ->  lists:foldl(
	fun([E1,E2],[[H1,H2]|T]) ->
		if
		 	((E1 >= H1) and (E1 =< H2)) or ((E2 >= H1) and (E2 =< H2)) -> [[
				if
					E1 >= H1 -> H1;
					true	 -> E1
				end,
				if
					E2 >= H2 -> E2;
					true	 -> H2
				end
			]|T];

			true	->	[[E1,E2]|[[H1,H2]] ++ T]
		end
	end, [[-1,-1]],
	lists:sort( fun([K,I],[L,M]) -> (K < L) or ((K >= L) and (I =< M)) end, A)).

La caratteristica migliore di questo algoritmo è sicuramente la sua bassa complessità: O(nlogn); l'operazione computazionalmente più costosa è infatti il sort.

Ecco la mia soluzione, sono 100 caratteri:

def k(l,n);l==''?n:l.split(//).map{|s|k(l.sub(s,''),n+s)}end;p k((ARGV[0]||"abcd"),'').flatten.uniq

Per questa soluzione mi sono inspirato ad una bellissima funzione scritta in Erlang:

permutation([]) -> [[]];
permutation(L)  -> [[H|T] || H <- L, T <- permutation(L--[H])].

Vediamo un pò di orientarci con questa particolare sintassi: Erlang utilizza dei pattern per descrivere quale ‘versione’ della funzione utilizzare, in questo caso abbiamo due ‘permutation’, una che si attiva quando il parametro è una lista vuota e una quando non lo è.

Concentriamoci quindi sulla seconda riga:  il nome del costrutto che stiamo osservando si chiama ‘List Comprehension‘ ed il suo funzionamento è tutto basato nell’eseguire l’operazione a sinistra del doppio pipe ‘||’ utilizzando i valori specificati nella parte destra.

Quindi nel nostro caso stiamo costruendo una lista di liste; notiamo infatti che a sinistra del doppio pipe risiede il costrutto classico di lista in Erlang:  [H|T]  ( H stà per Head e rappresenta il primo elemento della lista, T per tail e indica i rimanenti elementi della lista). Ma come vogliamo che sia costruita ognuna di queste liste ? La risposta è nella parte destra del List Comprehension:

• In H si alterneranno tutti gli elementi di L
• In T, per ogni elemento di L, si alterneranno le liste derivanti dal calcolo delle permutazioni sulla lista L privata dell’elemento che è in H.

In queste sede mi sono limitato ad una veloce overview sul funzionamento della funzione ‘permutation’ in Erlang;  per chi intenedesse approfondire la tematica consiglio vivamente questo articolo di Peter Miller che riesce a illustrare in modo molto comprensibile quanto io qui ho solo sommariamente spiegato.