Comments on: The Ted Neward F# Folding Challenge http://richardminerich.com/2010/04/the-ted-neward-f-folding-challenge/ A programmer's chronicle of insights and discoveries Sun, 05 Feb 2012 02:20:05 +0000 hourly 1 http://wordpress.org/?v=3.3.1 By: Richard Minerich http://richardminerich.com/2010/04/the-ted-neward-f-folding-challenge/comment-page-1/#comment-471 Richard Minerich Tue, 27 Sep 2011 23:46:09 +0000 http://richardminerich.com/?p=76#comment-471 Very nice! Even more valuable would be a step-by-step explanation of your logical reasoning when writing that. Very nice! Even more valuable would be a step-by-step explanation of your logical reasoning when writing that.

]]> By: David Klein http://richardminerich.com/2010/04/the-ted-neward-f-folding-challenge/comment-page-1/#comment-468 David Klein Mon, 26 Sep 2011 09:39:38 +0000 http://richardminerich.com/?p=76#comment-468 @Blake, your solution is the best listed here, concise and clear, thanks! @Blake, your solution is the best listed here, concise and clear, thanks!

]]> By: Blake Hegerle http://richardminerich.com/2010/04/the-ted-neward-f-folding-challenge/comment-page-1/#comment-442 Blake Hegerle Wed, 22 Jun 2011 18:23:33 +0000 http://richardminerich.com/?p=76#comment-442 Here's a solution that I think is more idiomatic of functional programming, with an added benefit of being slightly shorter and possibly easier to understand. let rle list = let push n list = match list with | c :: m :: t when m=n -> (c+1)::m::t | t -> 1::n::t List.foldBack push list [] Here’s a solution that I think is more idiomatic of functional programming, with an added benefit of being slightly shorter and possibly easier to understand.

let rle list =
let push n list =
match list with
| c :: m :: t when m=n -> (c+1)::m::t
| t -> 1::n::t
List.foldBack push list []

]]> By: The Road to Functional Programming in F# – From Imperative to Computation Expressions « Inviting Epiphany http://richardminerich.com/2010/04/the-ted-neward-f-folding-challenge/comment-page-1/#comment-360 The Road to Functional Programming in F# – From Imperative to Computation Expressions « Inviting Epiphany Tue, 08 Feb 2011 21:56:20 +0000 http://richardminerich.com/?p=76#comment-360 [...] route when generating sequence values by using the Seq.init function.  As I discussed in my Ted Neward’s Folding Challenge post, the contents of the folding function can be directly mapped to the imperative and recursive [...] [...] route when generating sequence values by using the Seq.init function.  As I discussed in my Ted Neward’s Folding Challenge post, the contents of the folding function can be directly mapped to the imperative and recursive [...]

]]> By: Jon-Anders Teigen http://richardminerich.com/2010/04/the-ted-neward-f-folding-challenge/comment-page-1/#comment-259 Jon-Anders Teigen Mon, 08 Nov 2010 07:39:59 +0000 http://richardminerich.com/?p=76#comment-259 // scala def fold(list:List[Int]) = list.foldRight(List[Int]()){ (e, a) => a match { case num :: `e` :: rest => num + 1 :: e :: rest case _ => 1 :: e :: a } } def reconstruct(list:List[Int]):List[Int] = list match { case Nil => Nil case num :: e :: rest => Nil.padTo(num, e) ::: reconstruct(rest) } val challenge1 = List(4, 5, 5, 5, 3, 3) val result1 = List(1, 4, 3, 5, 2, 3) val challenge2 = List(4, 5 , 4) val result2 = List(1, 4, 1, 5, 1, 4) fold(challenge1) == result1 fold(challenge2) == result2 reconstruct(result1) == challenge1 reconstruct(result2) == challenge2 // scala

def fold(list:List[Int]) = list.foldRight(List[Int]()){ (e, a) => a match {
case num :: `e` :: rest => num + 1 :: e :: rest
case _ => 1 :: e :: a
}
}

def reconstruct(list:List[Int]):List[Int] = list match {
case Nil => Nil
case num :: e :: rest => Nil.padTo(num, e) ::: reconstruct(rest)
}

val challenge1 = List(4, 5, 5, 5, 3, 3)
val result1 = List(1, 4, 3, 5, 2, 3)
val challenge2 = List(4, 5 , 4)
val result2 = List(1, 4, 1, 5, 1, 4)

fold(challenge1) == result1
fold(challenge2) == result2

