Here are some very basic function with self-explanatory name, to be coded in Scala for a super beginner. Some of them are very inefficient, pay attention to use them, they are only for demonstration.
1. Find the last element of a list
def last[T](xs : List[T]) : T = xs match
{
case x :: Nil => x by defition the last element has Nil after
case h::t => last(t)
case _ => throw new NoSuchElementException
}
2. Find the first element of a list
def first[T](xs : List[T]) : T = xs match
{
case head :: tail => head
case _ => throw new NoSuchElementException
}
3. Find the last but one
def lastButOne[T](xs : List[T]) : T = xs match
{
case x :: y :: Nil => x
case h :: t => lastButOne(xs)
case _ => throw new NoSuchElementException
}
4. Find the k-th element of a list
def kthElement[T](xs : List[T], k : Int) : T =
{
def _kth(xs : List[T], acc : Int) : T=
{
if (k==acc) xs.head else _kth(xs.tail, acc + 1)
}
_kth(xs, 0)
}
5. Find the number of elements of a List
def length[T](xs : List[T]) : Int =
{
def acc(xs : List[T], i : Int) : Int = xs match {
case Nil => i
case h::t => acc(xs.tail, i+1)
}
acc(xs, 0)
}
6. Reverse a list
Simple solution:
def reverse[T](xs : List[T]) : List[T] =
{
xs apply xs.length to 1 by -1
}
Procedural solution:
def reverse[T](xs : List[T]) : List[T] =
{
def _reverse[T](res : List[T], rem : List[T] ) : List[T] = rem match {
case Nil => res
case h::t => _reverse(h::res, tail)
case _ => throw new NoSuchElementException
}
_reverse(xs, )
}
def reverse[T](xs : List[T]) : List[T] =
{
xs.foldLeft(){(h,t)=>(t::h)}
}
7. Find out wheter a list is palindrome
def isPalindrome[T](xs : List[T]) : Boolean =
{
xs == reverse(xs)
}
8. Flatten a nested list structure
def flatten(xs: List[_]): List[Any] = xs match
{
case Nil => Nil
case (head: List[_]) :: tail => flatten(head) ::: flatten(tail)
case head :: tail => head :: flatten(tail)
}
9. Eliminate consecutive duplicates of list elements
def filterDuplicates[T](xs : List[T]) : List[T] = xs match
{
case Nil => Nil
case h::List() => List(h)
case head::tail if (head == tail.head) => filterDuplicates(tail)
case h::tail => h::filterDuplicates(tail)
}
10. Pack consecutive duplicates of list elements into sublists
def pack[T](xs : List[T]) : List[T] = xs match {
case Nil => Nil stop condition
case _ => throw new NoSuchElementException
}
Let's talk!
I'm Carlo Nicolini — I am interested on the reliability of AI reasoning systems (interpretability, inference-time methods, probabilistic language programming) and on quantitative portfolio optimization (I am a maintainer of skfolio). If you're working on something in these areas and think we might collaborate, chat, discuss, I'm happy to talk about it!
The best way to reach me is on via DM on LinkedIn.