librelist archives

« back to archive

Re: [erlar] [SOLUCIONADO] Consulta manejo de listas

Re: [erlar] [SOLUCIONADO] Consulta manejo de listas

From:
Carlos Pantelides
Date:
2013-06-01 @ 17:20
Tordek:

> ¿No probaste, o no te sirvieron?

Cuando vi esto, 

> normalize([ L = [ [{_,_,_}, {_,_,_}] | _ ]]) -> L;
> normalize(L) -> L.

me di cuenta que no estaba preguntando bien, ya que no 
estaba transmitiendo cual era la estructura de las listas,
ya habia probado cosas muy parecidas, asi que fuí reformulando
la pregunta.

> Eso, y, en vez de tirarnos tests para lo que tiene que hacer
>`depth` (que es incidental a tu problema), qué tal si definis 
> `normalizar`, y si se necesita una función adicional se implementará.

puse los tests para mostrar que ya estaba funcionando lo que
necesitaba, con eso me refería a 

> > Para resolver mi problema alcanza, buen enfoque. Como
> depth()
> > genérico no, pero esa ya es una cuestión deportiva.

el enfoque de Angel me destrabó, ni siquiera estaba seguro de mis tests.

Ya puedo implementar normalizar(), usando depth() o seguir luchando con
una expresión parecida a la que enviaron y con la cual estaba fracasando.

Ahora, como puedo confiar en mis tests de normalizar(), podría intentar
reimplementarla sin depth(), pero no estando bloqueado.

Espero que se me haya entendido y perdón por cualquier confusión que
pueda haber generado durante mi proceso de aprendizaje. Como dije al 
comienzo "prefiero sugerencias a soluciones", eso no es coherente con
que te tire los tests para que lo hagas vos, jaja.

Gracias a todos otra vez.

Charli

Re: [erlar] [SOLUCIONADO] Consulta manejo de listas

From:
Tordek
Date:
2013-06-01 @ 21:39
2013/6/1 Carlos Pantelides <carlos_pantelides@yahoo.com>

>
> me di cuenta que no estaba preguntando bien, ya que no
> estaba transmitiendo cual era la estructura de las listas,
> ya habia probado cosas muy parecidas, asi que fuí reformulando
> la pregunta.
>

Excelente, reformular la pregunta para entender el problema es exactamente
el motivo por el que siempre pregunto "¿por qué querés hacerlo así?". Vi
miles de problemas XY que se solucionan cambiando 1 linea en otra función
más fácil que agregando 15 en otra.

> > Para resolver mi problema alcanza, buen enfoque. Como
> > depth()
> > > genérico no, pero esa ya es una cuestión deportiva.
>
> el enfoque de Angel me destrabó, ni siquiera estaba seguro de mis tests.
>

¡Excelente! Entonces, sale la pregunta:

¿Solucionaste? ¿Cómo? (Digo, está copado que compartas la respuesta así nos
burlamos^H^H^H te tiramos ideas de si se puede mejorar (eso, y por
curiosidad)).

Digo, porque si al final tenés:

normalizar(L) ->
  case depth(L) of
    3 -> [X] = L, X;
    _ -> L
  end.

entonces retorno a mi expresión corregida en base a lo que mostró Sebastián:

normalizar([L = [[_|_]|_]]) -> L;
normalizar(L) -> L.

(Porque queda copada.)

Y si tu solución no se parece en nada a eso, ¿nos contás cómo hiciste?


> Gracias a todos otra vez.
>
> Charli
>


P.D.: Tomar en serio mis comentarios en chiste lleva a pasarla mal.

--
Tordek

Re: [erlar] [SOLUCIONADO] Consulta manejo de listas

From:
Carlos Pantelides
Date:
2013-06-16 @ 19:18
A medida que he avanzando en el problema, he hallado una mejor solución:

Replanteo el problema.

Tengo que obtener una lista de listas a partir de una lista que debido al 
funcionamiento de la función generadora, me produce distintos niveles de 
anidamiento, por ejemplo:

