Nice explaination. I was confused by this notion too.

This practice's test cases do not concern about f(2)=2 f(3)=2 or f(1)=99 f(2)=99 f(3)=99

Thank you, your explanation makes a whole lot more sense than the one which is provided.

Good explanation. Another way to think about it that helps me (though if it doesn't help you, probably best just to forget about it) is to consider the result if I graphed the function. So if the x axis is x, and the y axis is f(x), then for a valid function, there should be no place along the x axis where I could draw a vertical line directly down or up and have that line intersect the function's curve/line in more than one place.

Using the examples given above, if you graphed the valid function outputs, you would see that there is only one output for each x input (i.e. only one spot on the graph for each x), and thus I cannot draw a vertical line intercepting the function in more than one place. That is NOT the case however with the invalid input, as I could draw a line and intercept the function's output for 2 at two places.

I hope this helps to clarify things for someone :)

Thank you! Is there some good Haskell IO Tutorial? I struggle with reading from stdin and writing to stdout and spend much more time than necessary reading stackoverflow and hoogle just to write a million of ugly recursive functions to do it.

Why did you need to convert String to Int? and why did you need to put the numbers in tuples?

Crap, I spent quite some time working out how to get it to output anything..

Thanks for adding the io code, very helpful.

Your answer is hilarious. Nice hack. And you understand it wouldn't work if you get a duplicate relation, right? Like if the test set includes (1,2),(1,2). Your function would print NO, while this describes a valid funcition. But kudos for the insight!

I used the properties of Maps.

object Solution {

    def functionTest() : Unit = {
        val X = scala.io.StdIn.readInt()        
        val data = Iterator.continually(readLine())
        .take(X)
        .collect(_.split(" ") match
        { case Array(s1, s2) => (s1.toDouble, s2.toDouble)})
        .toList

        println(if (data.toMap.size == data.length) 
				"YES" else "NO")
    }

    def main(args: Array[String]) {
        val N = scala.io.StdIn.readInt()
        for (_ <- 1 to N) {
            functionTest
        }
    }
}

Same problem here :c

Same issue here. I finally wrote it using my own conversion functions.

Dude, this is a complete solution. But agreed, the goal of the task should be to design a function that can say if there's a 1-to-1 relation between input and output values, not struggling with I/O. The most challenging part, at least for me, is reading the input and transforming it to something usable and then mapping the results to "YES" or "NO" strings.

I tried to use your parser function and noticed it doesn't take into account the number of test cases (which is why the second int needs to be an option). So I added it and it parses the input as intended and without needing the pesky int option. Here,

let readList n parser =
    Seq.initInfinite (fun _ -> System.Console.ReadLine())
    |> Seq.take n
    |> Seq.map parser
    |> Seq.toList

let parseRelation (s: string) =
    match s.Split(' ') with
    | [|k; v|] -> int k, int v
    | _ -> failwith "OhGodWhy"

let readTestCase () =
    let n = int <| System.Console.ReadLine()

    readList n parseRelation

let readInput () =
    let n = int <| System.Console.ReadLine()
    Seq.initInfinite (fun _ -> readTestCase())
    |> Seq.take n
    |> Seq.toList

[<EntryPoint>]
let main argv =
    printfn "%A" <| readInput()
    System.Console.ReadKey true |> ignore
    0

As it is it'll only print the parsed input and wait before exiting, but it shouldn't be an issue to use it as a template to solve the challenge

There is no "ordered set" given, the statement speaks about "ordered pairs" which refers to the "2-component vectors (x,y)", and means that the order is important in (x,y), i.e., first component and second component have distinct meaning and can't be exchanged; in particular, (x,y) != (y,x) unless x=y.

Omitting type definitions and formalities (which are very important in the real world) I'd start from the building blocks and write an action (not a function) that reads a pair of values from a line and returns a tuple, something like this:

readPair :: IO (Int, Int)
readPair = do
    text <- getLine
    let pairs = (read ((words text)!!0) :: Int, read((words text)!!1) :: Int)
    return pairs

readPair is clunky and can be written much more elegantly but you get the gist

then I'd write an action that reads a test case, which is made by an integer (the number of pairs) and a list of pairs, something like this:

readTestCase :: IO [(Int, Int)]
readTestCase = do
    text <- getLine
    let n = read text :: Int
    replicateM n readPair

Finally I'd write an action that parses the first line (number of testcases) and calls readTestCase appropriately, aggregating all testcases in a list:

readInput :: IO [[(Int, Int)]]
readInput = do
    text <- getLine
    let n = read text :: Int
    let cases = replicateM n readTestCase
    cases

Finally you can use this IO action in your main:

main :: IO ()
main = do
    testCases <- readInput
	-- process your test cases here

Hope you get the idea. This is not the most elegant way and it looks fairly procedural but many IO actions looks procedural by nature.

If this was a real world piece of code, I'd work on defing my own data type (e.g. a Mapping could be an (Int, Int) tupe, a PossibleFunction could be a list of mappings [Mapping], etc.)

As per the given constraints "x and y both are integers" it may not constitue to trig functions

I was confused by this too. Have a go at submitting any old solution, then look at the cases for test 2 where the result should be 'NO' and it should all become clear.

Hi All. After sleeping on it & debugging my I/O code, I prepended each result to a List, but forgot to call .reverse before printing! So my output was in the wrong order. For anyone looking for "what is a valid function", this is a good reference: https://en.wikipedia.org/wiki/Function_(mathematics)

You already said it all: the only constraint to have a function is that the x-values must be distinct for distinct y-values. There is no other restriction. (It happens that here all values are integers, but that's not part of the definition of a function.) But it could a priori happen that a given pair (x,y) is listed twice.