We use cookies to ensure you have the best browsing experience on our website. Please read our cookie policy for more information about how we use cookies.
Loading...
  1. Practice
  2. Functional Programming
  3. Introduction
  4. List Replication
  5. Discussions

List Replication

Sort 115 Discussions, By:

votes

  • ASRagab + 5 comments

    Here's a Scala implementation

    arr.flatMap(List.fill(num)(_))
    • christopher_lil1 + 1 comment

      Similar to Haskell: concatMap (\num -> replicate n num) arr

      • MichaelQQ + 1 comment

        also works: concatMap (replicate n) arr

        • eloyekunle + 1 comment

          Also works:

          f n = concatMap (replicate n)
          • idan5x + 0 comments

            Also works:

            f = concatMap . replicate

    • josemanzoli + 1 comment

      I think this way is much more readable, even for people that are used to see functional programming codes!

      arr.flatMap(e => List.fill(num)(e))
      • avvin + 0 comments

        josemanzoli how to excel in scala any help or tips ?

    • byron_lema + 0 comments
      [deleted]
    • baldockja + 1 comment

      Could someone explain why we have to pass the parameters as "(a)(b)" instead of "(a, b)".

      If this is because "List.fill(a)" returns a function which is then passed "b", then why in the documentation is this code fragment refered to as if it is function in and of itself (http://www.scala-lang.org/api/current/scala/collection/generic/SeqFactory.html#fillA(elem:=>A):CC[A])?

      Thanks.

      • mayonesa + 0 comments

        It is currying. fill(a) or fill(a)(b) are both functions. The only difference is that fill(a)(b) returns a List while fill(a) returns a b => List function (e.g., a function that when given b returns a List).

    • sheldo + 1 comment

      could you explain how (_) works? Thanks

      • mayonesa + 0 comments

        It is a placeholder for an anonymous function parameter. It turns

        arr.flatMap(List.fill(num)(_))

        into 

        arr.flatMap { x =>
    List.fill(num)(x)
}

        where x is a value representing ea. element of arr.

  • _s_batra + 2 comments

    Haskell:-

    f n arr = do
    [num | num <- arr , a <- [1..n]]
    • dillonheins + 2 comments
      [deleted]
      • jonathandygert + 1 comment

        When you do list comprehensions in Haskell and draw from multiple lists (by doing x <- list), then the result is a list doing the thing in front for all posible combinations from the lists. Here's an example:

        [(a, b) | a <- [1, 2, 3], b <- [4, 5]]

        gives you

        [(1, 4), (1, 5), (2, 4), (2, 5), (3, 4), (3, 5)]

        In _s_batra's example, the a is kinda unused (which also means that by convention it should be named _), but it simply repeats the num for each element in [1..n] (aka n times).

        • WanpengWang + 0 comments

          Cartesian product

      • eliaszx + 0 comments

        that is also analogous to nested loops in imperative languages(C#, Java) something like:

        foreach(var num in arr) {
   for(var a=1; a <=n; a++) {
       yield return num;
   }
}
    • chesschingis + 0 comments

      Much more beautiful/mathematical!

  • fairjm + 7 comments

    If you use fsharp.Code followed is for input. 

    let s = Console.ReadLine() |> int
let list =
    [
     let mutable key = Console.ReadLine()
     while not (key = null) do
        yield key
        key <- Console.ReadLine()
    ]
    • mwojtkowski + 0 comments

      Thanks !!!

    • stt106 + 0 comments

      Nice!!!

    • edward_trenchar1 + 0 comments

      spot on - thanks!

    • waahhoo + 2 comments

      Here's a more functional way to read the inputs:

      let n = Console.ReadLine() |> int
Seq.initInfinite (fun _ -> Console.ReadLine()) 
|> Seq.takeWhile (String.IsNullOrWhiteSpace >> not)
|> Seq.toList
      • arche3r + 0 comments

        Thanks!

      • vaskarvelas + 0 comments

        Nice!!! :-)

    • lizzael_v_c + 0 comments

      Thanks!

    • borsh + 0 comments

      Thanks a lot!

    • vaskarvelas + 0 comments
      [deleted]

  • adrielradicchi + 2 comments

    Here's Elixir implementation

    defmodule Solution do
    def times(n, element) do
        if (n > 1) do
            IO.puts element
            times(n-1, element)
        else 
            IO.puts element
        end
    end 
    def elements(array) do 
        [_ | rest ] = array  
        Enum.map(rest, fn(x) -> times(List.first(array), x) end)
    end
    def main() do 
        IO.read(:stdio, :all)
            |> String.split
            |> Enum.map(&String.to_integer(&1))
            |> elements
    end
end

Solution.main
    • andrea_ftes + 0 comments
      [deleted]
    • andrea_ftes + 1 comment

      Elixir solution:

      Hi adrielradicchi, this is my solution using your main function

      defmodule Solution do
    def elements([head|tail]) do 
        Enum.each(tail, fn x ->
            Enum.each(1..head, fn _ -> IO.puts(x) end)
        end)
    end
    def main() do 
        IO.read(:stdio, :all)
            |> String.split
            |> Enum.map(&String.to_integer(&1))
            |> elements
    end
end
Solution.main
      • cmush + 0 comments

        Hey @adrielradicchi, @andrea_ftes

        I've tried the solution on my machine and I really don't get how the input stream is halted to indicate the end of the list's input. Yet the code works when I run it on hackerrank. Please explain to me how the Solution.main() method halts further input. Thank you.

  • FlavioFernandes4 + 2 comments

    Another scala impl:

    for{e <- arr; _ <- 1 to num} yield e
    • DearVolt + 1 comment

      I'm just learning Scala and this is beautiful :')

      • prasnicks + 0 comments

        All the best mate :)

    • mayonesa + 0 comments

      which is probably syntactic sugar for arr.flatMap(e => (1 to num).map(_ => e))

  • wamaral + 1 comment

    Haskell is so good for these kind of problems

    f = concatMap . replicate
    • chesschingis + 0 comments

      Ikr!

  • rpatrelle + 0 comments

    My clojure solution: (fn [num lst](flatten(map #(repeat num %) lst)))

  • darren_m_k + 0 comments

    My version in F#:

    (open, readline parts are excluded as they are already shown in other comments)

    List.iter (printfn "%s") (List.collect (fun x -> List.replicate num x) list)

  • c_song + 1 comment

    Struggled a lot for input handling, here is some reference for those having a hard time with erlang.

    input(L) ->
    case io:fread("", "~d") of
      {ok, [N]} ->  input([N|L]);
      _ ->  lists:reverse(L)
    end.

output(L) -> [io:fwrite("~w~n", [H]) || H<-L].

    The actual solution with list comprehension is easy as haskell:

    [N || N <- X , _ <- lists:seq(1,S)]
    • giusepanzuto + 0 comments

      thank you

  • ocramius + 1 comment

    The exercise is wrong/mis-specified.

    Mentions "The relative positions of the values should be the same as the original list provided in the input.", but the test cases seem to expect a sorted list.

    Discovered it by accident by looking at existing solutions after implementing my own (working against all my own test scenarios) :-(

    • reggaeguitar + 0 comments

      This should definitely be specified in the problem description, I'm really glad I read this comment before tearing my hair out.

Load more conversations