Back to Questions
1.0k
views2
comments
Just for fun: How would you do an "alternating zip"
f#

Let's say that you had two lists containing characters and you wanted to "zip" them up. That is, not in the usual List.zip sense which takes two lists (same length) and creates another list (same length) of tuples each element in each list.

Let's say that if you had the lists ['H'; 'L'] and ['E';'F'], that when "alternating zipped", would produce ['H';'E';'L';'F']. So you alternate between the first and second list when building the final list.

For example, this code produces two "unzipped" lists from a string:

1
2
3
4

let strin = "Nothing to see here, move along.".ToCharArray() |> List.of_array;
let tuples = strin |> List.mapi (fun i c -> (i,c))
let key1 = tuples |> List.filter (fun (i,c) -> i % 2 = 0) |> List.map (snd);
let key2 = tuples |> List.filter (fun (i,c) -> i % 2 = 1) |> List.map (snd);

Here is my (first attempt) at trying to "alternating zip" them back together.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

let key1 = ['N'; 't'; 'i'; 'g'; 't'; ' '; 'e'; ' '; 'e'; 'e'; ' '; 'o'; 'e'; 'a'; 'o'; 'g'];
let key2 = ['o'; 'h'; 'n'; ' '; 'o'; 's'; 'e'; 'h'; 'r'; ','; 'm'; 'v'; ' '; 'l'; 'n'; '.'];

let tuples = 
  let one = key1 |> List.mapi (fun i c -> (2*i,c));
  let two = key2 |> List.mapi (fun i c -> (2*i+1,c));
  List.concat [one; two];
let message = 
  tuples 
  |> List.sort (fun (i1,_) (i2,_) -> i1-i2) 
  |> List.map (snd) 
  |> List.fold_left (fun c1 c2 -> c1.ToString() ^ c2.ToString()) "";

printfn "%s" message; // prints out "Nothign to see here, move along."

Can anyone think of a better way to accomplish the same thing?

Just curious :) I'm trying to practice my F# as I've got another problem I'm trying to solve that is similar to this (though not with characters and strings).

.

Here's one way to zip them back together. Please note that this has the same prerequisites as List.zip, in that both lists should be of the same length (or, at least, the second list should not be shorter than the first). 

1
2
3
4

let rec altzip x y =
  match x with
  | _::_ -> (List.hd x) :: (List.hd y) :: altzip (List.tl x) (List.tl y)
  | _ -> [];;

If you want to deal with uneven size lists:

1
2
3
4
5
6

let rec altzip2 x y =
  match x,y with
  | _::_, _::_ -> (List.hd x) :: (List.hd y) :: altzip2 (List.tl x) (List.tl y)
  | _::_, _ -> x
  | _, _::_ -> y
  | _, _ -> [];;

It should be easy to thread an accumulator to make these functions tail-recursive. Finally, if you want to use the built-in F# List API:

1
2

let altzip3 x y =
  List.fold_left2 (fun seed one two -> seed @ [one; two]) [] x y

Regards,

z.

By on 12/30/2007 7:02 PM ()

Wow, another nice one z.

I'd completely overlooked the fold_left2 function. I sure wish there were some good examples of how to use each of these List.* functions. There's a ton of functionality there.

Thanks :)

By on 1/2/2008 9:47 AM ()

    Topic tags

    IntelliFactory Offices Copyright (c) 2011-2012 IntelliFactory. All rights reserved.
    Home | Products | Consulting | Trainings | Blogs | Jobs | Contact Us | Terms of Use | Privacy Policy | Cookie Policy     		Built with WebSharper