[ [ lista1], [lista2] ]

[ [ lista1,lista2], [lista3]]

[ [ [ lista1] ,lista2], [lista3]]

Lo que me esta pidiendo a gritos, como dijo Gabriel al comienzo, es un 
flatten, pero eso haría que los elementos de las listas se confundieran en
una sola gran lista:

[ [  [ L1E1,L1E2] ,[L2E1,L2E2] ] , [L3E1,L3,E2] ]
se convierte en

[  L1E1,L1E2,L2E1,L2E2, L3E1,L3,E2]
cuando yo quiero

[ [ L1E1,L1E2] ,[L2E1,L2E2], [L3E1,L3,E2] ]


La mejor solución que hallé fue convertir durante la generación cada Lista
en {set,Lista}, de modo tal que flatten se detiene en la dupla y luego 
remover las duplas:


unset({set,X})->X.

fix(TokenSets={set,_})->
   [unset(TokenSets)];
fix(TokenSets) ->
   [ unset(Sets)  || Sets <-   lists:flatten(TokenSets) ]. 
   
generate(Tokens) ->
   fix(generate(Tokens,[])).


% implementacion parcial, sólo muestro el último paso

generate([],Accum) ->
   {set,lists:reverse(Accum)}.



Comparto esta solución por si alguna vez alguien se encuentra con este problema.
 
Carlos Pantelides


@dev4sec

Re: [erlar] [SOLUCIONADO] Consulta manejo de listas

From:
Angel Java Lopez
Date:
2013-06-16 @ 19:31
Y algo como:

myflatten([[H1,T1], T]) -> myflatten([H1, [T1, T]]).

