List-manipulation exercises in Scala
General Comment

This looks like exercises from Functional Programming in Scala.  It's some time since I read that, but I'm pretty sure you are expected each time to use the functions you have already written, better to learn their use, rather than reach for Scala's core library functions or build-in control structures like for loops.

List Concatenation

Are you using your own implementation or the library version?  Either way, it looks as if you are doing this inefficiently because the first parameter in the library function passed to foldLeft is the accumulator, the second the list element.  As I recall, the book version does the same.

When concatenating immutable lists, the list on the left is entirely recreated, while the list on the right is shared and not copied at all.  foldLeft is the worst solution here because you start with the leftmost list and repeatedly add a new list on the right.  So with the first two lists, you copy the one on the left.  Then, when you add the third on the right, you completely copy your first two lists.  And so on, until you reach the final list.  This means that with n lists, the first list is copied n-1 times, the second n-2 times and so on.  Very wasteful.

With a foldRight solution, where you start by appending the seed (empty list) on the right of the rightmost list and then in each subsequent operation append the accumulated value on the right and not the left, each list is only copied once.

By the time you reached this challenge, you should have written a stack-safe version of foldRight.

You could, alternatively, reverse the outer list and then foldLeft.  Either way, remember that you want the accumulator to be on the right hand side of ++

add1

By using a for loop you have learned nothing about how to use the functions you have already written to build other functions.

You should, at this point, have written two stack-safe functions which make it possible to traverse a list: foldLeft and foldRight.  Either can be used but remember that you need to preserve the original order.

map

Again, using a for loop you have learned nothing about how to use the functions you have already written.  In fact, since Scala will actually rewrite the for loop using the core library map function, you've implemented map using map.
 Which works buy isn't in the spirit of the challenge. 

map is just the general case of add1, so the same answer applies as in that challenge.

Summary

Your first solution didn't meet the requirements at all, since it scales exponentially and not linearly.  The other two work functionally but don't meet the explicitly given (and often repeated) requirement to reuse functions you've written.

Forgive me for not providing you with any code examples but I don't want to rob you of the challenge to learn (which is the whole point of the book).