W dniu wtorek, 19 listopada 2019 13:52:06 UTC+1 użytkownik Borneq napisał:

> >> [[1,10],[7,3],[10],[100],[5,6]]
> > Trochę poprawiłem nazwy i formatowanie, może teraz będzie nieco czytelniejsze:
> > https://rextester.com/CRWPJS53169
>
> Wyniki daje dobre.
> Trzeba by przeanalizować, jakie znaczenie ma ++ ?

++ to sklejanie list:

[1,2]++[3,4] daje [1,2,3,4]

Niestety w przypadku języków funkcyjnych dopisywanie elementu na koniec listy jest
raczej kosztowne. No ale to szczegół


> jest tu jakiś sposób rekurencyjny

Jest rekurencyjny, ale to prosta rekurencja, którą można łatwo zamienic na pętlę.
Jakby co, to napisałem rozwiązanie rekurencyjne w Pythonie.

Wariant iteracyjny wygląda tak:

def igroups(l, cond):
result = []
group = []
for x in l:
group += [x]
if cond(group):
result += [group]
group = []
if group:
result += [group]
return result


> grouped [] [] = []
> grouped [] g = [g]
> Te dwa powyżej rozumiem
> a
> grouped (h:t) g
> | (cond (g++[h])) = [g++[h]]++(grouped t [])
> grouped (h:t) g = grouped t (g++[h])
>
> ?

W pierwszym przypadku jest tzn. "pattern guard", tzn. jeżeli funkcja "cond" dla
argumentu g++[h] zwróci True, to zwracamy [g++[h]] ++ (grouped t []), albo innymi
słowy - zamykamy bieżącą grupę z dopisanym bieżącym elementem i tworzymy nową pustą
grupę, którą będziemy przetwarzać na pozostałych elementach listy.

Jeżeli "cond" nie jest spełnione, to dodajemy bieżący element do bieżącej grupy i
przetwarzamy resztę listy.

Tutaj jest Pythonowa wersja, w której umieściłem Haskellowe patterny i guardy w
komentarzach

def groups(l, cond):
def group(l, g):
if l: ### grouped (h:t) g -- lista niepusta
h, *t = l
if cond(g+[h]): ### | (cond (g++[h])) -- warunek spelniony
return [g+[h]]+group(t, [])
return group(t, g+[h]) ### -- warunek niespelniony
if g:
return [g] ### grouped [] g -- grupa jest niepusta
return [] ### grouped [] [] -- pusta grupa
return group(l, [])


Oba warianty możesz potestować tutaj:
https://rextester.com/FCY59693