reconstruct(result1) == challenge1
reconstruct(result2) == challenge2

]]> By: Alex Boisvert http://richardminerich.com/2010/04/the-ted-neward-f-folding-challenge/comment-page-1/#comment-258 Alex Boisvert Mon, 08 Nov 2010 06:20:38 +0000 http://richardminerich.com/?p=76#comment-258 Hi Eric, your one-liner is unfortunately incorrect since 'groupBy' produces groups irrespective of element sequencing. Here's another Scala variation, similar to Tim Dalton's above, def compress[T](l: List[T]) = l.foldLeft(List[(T, Int)]()) { case (Nil, x) => (x, 1) :: Nil case ((y, c) :: r, x) if (x == y) => (x, c+1) :: r case (l, x) => (x, 1) :: l }.reverse scala> compress(List(4,5,5,5,3,3)) res0: List[(Int, Int)] = List((4,1), (5,3), (3,2)) Hi Eric, your one-liner is unfortunately incorrect since ‘groupBy’ produces groups irrespective of element sequencing.

Here’s another Scala variation, similar to Tim Dalton’s above,

def compress[T](l: List[T]) = l.foldLeft(List[(T, Int)]()) {
case (Nil, x) => (x, 1) :: Nil
case ((y, c) :: r, x) if (x == y) => (x, c+1) :: r
case (l, x) => (x, 1) :: l
}.reverse

scala> compress(List(4,5,5,5,3,3))
res0: List[(Int, Int)] = List((4,1), (5,3), (3,2))

]]> By: Eric http://richardminerich.com/2010/04/the-ted-neward-f-folding-challenge/comment-page-1/#comment-257 Eric Mon, 08 Nov 2010 04:55:11 +0000 http://richardminerich.com/?p=76#comment-257 Here is a one-liner in Scala: Seq(4,5,5,5,3,3) groupBy identity flatMap { case (n, l) => Seq(l.size, n) } => List(1, 4, 2, 3, 3, 5) Here is a one-liner in Scala:

Seq(4,5,5,5,3,3) groupBy identity flatMap { case (n, l) => Seq(l.size, n) }
=> List(1, 4, 2, 3, 3, 5)

]]> By: JadeNB http://richardminerich.com/2010/04/the-ted-neward-f-folding-challenge/comment-page-1/#comment-159 JadeNB Wed, 14 Jul 2010 22:58:35 +0000 http://richardminerich.com/?p=76#comment-159 Here's another Haskell solution, this time without <code>group</code>. It's a bit naughty, because it does a lot of list con- and destruction. <code> foldr ( \(a, b) abs -> a:b:abs ) [] . foldr ( \a ps -> case ps of (n, a'):rest | a == a' -> (n + 1, a):rest otherwise -> (1, a):ps ) [] </code> Here’s another Haskell solution, this time without group. It’s a bit naughty, because it does a lot of list con- and destruction.

foldr (
\(a, b) abs -> a:b:abs
) [] . foldr (
\a ps ->
case ps of
(n, a'):rest | a == a' -> (n + 1, a):rest
otherwise -> (1, a):ps
) []

]]> By: prakash http://richardminerich.com/2010/04/the-ted-neward-f-folding-challenge/comment-page-1/#comment-102 prakash Fri, 14 May 2010 14:25:24 +0000 http://richardminerich.com/?p=76#comment-102 It's been pointed to me that using stateful variable like $count isn't functional. Here's another approach (hopefully functional enough) in Perl 6: ( reduce { $^a.elems ?? $^b != $^a[*-1] ?? [ $^a[*], 1, $^b ] !! [ $^a[0..$^a.elems-3], $^a[*-2]+1, $^b ] !! [ 1, $^b ] }, [], 4, 5, 5, 5, 3, 3 ).perl.say; It’s been pointed to me that using stateful variable like $count isn’t functional. Here’s another approach (hopefully functional enough) in Perl 6:

(
reduce {
$^a.elems
?? $^b != $^a[*-1]
?? [ $^a[*], 1, $^b ]
!! [ $^a[0..$^a.elems-3], $^a[*-2]+1, $^b ]
!! [ 1, $^b ]
}, [], 4, 5, 5, 5, 3, 3
).perl.say;

]]> By: Richard Minerich http://richardminerich.com/2010/04/the-ted-neward-f-folding-challenge/comment-page-1/#comment-101 Richard Minerich Wed, 12 May 2010 18:50:35 +0000 http://richardminerich.com/?p=76#comment-101 Mission successful. Mission successful.

]]>