Introduction to List-based Data Structures with SARL
Note If you don’t know how to solve an problem, or what is the function to be used, you could search on Internet for the answer using the API of the Java programming language. Indeed, since SARL is fully compatible with the Java API, you could use all the types or functions that are defined in this Java API.
1. Exercise 1
- Write a SARL program to sum all the items in a list.
Two answers are possible. Answer #1 is:
## 2. Exercise 2
* Write a SARL program to multiply all the items in a list.
Answer
import java.util.List
class Solution1 {
static def sum(list : List) : Number {
var s = 0.0
for (e : list) {
s += e
}
return s
}
}
import java.util.List
class Solution2 {
static def sum(list : List) : Number {
list.reduce[accumulator, current | accumulator.doubleValue + current.doubleValue]
}
}
Two answers are possible. Answer #1 is:
## 3. Exercise 3
* Write a SARL program to get the largest number from a list.
Answer
import java.util.List
class Solution1 {
static def mul(list : List) : Number {
var s = 0.0
for (e : list) {
s *= e
}
return s
}
}
import java.util.List
class Solution2 {
static def mul(list : List) : Number {
list.reduce[accumulator, current | accumulator.doubleValue * current.doubleValue]
}
}
Two answers are possible. Answer #1 is:
## 4. Exercise 4
* Write a SARL program to count the number of strings from a given list of strings. The string length is 2 or more and the first and last characters are the same.
* Sample List : `['abc', 'xyz', 'aba', '1221']`
* Expected Result : `2`
Answer
import java.util.List
class Solution1 {
static def maxValue(list : List) : Number {
var m : Number = null
for (e : list) {
if (m === null || m < e) {
m = e
}
}
return m
}
}
import java.util.List
class Solution2 {
static def maxValue(list : List) : Number {
list.max[a, b | a <=> b]
}
}
Two answers are possible. Answer #1 is:
## 5. Exercise 5
* Write a SARL program to get a list, sorted in increasing order by the last element in each tuple from a given list of non-empty tuples.
* Sample List : `[(2, 5), (1, 2), (4, 4), (2, 3), (2, 1)]`
* Expected Result : `[(2, 1), (1, 2), (2, 3), (4, 4), (2, 5)]`
Answer
import java.util.List
class Solution1 {
static var original = #['abc', 'xyz', 'aba', '1221']
static def countStrings(list : List) : int {
var n = 0
for (s : list) {
if (s.length >= 2 && s.charAt(0) == s.charAt(s.length - 1)) {
n++
}
}
return n
}
static def main : void {
println(countStrings(original))
}
}
import java.util.List
class Solution2 {
static var original = #['abc', 'xyz', 'aba', '1221']
static def countStrings(list : List) : int {
list.filter[it.length >= 2 && it.charAt(0) == it.charAt(it.length - 1)].size
}
static def main : void {
println(countStrings(original))
}
}
import java.util.List
class Solution {
static var original = #[#[2, 5], #[1, 2], #[4, 4], #[2, 3], #[2, 1]]
static def main : void {
var result = original.sortWith[a, b |
a.get(1) <=> b.get(1)
]
println(result)
}
}
import java.util.List
class Solution {
static def remove_duplicates(list : List) {
var result = newArrayList
for (e : list) {
if (!result.contains(e)) {
result += e
}
}
return result
}
}
7. Exercise 7
- Write a SARL program to check if a list is empty or not.
import java.util.List
class Solution {
static def enquiry(list : List) {
list.size === 0
}
}
import java.util.List
class Solution {
static def copy(list : List) {
var cp = newArrayList
cp.addAll(list)
return cp
}
}
9. Exercise 9
- Write a SARL program to find the list of words that are longer than n from a given list of words.
Two answers are possible. Answer #1 is:
import java.util.List
class Solution1 {
static def words(list : List, n : int) {
var cp = newArrayList
for (e : list) {
if (e.length > n) {
cp += e
}
}
return cp
}
}
</code></pre>
Answer #2 is:
import java.util.List
class Solution2 {
static def words(list : List, n : int) {
list.filter[it.length > n].toList
}
}
</code></pre>
</div>
## 10. Exercise 10
* Write a SARL function that takes two lists and returns `true` if they have at least one common member.
Answer
Two answers are possible. Answer #1 is:
import java.util.List
class Solution1 {
static def common(list1 : List, list2 : List) {
for (e : list1) {
if (list2.contains(e)) {
return true
}
}
return false
}
}
Answer #2 is:
import java.util.List
class Solution2 {
static def words(list1 : List, list2 : List) {
list1.exists[list2.contains(it)]
}
}
## 11. Exercise 11
* Write a SARL program to print a specified list after removing the 0th, 4th and 5th elements.
* Sample List: `['Red', 'Green', 'White', 'Black', 'Pink', 'Yellow']`
* Expected Output : `['Green', 'White', 'Black']`
Answer
class Solution {
static var original = #['Red', 'Green', 'White', 'Black', 'Pink', 'Yellow']
static def main : void {
original.remove(5)
original.remove(4)
original.remove(0)
println(original)
}
}
## 12. Exercise 12
* Write a SARL program to generate a 3*4*6 3D array whose each element is `*`.
Answer
Two answers are possible. Answer #1 is:
class Solution1 {
static def main : void {
var result = newArrayList
for (a : 1..3) {
var dim2 = newArrayList
for (b : 1..4) {
var dim3 = newArrayList
for (c : 1..6) {
dim3 += '*'
}
dim2 += dim3
}
result += dim2
}
println(result)
}
}
Answer #2 is:
import java.util.List
class Solution2 {
static def main : void {
var result = (1..3).map[
(1..4).map[
(1..6).map['*'].toList
].toList
].toList
println(result)
}
}
## 13. Exercise 13
* Write a SARL program to print the numbers of a specified list after removing even numbers from it.
Answer
Two answers are possible. Answer #1 is:
import java.util.List
class Solution1 {
static def remove_even(list : List) : List {
var nlist = newArrayList
for (e : list) {
if ((e % 2) != 0) {
nlist += e
}
}
return nlist
}
}
Answer #2 is:
import java.util.List
class Solution2 {
static def remove_even(list : List) : List {
list.filter[(it % 2) != 0].toList
}
}
## 14. Exercise 14
* Write a SARL program to shuffle and print a specified list.
Answer
import static extension java.util.Collections.shuffle
class Solution {
static var original = #['Red', 'Green', 'White', 'Black', 'Pink', 'Yellow']
static def main : void {
original.shuffle
println(original)
}
}
## 15. Exercise 15
* Write a SARL program to generate all permutations of a list in SARL.
Answer
import java.util.List
class Solution {
static def swap(elements : Object[], index0 : int, index1 : int) : void {
var tmp = elements.get(index0)
elements.set(index0, elements.get(index1))
elements.set(index1, tmp);
}
static def permuts(list : List
## 16. Exercise 16
* Write a SARL program to calculate the difference between the two lists.
Answer
import java.util.List
class Solution {
static def difference(a : List
## 17. Exercise 17
* Write a SARL program to access the index of a list.
* Sample Input: `[5, 15, 35, 8, 98]`
* Sample Output:
```text
0 5
1 15
2 35
3 8
4 98
```
Answer
Three answers are possible. Answer #1 is:
class Solution1 {
static var original = #[5, 15, 35, 8, 98]
static def main : void {
var i = 0
for (element : original) {
println(i + " " + element)
i++
}
}
}
Answer #2 is:
class Solution2 {
static var original = #[5, 15, 35, 8, 98]
static def main : void {
for (var i = 0; i < original.size; i++) {
println(i + " " + original.get(i))
}
}
}
Answer #3 is:
class Solution3 {
static var original = #[5, 15, 35, 8, 98]
static def main : void {
original.forEach [element, index |
println(index + " " + element)
]
}
}
## 18. Exercise 18
* Write a SARL program to convert a list of characters into a string.
Answer
Three answers are possible. Answer #1 is:
import java.util.List
class Solution1 {
static var original : List = #['h', 'e', 'l', 'l', 'o']
static def main : void {
var str = ""
for (c : original) {
str += c
}
println(str)
}
}
Answer #2 is:
import java.util.List
class Solution2 {
static var original : List = #['h', 'e', 'l', 'l', 'o']
static def main : void {
var str_buffer = new StringBuilder
for (c : original) {
str_buffer.append(c)
}
var str = str_buffer.toString
println(str)
}
}
Answer #3 is:
import java.util.List
class Solution3 {
static var original : List = #['h', 'e', 'l', 'l', 'o']
static def main : void {
var str = original.join("")
println(str)
}
}
## 19. Exercise 19
* Write a SARL program to find the index of an item in a specified list.
Answer
Two answers are possible. Answer #1 is:
import java.util.List
class Solution1 {
static var original : List = #['h', 'e', 'l', 'l', 'o']
static def findIndexOf(list : List, element : Object) : int {
var i = 0
for (elt : list) {
if (elt == element) {
return i
}
i++
}
return -1
}
static def main : void {
println(original.findIndexOf('h'))
println(original.findIndexOf('e'))
println(original.findIndexOf('l'))
println(original.findIndexOf('o'))
}
}
</code></pre>
Answer #2 is:
import java.util.List
class Solution2 {
static var original : List = #['h', 'e', 'l', 'l', 'o']
static def main : void {
println(original.indexOf('h'))
println(original.indexOf('e'))
println(original.indexOf('l'))
println(original.indexOf('o'))
}
}
</code></pre>
</div>
## 20. Exercise 20
* Write a SARL program to flatten a shallow list.
* Sample Input: `[[4], [0, 658, 4, 6], [1, 2, 3]]`
* Expected Output: `[4, 0, 658, 4, 6, 1, 2, 3]`
Answer
Three answers are possible. Answer #1 is:
import java.util.List
class Solution1 {
static var original = #[#[4], #[0, 658, 4, 6], #[1, 2, 3]]
static def flattenList(list : List<List>) : List {
var output = newArrayList
for (sublist : list) {
for (element : sublist) {
output += element
}
}
return output
}
static def main : void {
println(original.flattenList)
}
}
</code></pre>
Answer #2 is:
import java.util.List
class Solution2 {
static var original = #[#[4], #[0, 658, 4, 6], #[1, 2, 3]]
static def flattenList(list : List<List>) : List {
var output = newArrayList
for (sublist : list) {
output += sublist
}
return output
}
static def main : void {
println(original.flattenList)
}
}
</code></pre>
Answer #3 is:
import java.util.List
class Solution3 {
static var original = #[#[4], #[0, 658, 4, 6], #[1, 2, 3]]
static def main : void {
println(original.flatten.toList)
}
}
</div>
## 21. Exercise 21
* Write a SARL program to append a list to the second list.
Answer
Two answers are possible. Answer #1 is:
class Solution1 {
static var original1 = #[1, 45, 8, 6, 1]
static var original2 = #[457, -1, 5]
static def main : void {
for (c : original2) {
original1 += c
}
println(original1)
}
}
Answer #2 is:
class Solution2 {
static var original1 = #[1, 45, 8, 6, 1]
static var original2 = #[457, -1, 5]
static def main : void {
original1 += original2
println(original1)
}
}
## 22. Exercise 22
* Write a SARL program to select an item randomly from a list.
Answer
import java.util.Random
class Solution {
static var original = #[1, 45, 8, 6, 1]
static def main : void {
var random = new Random
var element = original.get(random.nextInt(original.size))
println(element)
}
}
## 23. Exercise 23
* Write a SARL program to check whether two lists are circularly identical.
* Input 1:
```text
list1 = [10, 10, 0, 0, 10]
list2 = [10, 10, 10, 0, 0]
```
* Output 1: `true`
* Input 2:
```text
list1 = [10, 10, 0, 10, 0]
list2 = [10, 10, 10, 0, 0]
```
* Output 2: `false`
Answer
import java.util.List
class Solution {
static var list1 = #[10, 10, 0, 0, 10]
static var list2 = #[10, 10, 10, 0, 0]
static def circularly_identical(list1 : List, list2 : List) : boolean {
// doubling list
var list3 = newArrayList(list1)
list3.addAll(list1)
// traversal in twice of list1
for (x : 0..<list1.size) {
var z = 0
// check if list2 == list1 circularly
for (y : x..<(x + list1.size)) {
if (list2.get(z) == list3.get(y)) {
z += 1
} else {
break
}
}
// if all n elements are same circularly
if (z == list1.size) {
return true
}
}
return false
}
static def main : void {
println(circularly_identical(list1, list2))
}
}
</code></pre>
</div>
## 24. Exercise 24
* Write a SARL program to find the second smallest number in a list.
Answer
Two answers are possible. Answer #1 is:
class Solution1 {
static var original = #[1, 45, -45, 2, 987]
static def main : void {
var smaller : Integer = null
for (c : original) {
if (smaller === null || c < smaller) {
smaller = c
}
}
var secondSmaller : Integer = null
for (c : original) {
if (c > smaller && (smaller === null || c < secondSmaller)) {
secondSmaller = c
}
}
println(secondSmaller)
}
}
Answer #2 is:
class Solution2 {
static var original = #[1, 45, -45, 2, 987]
static def main : void {
var smaller = original.min
var secondSmaller = original.filter[it > smaller].min
println(secondSmaller)
}
}
## 25. Exercise 25
* Write a SARL program to get unique values from a list.
Answer
Two answers are possible. Answer #1 is:
import java.util.List
class Solution1 {
static var original = #[1, 45, -45, 1, 2, 987, 45]
static def get_uniq(list : List) : List {
var uniq = newArrayList
for (c : list) {
if (!uniq.contains(c)) {
uniq += c
}
}
return uniq
}
static def main : void {
println(get_uniq(original))
}
}
</code></pre>
Answer #2 is:
import java.util.List
class Solution2 {
static var original = #[1, 45, -45, 1, 2, 987, 45]
static def get_uniq(list : List) : List {
var uniq = newTreeSet(null)
uniq.addAll(list)
return uniq.toList
}
static def main : void {
println(get_uniq(original))
}
}
</code></pre>
</div>
## 26. Exercise 26
* Write a SARL program to get the frequency of elements in a list.
Answer
import java.util.List
import java.util.Map
class Solution {
static var original = #[1, 45, -45, 1, 2, 987, 45]
static def frequency(list : List) : Map<T, Integer> with T {
var map = newHashMap
for (c : list) {
var n = map.getOrDefault(c, 0)
map.put(c, n + 1)
}
return map
}
static def main : void {
println(frequency(original))
}
}
</code></pre>
</div>
## 27. Exercise 27
* Write a SARL program to check whether a list contains a sublist.
Answer
import java.util.List
class Solution {
static var original = #[1, 45, -45, 1, 2, 987, 45]
static def is_sublist(list : List, search_for : List) : boolean {
if (search_for.isEmpty) {
return true
}
if (search_for.size > list.size) {
return false
}
for (i : 0..<list.size) {
if (list.get(i) == search_for.get(0)) {
var n = 1
while ((n < search_for.size) && (list.get(i + n) == search_for.get(n))) {
n++
}
if (n == search_for.size) {
return true
}
}
}
return false
}
static def main : void {
println(is_sublist(original, #[1, 2, 987]))
println(is_sublist(original, #[1, 987, 2]))
}
}
</code></pre>
</div>
## 28. Exercise 28
* Write a SARL program that uses the Sieve of Eratosthenes method to compute prime numbers up to a specified number.
Note In mathematics, the sieve of Eratosthenes, one of a number of prime number sieves, is a simple, ancient algorithm for finding all prime numbers up to any given limit.
Answer
Two answers are possible. Answer #1 is:
import java.util.BitSet
import java.util.List
class Solution1 {
static def sieve_of_eratosthenes(num : int) {
var prime = newArrayList
for (i : 0..num) {
prime += true
}
var p = 2
while (p * p <= num) {
// If prime[p] is not changed, then it is a prime
if (prime.get(p)) {
// Updating all multiples of p
for (var i = p * p; i <= num; i += p) {
prime.set(i, false)
}
}
p += 1
}
// Print all prime numbers
for (p2 : 2..num) {
if (prime.get(p2)) {
println(p2)
}
}
}
static def main : void {
sieve_of_eratosthenes(10)
sieve_of_eratosthenes(20)
}
}
Answer #2 is:
import java.util.BitSet
import java.util.List
class Solution2 {
static def sieve_of_eratosthenes(num : int) {
var prime = new BitSet(num)
var p = 2
while (p * p <= num) {
// If prime[p] is not changed, then it is a prime
if (!prime.get(p)) {
// Updating all multiples of p
for (var i = p * p; i <= num; i += p) {
prime.set(i)
}
}
p += 1
}
// Print all prime numbers
for (i : 2..num) {
if (!prime.get(i)) {
println(i)
}
}
}
static def main : void {
sieve_of_eratosthenes(10)
sieve_of_eratosthenes(20)
}
}
## 29. Exercise 29
* Write a SARL program to create a list by concatenating a given list with a range from 1 to n.
* Sample list: `['p', 'q']`
* n = 5
* Sample Output: `['p1', 'q1', 'p2', 'q2', 'p3', 'q3', 'p4', 'q4', 'p5', 'q5']`
Answer
import java.util.List
class Solution {
static def concat(list : List, num : int) : List {
var new_list = newArrayList
for (element : list) {
for (i : 1..num) {
new_list += element + i
}
}
return new_list
}
static def main : void {
println(concat(#['p', 'q'], 5))
}
}
</code></pre>
</div>
## 30. Exercise 30
* Write a SARL program to find common items in two lists.
Answer
import java.util.List
class Solution {
static def common(list1 : List, list2 : List) : List {
var common_list = newArrayList
for (element : list1) {
if (list2.contains(element)) {
common_list += element
}
}
return common_list
}
static def main : void {
println(common(#[1, 2, 4, 6], #[2, 34, 6, 122]))
}
}
</code></pre>
</div>
## 31. Exercise 31
* Write a SARL program to change the position of every n-th value to the (n+1)th in a list.
* Sample list: `[0,1,2,3,4,5]`
* Expected Output: `[1, 0, 3, 2, 5, 4]`
Answer
import java.util.List
class Solution {
static def change(list : List) : List {
var new_list = newArrayList
for (var i = 0; i < list.size; i += 2) {
var tmp = list.get(i)
list.set(i, list.get(i + 1))
list.set(i + 1, tmp)
}
return new_list
}
static def main : void {
println(change(#[0,1,2,3,4,5]))
}
}
</code></pre>
</div>
## 32. Exercise 32
* Write a SARL program to convert a list of multiple integers into a single integer.
* Sample list: `[11, 33, 50]`
* Expected Output: `113350`
Answer
import java.util.List
class Solution {
static def diz(n : int) : int {
var d = 1
while (n > d) {
d *= 10
}
return d
}
static def merge(list : List) : Integer {
var result = 0
for (element : list) {
result *= diz(element)
result += element
}
return result
}
static def main : void {
println(merge(#[11, 33, 50]))
}
}
</code></pre>
</div>
## 33. Exercise 33
* Write a SARL program to split a list based on the first character of a word.
* Sample Input:
```text
['be', 'have', 'do', 'say', 'get', 'make', 'go', 'know', 'take', 'see', 'come', 'think',
'look', 'want', 'give', 'use', 'find', 'tell', 'ask', 'work', 'seem', 'feel',
'leave', 'call']
```
* Expected Output:
```text
{ 'a': ['ask'],
'b': ['be'],
'c': ['come', 'call'],
'd': ['do'],
'f': ['find', 'feel'],
'g': ['get', 'go', 'give'],
'h': ['have'],
'k': ['know'],
'l': ['look', 'leave'],
'm': ['make'],
's': ['say', 'see', 'seem'],
't': ['take', 'think', 'tell'],
'u': ['use'],
'w': ['want', 'work']
}
```
Answer
Two answers are possible. Answer #1 is:
import java.util.List
import java.util.Map
class Solution1 {
static var original = #[
'be', 'have', 'do', 'say', 'get', 'make',
'go', 'know', 'take', 'see', 'come', 'think',
'look', 'want', 'give', 'use', 'find',
'tell', 'ask', 'work', 'seem', 'feel',
'leave', 'call']
static def split_by_letter(words : List) : Map<Character, List> {
var map : Map<Character, List> = newHashMap
for (word : words) {
var letter = word.charAt(0)
var list = map.computeIfAbsent(letter, [newArrayList])
list += word
}
return map
}
static def main : void {
println(split_by_letter(original))
}
}
</code></pre>
Answer #2 is:
import java.util.List
import java.util.Map
class Solution2 {
static var original = #[
'be', 'have', 'do', 'say', 'get', 'make',
'go', 'know', 'take', 'see', 'come', 'think',
'look', 'want', 'give', 'use', 'find',
'tell', 'ask', 'work', 'seem', 'feel',
'leave', 'call']
static def split_by_letter(words : List) : Map<Character, List> {
return words.groupBy[it.charAt(0)]
}
static def main : void {
println(split_by_letter(original))
}
}
</code></pre>
</div>
## 34. Exercise 34
* Write a SARL program to create multiple lists.
* Sample Input: `1..10`
* Expected Output: `{'1': [], '8': [], '14': [], '5': [], '17': [], '9': [], '2': [], '7': [], '16': [], '19': [], '4': [], '18':
[], '13': [], '3': [], '15': [], '11': [], '20': [], '6': [], '12': [], '10': []}`
Answer
Two answers are possible. Answer #1 is:
class Solution1 {
static def main : void {
var result = newHashMap
for (i : 1..10) {
result.computeIfAbsent(i) [newArrayList]
}
println(result)
}
}
Answer #2 is:
class Solution2 {
static def main : void {
var result = (1..10).toInvertedMap[newArrayList]
println(result)
}
}
## 35. Exercise 35
* Write a SARL program to convert a pair of values into a sorted unique array.
* Original List: `[(1, 2), (3, 4), (1, 2), (5, 6), (7, 8), (1, 2), (3, 4), (3, 4), (7, 8), (9, 10)]`
* Sorted Unique Data: `[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]`
Answer
Three answers are possible. Answer #1 is:
class Solution1 {
static var original = #[
#[1, 2], #[3, 4], #[1, 2], #[5, 6], #[7, 8],
#[1, 2], #[3, 4], #[3, 4], #[7, 8], #[9, 10]
]
static def main : void {
var result = newArrayList
for (tuple : original) {
for (element : tuple) {
if (!result.contains(element)) {
result += element
}
}
}
println(result)
}
}
Answer #2 is:
class Solution2 {
static var original = #[
#[1, 2], #[3, 4], #[1, 2], #[5, 6], #[7, 8],
#[1, 2], #[3, 4], #[3, 4], #[7, 8], #[9, 10]
]
static def main : void {
var result = newTreeSet(null)
for (tuple : original) {
for (element : tuple) {
result += element
}
}
println(result)
}
}
Answer #3 is:
class Solution3 {
static var original = #[
#[1, 2], #[3, 4], #[1, 2], #[5, 6], #[7, 8],
#[1, 2], #[3, 4], #[3, 4], #[7, 8], #[9, 10]
]
static def main : void {
var result = newTreeSet(null)
for (tuple : original) {
result += tuple
}
println(result)
}
}
## 36. Exercise 36
* Write a SARL program to select the odd items from a list.
Answer
Two answers are possible. Answer #1 is:
class Solution1 {
static var original = #[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
static def main : void {
var result = newArrayList
for (value : original) {
if ((value % 2) != 0) {
result += value
}
}
println(result)
}
}
Answer #2 is:
class Solution2 {
static var original = #[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
static def main : void {
var result = original.filter[(it % 2) != 0].toList
println(result)
}
}
## 37. Exercise 37
* Write a SARL program to insert an element before each element of a list.
Answer
import java.util.List
class Solution {
static var original = #[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
static def appendBefore(list : List, prefix : Integer) : List {
var result = newArrayList
for (element : list) {
result += prefix
result += element
}
return result
}
static def main : void {
println(appendBefore(original, 34))
}
}
</code></pre>
</div>
## 38. Exercise 38
* Write a SARL program to print nested lists (each list on a new line) using the `println()` function.
* Sample Input: `[['assign1', 'assign2'], ['final', 'assign4'], ['exam', 'study']]`
* Expected Output:
```text
assign1 assign2
final assign4
exam study
```
Answer
import java.util.List
class Solution {
static var original = #[#['assign1', 'assign2'], #['final','assign4'], #['exam','study']]
static def main : void {
for (list : original) {
if (!list.isEmpty) {
var iter = list.iterator
print(iter.next)
while (iter.hasNext) {
print(" " + iter.next)
}
}
println
}
}
}
## 39. Exercise 39
* Write a SARL program to convert a list to a list of maps.
* Sample lists: `["Black", "Red", "Maroon", "Yellow"], ["#000000", "#FF0000", "#800000", "#FFFF00"]`
* Expected Output: `[{'color_name': 'Black', 'color_code': '#000000'}, {'color_name': 'Red', 'color_code': '#FF0000'}, {'color_name': 'Maroon', 'color_code': '#800000'}, {'color_name': 'Yellow', 'color_code': '#FFFF00'}]`
Answer
class Solution {
static var originalNames = #["Black", "Red", "Maroon", "Yellow"]
static var originalColors = #["#000000", "#FF0000", "#800000", "#FFFF00"]
static def main : void {
var result = newArrayList
var iter1 = originalNames.iterator
var iter2 = originalColors.iterator
while (iter1.hasNext && iter2.hasNext) {
var map = newHashMap
map.put('color_name', iter1.next)
map.put('color_code', iter2.next)
result += map
}
println(result)
}
}
## 40. Exercise 40
* Write a SARL program to split a list every Nth element.
* Sample list: `['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n']`
* n = 5
* Expected Output: `[['a', 'd', 'g', 'j', 'm'], ['b', 'e', 'h', 'k', 'n'], ['c', 'f', 'i', 'l']]`
Answer
import java.util.List
class Solution {
static var original = #['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n']
static def split_at_n(list : List, n : int) : List<List> {
var result = newArrayList
var clist = newArrayList
for (element : list) {
if (clist.size == n) {
result.add(clist)
clist = newArrayList
}
clist += element
}
if (!clist.isEmpty) {
result.add(clist)
}
return result
}
static def main : void {
println(split_at_n(original, 5))
}
}
</code></pre>
</div>
## 41. Exercise 41
* Write a SARL program to compute the difference between two lists.
* Sample data: `a = ["red", "orange", "green", "blue", "white"]`, `b = ["black", "yellow", "green", "blue"]`
* Expected Output when `a` is passed before `b`: `['white', 'orange', 'red']`
* Expected Output when `b` is passed before `a`: `['black', 'yellow']`
Answer
import java.util.List
class Solution {
static var a = #["red", "orange", "green", "blue", "white"]
static var b = #["black", "yellow", "green", "blue"]
static def difference(list1 : List, list2 : List) : List {
var result = newArrayList
for (element : list1) {
if (!list2.contains(element)) {
result += element
}
}
return result
}
static def main : void {
println(difference(a, b))
println(difference(b, a))
}
}
</code></pre>
</div>
## 42. Exercise 42
* Write a SARL program to replace the last element in a list with another list.
* Sample data: `[1, 3, 5, 7, 9, 10]` and `[2, 4, 6, 8]`
* Expected Output: `[1, 3, 5, 7, 9, 2, 4, 6, 8]`
Answer
import java.util.List
class Solution {
static def replace_last(list1 : List, list2 : List) : List {
var result = newArrayList
result += list1.subList(0, list1.size - 1)
result += list2
return result
}
static def main : void {
println(replace_last(#[1, 3, 5, 7, 9, 10], #[2, 4, 6, 8]))
}
}
</code></pre>
</div>
## 43. Exercise 43
* Write a SARL program to check whether the n-th element exists in a given list.
Answer
import java.util.List
class Solution {
static def exist_in(list : List, position : int) : boolean {
0 <= position && position < list.size
}
static def main : void {
println(exist_in(#[1, 3, 5, 7, 9, 10], 3))
println(exist_in(#[1, 3, 5, 7, 9, 10], 8))
}
}
</code></pre>
</div>
## 44. Exercise 44
* Write a SARL program to insert a given string at the beginning of all items in a list.
* Sample list: `[1,2,3,4]`
* Input string: `emp`
* Expected output: `['emp1', 'emp2', 'emp3', 'emp4']`
Answer
Two answers are possible. Answer #1 is:
import java.util.List
class Solution1 {
static var original = #[1, 2, 3, 4]
static def append_prefix(list : List, prefix : String) : List {
var result = newArrayList
for (element : list) {
result += prefix + element
}
return result
}
static def main : void {
println(append_prefix(original, "emp"))
}
}
</code></pre>
Answer #2 is:
import java.util.List
class Solution2 {
static var original = #[1, 2, 3, 4]
static def append_prefix(list : List, prefix : String) : List {
list.map[prefix + it].toList
}
static def main : void {
println(append_prefix(original, "emp"))
}
}
</code></pre>
</div>
## 45. Exercise 45
* Write a SARL program to iterate over two lists simultaneously.
Answer
Two answers are possible. Answer #1 is:
import java.util.List
import java.util.Iterator
class Solution1 {
static var original1 = #[1, 2, 3]
static var original2 = #['red', 'white', 'black']
static def zip(list1 : List, list2 : List) : List<Object[]> {
var result : List<Object[]> = newArrayList
val iter1 = list1.iterator
val iter2 = list2.iterator
while (iter1.hasNext && iter2.hasNext) {
result.add(#[iter1.next, iter2.next])
}
return result
}
static def main : void {
for (tuple : zip(original1, original2)) {
println(tuple)
}
}
}
Answer #2 is:
import java.util.List
import java.util.Iterator
class Solution2 {
static var original1 = #[1, 2, 3]
static var original2 = #['red', 'white', 'black']
static def zip(list1 : List, list2 : List) : Iterable<Object[]> {
[
val iter1 = list1.iterator
val iter2 = list2.iterator
new Iterator<Object[]> {
def hasNext : boolean {
iter1.hasNext && iter2.hasNext
}
def next : Object[] {
var v1 = iter1.next
var v2 = iter2.next
return #[v1, v2]
}
}
]
}
static def main : void {
for (tuple : zip(original1, original2)) {
println(tuple)
}
}
}
## 46. Exercise 46
* Write a SARL program to flatten a given nested list structure.
* Original list: `[0, 10, [20, 30], 40, 50, [60, 70, 80], [90, 100, 110, 120]]`
* Flatten list: `[0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120]`
Answer
import java.util.List
class Solution {
static var original = #[0, 10, #[20, 30], 40, 50, #[60, 70, 80], #[90, 100, 110, 120]]
static def flatten_list(list : List) : List {
var result = newArrayList
for (element : list) {
if (element instanceof Iterable) {
result.addAll(element)
} else {
result += element
}
}
return result
}
static def main : void {
println(flatten_list(original))
}
}
## 47. Exercise 47
* Write a SARL program to remove consecutive (following each other continuously) duplicates (elements) from a given list.
* Original list: `[0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4]`
* After removing consecutive duplicates: `[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 4]`
Answer
class Solution {
static var original = #[0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4]
static def main : void {
var result = newArrayList
for (element : original) {
if (result.isEmpty || element != result.get(result.size - 1)) {
result += element
}
}
println(result)
}
}
## 48. Exercise 48
* Write a SARL program to pack consecutive duplicates of a given list of elements into sublists.
* Original list: `[0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4]`
* After packing consecutive duplicates of the said list elements into sublists: `[[0, 0], [1], [2], [3], [4, 4], [5], [6, 6, 6], [7], [8], [9], [4, 4]]`
Answer
import java.util.List
class Solution {
static var original = #[0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4]
static def main : void {
var result = newArrayList
var pack : List = null
var prev : Integer = null
for (element : original) {
if (element != prev) {
if (!pack.isNullOrEmpty) {
result.add(pack)
}
pack = newArrayList
}
pack += element
prev = element
}
if (!pack.isNullOrEmpty) {
result.add(pack)
}
println(result)
}
}
</code></pre>
</div>
## 49. Exercise 49
* Write a SARL program to insert an element at a specified position into a given list.
* Original list: `[1, 1, 2, 3, 4, 4, 5, 1]`
* After inserting an element at kth position in the said list: `[1, 1, 12, 2, 3, 4, 4, 5, 1]`
Answer
import java.util.List
class Solution {
static var original = #[1, 1, 2, 3, 4, 4, 5, 1]
static def insert_at(list : List, position : int, element : Integer) : List {
var new_list = newArrayList
new_list.addAll(list)
if (position >= new_list.size) {
new_list += element
} else {
new_list.add(position, element)
}
return new_list
}
static def main : void {
println(insert_at(original, 3, 12))
}
}
</code></pre>
</div>
## 50. Exercise 50
* Write a SARL program to extract a given number of randomly selected elements from a given list.
* Original list: `[1, 1, 2, 3, 4, 4, 5, 1]`
* Selected 3 random numbers of the above list: `[4, 4, 1]`
Answer
import java.util.List
import java.util.Random
class Solution {
static var original = #[1, 1, 2, 3, 4, 4, 5, 1]
static def extract_random(list : List, n : int) : List {
var new_list = newArrayList
if (n <= list.size) {
new_list.addAll(list)
} else {
var random = new Random
var selected = newHashSet
for (i : 1..n) {
var rnd = random.nextInt(list.size)
while (!selected.add(rnd)) {
rnd = random.nextInt(list.size)
}
new_list.add(list.get(rnd))
}
}
return new_list
}
static def main : void {
println(extract_random(original, 3))
}
}
</code></pre>
</div>
## 51. Exercise 51
* Write a SARL program to generate combinations of n distinct objects taken from the elements of a given list.
* Original list: `[1, 2, 3, 4, 5, 6, 7, 8, 9]`
* Combinations of 2 distinct objects: `[1, 2] [1, 3] [1, 4] [1, 5] .... [7, 8] [7, 9] [8, 9]`
Answer
class Solution {
static var original = #[1, 2, 3, 4, 5, 6, 7, 8, 9]
static def main : void {
var result = newArrayList
for (var i = 0; i < original.size - 1; i++) {
var elt0 = original.get(i)
for (var j = i + 1; j < original.size; j++) {
var elt1 = original.get(j)
result.add(#[elt0, elt1])
}
}
println(result)
}
}
## 52. Exercise 52
* Write a SARL program to round every number in a given list of numbers and print the total sum multiplied by the length of the list.
* Original list: `[22.4, 4.0, -16.22, -9.1, 11.0, -12.22, 14.2, -5.2, 17.5]`
* Result: `243`
Answer
Two answers are posible. Answer #1 is:
class Solution1 {
static var original = #[22.4, 4.0, -16.22, -9.1, 11.0, -12.22, 14.2, -5.2, 17.5]
static def main : void {
var sum = 0l
for (element : original) {
sum += Math::round(element)
}
println(sum * original.size)
}
}
Answer #2 is:
class Solution2 {
static var original = #[22.4, 4.0, -16.22, -9.1, 11.0, -12.22, 14.2, -5.2, 17.5]
static def main : void {
var result = original.size * original.map[Math::floor(it)].reduce[accumulator, current| accumulator + current]
println(result)
}
}
## 53. Exercise 53
* Write a SARL program to create a multidimensional list (lists of lists) with zeros. Multidimensional list: `[[0, 0], [0, 0], [0, 0]]`.
Answer
import java.util.List
class Solution {
static def create_multidimensional_list(a : int, b : int) : List<List> {
var list = newArrayList
for (i : 1..a) {
var sublist = newArrayList
for (j : 1..b) {
sublist += 0
}
list.add(sublist)
}
return list
}
static def main : void {
println(create_multidimensional_list(3, 2))
}
}
</code></pre>
</div>
## 54. Exercise 54
* Write a SARL program to read a square matrix from the command line and print the sum of the matrix's primary diagonal. Accept the size of the square matrix and elements for each column separated with a space (for every row) as input from the user.
* Input the size of the matrix: 3
```text
2 3 4
4 5 6
3 4 7
```
* Sum of matrix primary diagonal: `14`
Answer
import java.util.List
class Solution {
static def input_matrix(args : String[]) : List<List> {
var n = args.get(0) as int
var m = newArrayList
var k = 1
for (i : 1..n) {
var row = newArrayList
for (j : 1..n) {
row.add(args.get(k) as int)
k++
}
m.add(row)
}
return m
}
static def sum_diag(matrix : List<List>) : int {
var sum = 0
for (i : 0..<matrix.size) {
sum += matrix.get(i).get(i)
}
return sum
}
static def main(args : String*) : void {
var matrix = input_matrix(args)
var result = sum_diag(matrix)
println(result)
}
}
</code></pre>
</div>
## 55. Exercise 55
* Write a SARL program to Zip two given lists of lists.
* Original lists:
```text
[[1, 3], [5, 7], [9, 11]]
[[2, 4], [6, 8], [10, 12, 14]]
```
* Zipped list: `[[1, 3, 2, 4], [5, 7, 6, 8], [9, 11, 10, 12, 14]]`
Answer
import java.util.List
import java.util.Iterator
class Solution {
static var original1 = #[#[1, 3], #[5, 7], #[9, 11]]
static var original2 = #[#[2, 4], #[6, 8], #[10, 12, 14]]
static def zip(list1 : List<List>, list2 : List<List>) : List<List> {
var iter1 = list1.iterator
var iter2 = list2.iterator
var result = newArrayList
while (iter1.hasNext && iter2.hasNext) {
var sublist = newArrayList
sublist.addAll(iter1.next)
sublist.addAll(iter2.next)
result.add(sublist)
}
if (iter1.hasNext) {
do {
result.add(iter1.next)
} while (iter1.hasNext)
} else if (iter2.hasNext) {
do {
result.add(iter2.next)
} while (iter2.hasNext)
}
return result
}
static def main : void {
var result = zip(original1, original2)
println(result)
}
}
</code></pre>
</div>
## 56. Exercise 56
* Write a SARL program to extract specified number of elements from a given list, which follows each other continuously.
* Original list: `[1, 1, 3, 4, 4, 5, 6, 7]`
* Extract 2 number of elements from the said list which follows each other continuously: `[1, 4]`
* Original list: `[0, 1, 2, 3, 4, 4, 4, 4, 5, 7]`
* Extract 4 number of elements from the said list which follows each other continuously: `[4]`
Answer
import java.util.List
class Solution {
static var original = #[1, 1, 3, 4, 4, 5, 6, 7]
static def isseq(list : List, i : int, n : int) : boolean {
var elt = list.get(i)
for (var j = i + 1; j < n; j++) {
if (list.get(j) != elt) {
return false
}
}
return true
}
static def extract(list : List, n : int) : List {
var result = newArrayList
for (var i = 0; i <= list.size - n; i++) {
if (isseq(list, i, n)) {
result += list.get(i)
}
}
return result
}
static def main : void {
var result = extract(original, 2)
println(result)
}
}
</code></pre>
</div>
## 57. Exercise 57
* Write a SARL program to compute average of two given lists.
* Original list:
```text
[1, 1, 3, 4, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 4, 5, 7, 8]
```
* Average of two lists: `3.823529411764706`
Answer
import java.util.List
class Solution {
static var original1 = #[1, 1, 3, 4, 4, 5, 6, 7]
static var original2 = #[0, 1, 2, 3, 4, 4, 5, 7, 8]
static def average(lists : List*) : double {
var sum = 0.0
var count = 0
for (list : lists) {
count += list.size
for (elt : list) {
sum += elt
}
}
return sum / count
}
static def main : void {
var result = average(original1, original2)
println(result)
}
}
</code></pre>
</div>
## 58. Exercise 58
* Write a SARL program to count integers in a given mixed list.
* Original list: `[1, 'abcd', 3, 1.2, 4, 'xyz', 5, 'pqr', 7, -5, -12.22]`
* Number of integers in the said mixed list: 6
Answer
Two answers are possible. Answer #1 is:
import java.util.List
import java.math.BigInteger
class Solution1 {
static var original = #[1, 'abcd', 3, 1.2, 4, 'xyz', 5, 'pqr', 7, -5, -12.22]
static def isInteger(value : Object) : boolean {
value instanceof Integer || value instanceof Long || value instanceof BigInteger
}
static def count_integers(list : List) : int {
var count = 0
for (element : list) {
if (element.isInteger) {
count++
}
}
return count
}
static def main : void {
println(count_integers(original))
}
}
Answer #1 is:
import java.util.List
import java.math.BigInteger
class Solution2 {
static var original = #[1, 'abcd', 3, 1.2, 4, 'xyz', 5, 'pqr', 7, -5, -12.22]
static def count_integers(list : List) : int {
list.filter[it instanceof Integer || it instanceof Long || it instanceof BigInteger].size
}
static def main : void {
println(count_integers(original))
}
}
## 59. Exercise 59
* Write a SARL program to remove a specified column from a given nested list.
* Original Nested list: `[[1, 2, 3], [2, 4, 5], [1, 1, 1]]`
* After removing 1st column: `[[2, 3], [4, 5], [1, 1]]`
* Original Nested list: `[[1, 2, 3], [-2, 4, -5], [1, -1, 1]]`
* After removing 3rd column: `[[1, 2], [-2, 4], [1, -1]]`
Answer
import java.util.List
class Solution {
static var original = #[#[1, 2, 3], #[2, 4, 5], #[1, 1, 1]]
static def remove_column(list : List<List>, col : int) : List<List> {
var rows = newArrayList
for (row : list) {
var ncols = newArrayList
ncols.addAll(row)
ncols.remove(col)
rows.add(ncols)
}
return rows
}
static def main : void {
println(remove_column(original, 1))
}
}
</code></pre>
</div>
## 60. Exercise 60
* Write a SARL program to extract a specified column from a given nested list.
* Original Nested list: `[[1, 2, 3], [2, 4, 5], [1, 1, 1]]`
* Extract 1st column: `[1, 2, 1]`
* Original Nested list: `[[1, 2, 3], [-2, 4, -5], [1, -1, 1]]`
* Extract 3rd column: `[3, -5, 1]`
Answer
import java.util.List
class Solution {
static var original = #[#[1, 2, 3], #[2, 4, 5], #[1, 1, 1]]
static def get_column(list : List<List>, col : int) : List {
var column = newArrayList
for (row : list) {
column += row.get(col)
}
return column
}
static def main : void {
println(get_column(original, 1))
}
}
</code></pre>
</div>
## 61. Version Specification
* Specification: SARL General-purpose Agent-Oriented Programming Language ("Specification")
* Version: 0.15
* Status: Stable Release
* Release: 2025-09-11
## 62. Legal Notice
> Copyright © 2014-2025 [SARL.io, the Original Authors and Main Authors](http://www.sarl.io/about/index.html).
>
> Documentation text and medias are licensed under the Creative Common CC-BY-SA-4.0;
> you may not use this file except in compliance with CC-BY-SA-4.0.
> You may obtain a copy of [CC-BY-4.0](https://creativecommons.org/licenses/by-sa/4.0/deed.en).
>
> Examples of SARL code are licensed under the Apache License, Version 2.0;
> you may not use this file except in compliance with the Apache License.
> You may obtain a copy of the [Apache License](http://www.apache.org/licenses/LICENSE-2.0).
>
> You are free to reproduce the content of this page on copyleft websites such as Wikipedia.
Generated with the translator docs.generator 0.15.1.