Thursday, July 14, 2016

1HaskellADay 1Liners June 2016

  • June 13th, 2016:
    You want this list: [1, -1, 1, -1, ...]
    How would you produce this value in #Haskell ?
    • Wai Lee Chin Feman @wchinfeman
      (set plop to be identity, and set transformstate to be (*) -1)
    • Philipp Maier @AkiiZedd `iterate negate 1
    • Patrick Mylund @pmylund concat $ repeat [1, (-1)]
      • Gary Fixler @gfixler No need for the parens in a list.
    • Jeff Foster @fffej and Kevin Meredith @Gentmen
      iterate (* (- 1)) 1
    • Spencer Janssen @spencerjanssen and Андреев Кирилл @nonaem00
      cycle [1, -1]
      • Philipp Maier @AkiiZedd:
        I’m curious: Since concat is O(n) wouldn’t it take more and more time depending on how many items you take?
      • Patrick Mylund @pmylund Looks like they compile to the same thing
      • Philipp Maier @AkiiZedd I’m actually surprised the compiler can optimise this away :o Thanks for showing me ddump-simpl!
      • Eyal Lotem @EyalL concat is foldr (++), not foldl. O(1) work is done to produce the next item. [1,-1]++([1,-1]++(...
    • David Turner @DaveCTurner I'd actually write 'cycle [1,-1]' but I like the elegant, alliterative obscurity of   'iterate negate 1'
    • Fatih Karakurt @karakfa alt=1:[-x|x<-alt]

Friday, July 1, 2016

June 2016 1HaskellADay Problems and Solutions

  • June 29th, 2016: Today's #Haskell exercise is REALLY HARD! ... for Big Gov't. Can you solve it? A little bit of (well-typed) Prolog-like code gets us our #haskell solution for today 
  • June 28th, 2016: For today's #haskell problem we do ... NOTHING! But we are introduced to coding software for a huge bureaucracy  ... AAAAANNNDDD three System imports and we've got today's #haskell solution. Groovy! 
  • June 24th, 2016: #haskell problem today charts Stochastic Oscillators of a security  and includes a 'malus' problem: report generation 
  • June 23rd, 2016: Today we look at using #haskell to chart moving averages of a stock's prices 
  • June 21th, 2016: I pushed today's #haskell problem last night on git but did I announce it? sigh Complex roots of quadratic equations The #haskell solution gives us the Complex roots to any (Real) quadratic equation
  • June 20th, 2016: Solving quadratic equations is on the plate for today's #haskell exercise 
    It's not every day I code
    Thank you, #haskell, for today's solution to do so
  • June 17th, 2016: My, my! Where has the day flown? Today's #haskell problem is to reinvent charting API! ... or not.
  • June 16th, 2016: Today's #haskell exercise looks at representing $TWTR data as candlesticks 
  • June 15th, 2016: For today's #haskell problem, we round out the Data.Matrix module with the definition of the identity matrix There are many ways to define the identity matrix. Today's #haskell solution does so with Cellular Automata Rule 16
  • June 14th, 2016: Yesterday we computed the matrix determinant, today we'll invert a matrix and use it to solve systems of equations Today's #haskell solution inverts a matrix BECAUSE WE FEEL LIKE IT! Yeah
  • June 13th, 2016: For today's #haskell problem we *ahem* DETERMINE (eventually) to solve systems of equations The determinant is the sum of the products of the first row with the sub-matrix determinants, right? RIGHT!
  • June 10th, 2016: Today's #haskell problem looks at box-and-whiskers charting of data Boxes for realz, yo: The #haskell solution has @geophf writing 'uncurry uncurry' and sincerely meaning it! 😱 and box: 
  • June 9th, 2016: Triangles are on my mind for today's #haskell problem: … bisecting them, then trisecting them.
  • June 8th, 2016: For today's #haskell problem, just what you've always wanted: MATH HOMEWORK! We find the intersection of two lines
  • ANNOUNCEMENT: is acting up; cloning original @1HaskellADay github repository and putting the exercise there. FYI
  • June 6th, 2016: Today's #haskell problem explores superstring theory No, it doesn't, but saying that has a certain ring to it!
  • June 3rd, 2016: We saw a solution to perfect matching yesterday. For today's #haskell problem, let's efficient-ize it!
  • June 1st, 2016: Today's #haskell problem is pretty much counting complements ... pretty much. These apparently simple problems are actually rather hard. Today we have a #P-complete #haskell solution

Tuesday, June 14, 2016

May 2016 1Liners

  • May 24th, 2016:
    Given f :: a -> [a] -> b, g :: a -> c
    Write h :: c -> [c] -> b, point-free, in terms of f and g
    where h x y = f (g x) (map g y)
  • May 16th, 2016: The next 3 #1Liner are of a piece, using
    data CmpV a =
       Vec { len :: Int, top :: a,  elts :: [a],
             cmp :: CmpV a -> CmpV a -> Ordering }
    • Give the point-free definition of:
      twoVs :: CmpV a -> CmpV b -> ([a], [b])
    • instance Ord (CmpV a) where
         compare v1 = uncurry (cmp v1) .  (v1,)

      Make compare point-free by removing v1 from above definition
    • An Ord-instance needs an Eq-instance:
      instance Eq a => Eq (CmpV a) where
         v1 == v2 = elts v1 == elts v2

      point-free-itize (==)
  • May 16th, 2016: You have the following lambda:
    \x y -> x == y || fn x y
    where fn :: a -> a -> Bool
    • obadz @obadzz without any fancy uses of the (a ->) Applicative :)
      curry $ foldr (||) False . flip map [(==), fn] . flip uncurry
    • obadz @obadzz with fancy use of (a ->) Applicative :)
      curry $ liftA2 (||) (uncurry (==)) (uncurry fn)
    • Noah Luck Easterly @walkstherain
      curry $ uncurry (||) . (uncurry (==) &&& uncurry fn)
  • May 5th, 2016:
    sames :: Eq a => [a] -> [a] -> Int
    Counts equal values at the same indices in two lists.
    What is the point-free definition?
    • joomy @cattheory
      sames = curry (length . filter (uncurry (==)) . uncurry zip)
    • bazzargh @bazzargh and then Fatih Karakurt @karakfa
      ((length . filter id) .) . zipWith (==)
    • me: sum <<- fromenum="" li="" nbsp="" zipwith="">
    • Noah Luck Easterly @walkstherain
      sames = ((sum . map fromEnum) .) . zipWith (==)
      • `getSum . foldMap (Sum . fromEnum)` seems better than `foldr (bool id succ) 0` but both satisfy `[Bool] -> Int`
    • Андреев Кирилл @nonaem00
      let it = (length .) . (filter id .)  . zipWith (==)

Wednesday, June 1, 2016

May 2016 1HaskellADay Problems and Solutions

May 2016

  • May 31st, 2016: Today's #haskell problem gets a subsequence of DNA from ... DNA! Today's #haskell solution: DNA subsequence GOT
  • May 30th, 2016: We find the number of RNA strands that can generate a protein ... modulo reasonableness for today's #haskell problem Today's #haskell solution shows us there are 'more than a few' RNA strands to compose some proteins
  • May 27th, 2016: For today's #haskell problem we sing: No woman, Nah Trie! Or: Breath-first Trie Traversal via the branches. We take breathing-lessons for today's #haskell solution
  • May 26th, 2016: For today's #haskell problem we label the nodes of a Trie ... or at least we ... TRIE to! *groan Today's #haskell solution is a depth-first traversal of a Trie
  • May 25th, 2016: Today's #haskell problem ask you to exercise your probability muscles and look at some allele-pairings That's all.
  • May 24th, 2016: Reverse Palindromes in DNA strands?Yes. Today's #haskell problem. Turns out there are lots of palindromes in DNA strands as today's #haskell solution shows. Go figure.
  • May 23rd, 2016: Splice, splice, baby! We get all Vanilla Ice with RNA with today's #haskell problem We get our protein when with today's hand-rolled List-y-(\\) #haskell solution
  • May 20th, 2016: For today's #haskell problem we consider the weighty matter of ... weighing matter The weight's the thing Wherein I'll catch the conscience of the King ... no ... weight ...Today's #haskell solution
  • May 19th, 2016: Today's #haskell problem looks at the Carmina Burana ... uh, no, it doesn't: Open Reading Frames.  Today's #haskell solution sequences DNA strands to proteins
  • May 18th, 2016: If at first you do not succeed, trie and trie again today's #haskell problem #trie #datatype 
  • May 17th, 2016: "Houston. We have a problem." #bigdata factors into today's #haskell problem of longest monotonic sequences
  • May 16th, 2016: Today's #Haskell problem asks for longest monotonic increasing/decreasing sequences ... in the small ... So, the #haskell solution works against small data set, but since it's bifurcating, against large data sets? ...
  • May 13th, 2016: #Rosalind is impatient. She doesn't have all day! Let's find a real-world solution to today's #haskell problem Finding the longest common gene subsequence of 100 strands each 1000 nucleotides long in #haskell Can you find faster?
  • May 12th, 2016: We propose a little problem from Set Theory for today's #haskell problem And we have today's #haskell in-a-perfect-world solution of the set-intersection of all subsequences
  • May 11th, 2016: Today's #haskell problem is all about the inods ... not 'inodes,' but 'internal nodes of an unrooted binary tree.' "inods?" you say? "Of an unrooted binary tree?" you say? That would be pred . pred for today's #haskell solution
  • May 10th, 2016: For today's #haskell problem we take it to the next level, see? and get variable-length strings as enumerated tokens We pulled the powerSet Set.fromList Set.toList switcheroo for today's #haskell solution.
  • May 9th, 2016: For today's #haskell problem we sing our A, B, Cs ... #Rosalind-style! Today's #Haskell solution enumerates lexed tokens
  • May 6th, 2016: For today's #haskell problem we ask #Rosalind and she says 'Permutations.' So that's what we do! This is the dawning of the age of Aquarius! "Hair" a movie about perms for today's #haskell solution @NickiElson3D 
  • May 5th, 2016: Today's #haskell problem: p-distance Matrices Believe you me: you will get a LOT of continued employment with these Today's #haskell solution is filed under #jobsecurity #distanceMatrix
  • May 4th, 2016: Today's #haskell problem we look at completing a graph into the Tree of Life #Rosalind Today's #haskell solution is graph-y, or also take the approach of @bazzargh
  • May 3rd, 2016: Today's #haskell problem looks at overlapping graphs, specifically for DNA strands from Did you know a list is a graph? Today's #haskell solution was an elaboration of `isSuffixOf` #Rosalind 
  • May 2nd, 2016: For today's #haskell problem we look at transforming our data into d3: "Data-driven document"-JSON For the #haskell solution we get a bird's-eye view of the Top5s stocks 

Thursday, May 5, 2016

April 2016 1HaskellADay 1Liners

  • April 15th, 2016:
    (\(intensf, list) -> map (second intensf) list) (insensifierFn, assocList)
    Point-free-itize this lambda
    • obadz @obadzz uncurry $ map . second
  • April 15th, 2016:
    foldr (\card -> let c = color card in mappend c *** ((idx card, c):))
           (mempty, []) cards
    Point-free-itize and de-let lambda
    • Gautier DI FOLCO @gautier_difolco foldr (uncurry (***) . (uncurry fmap . fmap (((,) =<< mappend) . color) . ((,) =<< ((:) .) . (,) . idx))) (mempty, []) cards
    • me: foldr (uncurry (***) . (mappend . snd &&& (:)) . (idx &&& color)) (mempty, [])
  • April 15th, 2016: map (\(idx, color) -> C idx (cell bb idx) color) assoclist
    point-free-itize the lambda in the map function.
    • Eyal Lotem @EyalL uncurry (C <*> cell bb) ?
      Not in front of a type checker, can't check myself :)
  • April 13th, 2016:
    point-free-itize lambda term in:
    uncurry (foldr (\a -> min a *** max a)) . ((head &&& head) &&& id)
    • obadz @obadzz liftA2 (***) min max
  • April 12th, 2016:
    minmax :: Ord a => [a] -> (a, a)
    minmax [1..9] = (1,9)
    in linear time.
    minmax = minimum &&& maximum
    fails as it's 2x too slow.
  • April 12th, 2016:
    You have (a,b) (c,d)
    You need (a*c, b*d)

    Well, we don't have all day! (Actually, we do) Get to it!
    Pointless; I MEAN POINT-FREE pls
    • lotz@Haskell㌠ @lotz84_ ((uncurry . flip . curry $ id).) . ((uncurry.) . uncurry . (flip.) . flip . flip) ((((flip . (flip.)) $ ((,).) . (*)).) . (*))
    • Olivier Iffrig @oiffrig Point-free but star-full: uncurry (***) . ((*) *** (*))
    • bazzargh @bazzargh curry((uncurry (*)) *** (uncurry (*)))
    • bazzargh @bazzargh knew there had to be a bimap answer, eventually got: curry ((bimap <$> id <*> id) (uncurry (*)))
    • obadz @obadzz join biliftA2 (*)
    • Андреев Кирилл @nonaem00 (((product *** product) . unzip) .) . (flip (:)) . (:[]) ... I clearly need more coffee this morning.
  • April 10th, 2016:

    data BBx = Bx (Int, Int) Pt2D Pt2D

    mkBB :: [a] -> Pt2D -> BBx
    mkBB xs extents = Bx (0, length xs) (0,0) extents
    • Gautier DI FOLCO @gautier_difolco
      -- LANGUAGE TupleSections
      data BBx = Bx (Int, Int) Pt2D Pt2D
      mkBB :: [a] -> Pt2D -> BBx
      mkBB = flip Bx (0,0) . (0, ) . length
    • Thomas D @tthomasdd mkBB = flip Bx (0,0) . (,) 0 . length
  • April 7th, 2016:
    type MList a n = [(a, n)]
    partSz :: Ord n => n -> MList a n -> (MList a n, MList a n)
    partSz µ = partition ((µ >) . snd)
    Define points-free
    • partSz = partition . (. snd) . (>)  -- via @gautier_difolco

Monday, May 2, 2016

April 2016 1HaskellADay Problem and Solutions

April 2016

Thursday, April 7, 2016

March 2016 1HaskellADay 1Liners

  • March 29th, 2016: You have a list, Show a => [a], of known-length n, n > 100 Show the first three and the last three elements of that list
  • March 28th, 2016: You have f :: c -> d and g :: a -> b -> c
    define (<<-) such that f <<- g is f (g a b)
    Does it exist already (in the Prelude, maybe)?
  • March 26th, 2016: insert1 :: Ord k => k -> a -> Map k [a] -> Map k [a] define, points-free, efficiently. (hint: it's not insertWith)
  • March 26th, 2016: sqDist :: Fractional ä => [ä] -> [ä] -> ä sqDist v1 v2 = sum (zipWith (\a b -> (a - b) ^2) v1 v2) Point-free-itize sqDist (and λ)
  • March 17th, 2016: for f :: (a -> b) -> (a, a) -> (b, b) define f
    • obadz @obadzz f = join bimap
  • March 17th, 2016: removeAll :: Eq a => a -> [a] -> [a]; define
    e.g.: removeAll '"' "(\"S312\", \"S204\")" ~> "(S312, S204)"
    • obadz @obadzz removeAll = filter . (/=)
    • Gautier DI FOLCO @gautier_difolco ... same
  • March 17th, 2016:
    f, g :: (String, String) -> String
    let ab = ("a", "b")
    f ab ~> "(\"a\", b)"
    g ab ~> "(a, \"b\")"
    define h that generalizes f and g
    • Gautier DI FOLCO @gautier_difolco
      cp x y (a,b) = concat ["(", x a, ",", y b, ")"]
      f,g :: (String, String) -> String
      g = cp id show
      f = cp show id