In these cases it is best to go step by step to simplify the problem.

The cast can be seen as two separate cases (the two elements of the tuple). The first takes two of the list discarding the second and the second of the tuple is also two but discarding the first.

For the first:

```
reparte1 :: [a] -> [a] -- firma
reparte1 (x:_:xs) = x : reparte1 xs -- tomo el 1ro, descarto el 2do
```

But ...

```
*Main> reparte1 "hola"
"hl*** Exception: Non-exhaustive patterns in function reparte1
```

The obvious is missing, the closing case. Now it would be:

```
reparte1 :: [a] -> [a] -- firma
reparte1 [] = [] -- fin
reparte1 (x:_:xs) = x : reparte1 xs -- tomo el 1ro, descarto el 2do
```

Now it fails on odd:

```
*Main> reparte1 "hola"
"hl"
*Main> reparte1 "holas"
"hl*** Exception: Non-exhaustive patterns in function reparte1
```

Easy to solve. You add this case:

```
reparte1 :: [a] -> [a] -- firma
reparte1 [] = [] -- fin
reparte1 [x] = [x] -- cuando quede uno me lo quedo
reparte1 (x:_:xs) = x : reparte1 xs -- tomo el 1ro, descarto el 2do
*Main> reparte1 "hola"
"hl"
*Main> reparte1 "holas"
"hls"
```

Case 2 is the same but you discard the first element and you keep the second one. You ignore it.

```
reparte2 :: [a] -> [a] -- firma
reparte2 [] = [] -- fin
reparte2 [x] = [] -- cuando quede uno lo ignoro
reparte2 (_:x:xs) = x : reparte2 xs -- descarto el 1ro, tomo el 2do
*Main> reparte2 "holas"
"oa"
```

And finally together the two cases.

```
repartir :: [a] -> ([a],[a])
repartir (x) = (reparte1 x, reparte2 x)
*Main> repartir [1,2,3,4,5]
([1,3,5],[2,4])
*Main> repartir "hola"
("hl","oa")
```

Optimization is left to the student. ;-)