The challenge

Given a string "abc" and assuming that each letter in the string has a value equal to its position in the alphabet, our string will have a value of 1 + 2 + 3 = 6. This means that: a = 1, b = 2, c = 3 ....z = 26.

You will be given a list of strings and your task will be to return the values of the strings as explained above multiplied by the position of that string in the list. For our purpose, position begins with 1.

nameValue ["abc","abc abc"] should return [6,24] because of [ 6 * 1, 12 * 2 ]. Note how spaces are ignored.

"abc" has a value of 6, while "abc abc" has a value of 12. Now, the value at position 1 is multiplied by 1 while the value at position 2 is multiplied by 2.

Input will only contain lowercase characters and spaces.

The solution in Java code

Option 1:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

class Solution{
    public static int [] nameValue(String [] arr){
        String alpha = "abcdefghijklmnopqrstuvwxyz";
        int[] out = new int[arr.length];
      
        for (int i=0; i<arr.length; i++) {
            int count = 0;
            
            for (int j=0; j<arr[i].length(); j++) {
                int val = alpha.indexOf(arr[i].charAt(j));
                if (val>-1) count+=(val+1);
            }
          
            out[i] = count*(i+1);  
        }
        return out;
    }
}

Option 2:

1
2
3
4
5
6
7
8
9

class Solution{
    public static int [] nameValue(String [] arr){
        int[] result = new int[arr.length];
        for (int i = 0; i < arr.length; i++){
            result[i] = arr[i].chars().filter(e -> e != ' ').map(e -> e - 96).sum() * (i+1);
        }
        return result;
    }
}

Option 3:

1
2
3
4
5
6
7
8
9

import static java.util.stream.IntStream.rangeClosed;

interface Solution {
  static int[] nameValue(String[] arr) {
    return rangeClosed(1, arr.length)
                 .map(i -> i * arr[i - 1].chars().reduce(0, (s, c) -> s + Math.max(c - 96, 0)))
                 .toArray();
  }
}

Test cases to validate our solution

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

import org.junit.Test;
import static org.junit.Assert.assertArrayEquals;
import org.junit.runners.JUnit4;
import java.util.*;

public class SolutionTest{
    private static Random random = new Random();    
    
    private static int [] ba56(String [] arr){
        int temp = 0;
        int [] res = new int[arr.length];
        for(int i = 0;i<arr.length;++i){         
            for(char ch : arr[i].toCharArray())
                if(Character. isLowerCase(ch))
                    temp += (int)ch - 96;            
            res[i] = temp*(i+1);
            temp = 0;
        }
        return res;
    }
    
    private static int random(int l, int u){
        return random.nextInt(u-l)+l;
    }
    
    @Test
    public void basicTests(){     
        assertArrayEquals(new int[]{6,24},Solution.nameValue(new String[]{"abc","abc abc"}));
        assertArrayEquals(new int[]{351,282,330},Solution.nameValue(new String[]{"abcdefghijklmnopqrstuvwxyz","stamford bridge","haskellers"}));
    }
    
    @Test
    public void randomTests(){ 
        String abc = " abcdefghijklmnopqrstuvwxyzabc";
        for(int k=0;k<100;k++){
            int arrLen = random(1,10), i = 0; 
            String [] arr = new String[arrLen];
            while (i < arrLen){
               String st = "";
               int len = random(5,15); 
               for (int j = 0; j < len; ++j)
                 st += abc.charAt(random(0,27));
               arr[i] = st; 
               i++;
            }         
            assertArrayEquals(ba56(arr),Solution.nameValue(arr));
        }
    }
}