myflatten([H,[H2,T2]) -> [H, myflatten([H2, T2]).

myflatten([H,T] -> [H,T]

funciona? Escribi a mano alzada ;-)

Angel "Java" Lopez
@ajlopez
justo trabajando en
https://github.com/ajlopez/AjErl


2013/6/16 Carlos Pantelides <carlos_pantelides@yahoo.com>

> A medida que he avanzando en el problema, he hallado una mejor solución:
>
> Replanteo el problema.
>
> Tengo que obtener una lista de listas a partir de una lista que debido al
> funcionamiento de la función generadora, me produce distintos niveles de
> anidamiento, por ejemplo:
>
> [ [ lista1], [lista2] ]
>
> [ [ lista1,lista2], [lista3]]
>
> [ [ [ lista1] ,lista2], [lista3]]
>
> Lo que me esta pidiendo a gritos, como dijo Gabriel al comienzo, es un
> flatten, pero eso haría que los elementos de las listas se confundieran en
> una sola gran lista:
>
> [ [  [ L1E1,L1E2] ,[L2E1,L2E2] ] , [L3E1,L3,E2] ]
> se convierte en
> [  L1E1,L1E2,L2E1,L2E2, L3E1,L3,E2]
> cuando yo quiero
> [ [ L1E1,L1E2] ,[L2E1,L2E2], [L3E1,L3,E2] ]
>
> La mejor solución que hallé fue convertir durante la generación cada Lista
> en {set,Lista}, de modo tal que flatten se detiene en la dupla y luego
> remover las duplas:
>
> unset({set,X})->X.
>
> fix(TokenSets={set,_})->
>    [unset(TokenSets)];
> fix(TokenSets) ->
>    [ unset(Sets)  || Sets <-   lists:flatten(TokenSets) ].
>
> generate(Tokens) ->
>    fix(generate(Tokens,[])).
>
> % implementacion parcial, sólo muestro el último paso
> generate([],Accum) ->
>    {set,lists:reverse(Accum)}.
>
>
> Comparto esta solución por si alguna vez alguien se encuentra con este
> problema.
>
> Carlos Pantelides
>
> @dev4sec
>
>
>

Re: [erlar] [SOLUCIONADO] Consulta manejo de listas

From:
Carlos Pantelides
Date:
2013-06-16 @ 21:23
Angel:


>Y algo como:
>myflatten([[H1,T1], T]) -> myflatten([H1, [T1, T]]).
>myflatten([H,[H2,T2]) -> [H, myflatten([H2, T2]).
>myflatten([H,T] -> [H,T]
>funciona? Escribi a mano alzada ;-)

Tras haberlo toqueteado un poco, compila, pero no pasa los tests. Eso no 
es concluyente, ya que tuve que quitar la "protección" que había agregado 
y modificar los tests, pude haberme equivocado, pero rompe demasiados y 
los apropiados. Si querés vuelvo a probar, si no, en unos pocos dias(*) 
cuando publique el código te muestro justo donde va.

myflatten([[H1,T1], T]) -> myflatten([H1, [T1, T]]);
myflatten([H|[H2,T2]]) -> [H, myflatten([H2, T2])];
myflatten([H,T]) -> [H,T].

Charli

(*) si no me encuentro con otro bloqueante como este...

Re: [erlar] [SOLUCIONADO] Consulta manejo de listas

From:
Carlos Pantelides
Date:
2013-06-02 @ 15:09
Tordek:

Hago un diálogo ficticio para que quede más fluido que inline


TORDEK: me parece bien reformular la pregunta

CHARLI: para que te des una idea, sólo envío a los foros una de cada 
cuatro o cinco preguntas, el hecho de prepararlas suele llevarme a la 
solución.

TORDEK: compartí la solución, si es con un case, probá la mía corregida


CHARLI: perdón que no la compartí ya, el árbol me impide ver el bosque a 
veces, de todos modos la iba a compartir en pocos días al terminar el 
proyectito. Ahí va, con un case, por supuesto, décadas de spaghetti, 
estructurado y OOP no se corrigen de la noche a la mañana:

-------------------------------------------

depth([H|_])->
   depth(H) + 1;
depth([])->
   1;
depth(_) ->
   0.

fix([[[]]]) ->
   [];
fix([[]]) ->   
  [];
fix([]) ->  
  [];
fix(Tokens)->
   Levels = depth(Tokens),
   case Levels of
     0->[[Tokens]];
     1->[Tokens];
     2->Tokens;
     3->[R]=Tokens,
        R
   end.

generate(Tokens) ->
   fix(generate(Tokens,[])).

generate(Tokens,Accum) -> 
   %fuera del ambito del problema, por ahora

-------------------------------------------
Al probar lo que enviás:


normalizar([L = [[_|_]|_]]) -> L;
  normalizar(L) -> L.

   
generate(Tokens) ->
   normalizar(generate(Tokens,[])).

-------------------------------------------

funciona para el enunciado original, pero, revisando mis test, hay unos 
casos en los cuales en lugar de quitar anidamiento, hay que agregar.

TORDEK: pusiste %fuera de ambito, por que no corregís ahí?

CHARLI: por que ahora es un problema menor, en algún momento pasaré 
refactorizando, necesitaba tener bien los tests.

TORDEK: eh, no te pongás tan serio, 

CHARLI: es que en este medio cuesta discernir las entonaciones, chau y 
gracias, nos vemos

TORDEK: chau

CHARLI: ...

TORDEK: ...

CHARLI: cortá vos

TORDEK: no, cortá vos

CHARLI: bueno, a la vez

TORDEK: si

[ tuuu || _ <- lists:seq(1, 10) ]. 


Re: [erlar] [SOLUCIONADO] Consulta manejo de listas

From:
Carlos Pantelides
Date:
2013-06-02 @ 16:03
Ahora que puedo confiar en los tests, puedo hacer las cosas mejor, como 
hacer depth() tail recursive 


-depth([H|_])->
-   depth(H) + 1;
-depth([])->
-   1;
-depth(_) ->
-   0.
+depth(L) ->
+  depth(L,0).
+  
+depth([H|_],Accum)->
+   depth(H,Accum + 1);
+depth([],Accum)->
+   Accum +1;
+depth(_,Accum) ->
+   Accum.

Charli