# Positions Average in Java

## The challenge

Suppose you have 4 numbers: `'0', '9', '6', '4'`

and 3 strings composed with them:

```
s1 = "6900690040"
s2 = "4690606946"
s3 = "9990494604"
```

Compare `s1`

and `s2`

to see how many positions they have in common: “ at index 3, `6`

at index 4, `4`

at index 8 ie 3 common positions out of ten.

Compare `s1`

and `s3`

to see how many positions they have in common: `9`

at index 1, “ at index 3, `9`

at index 5 ie 3 common positions out of ten.

Compare `s2`

and `s3`

. We find 2 common positions out of ten.

So for the 3 strings we have 8 common positions out of 30 ie 0.2666… or 26.666…%

Given `n`

substrings (n >= 2) in a string `s`

our function `pos_average`

will calculate the average percentage of positions that are the same between the `(n * (n-1)) / 2`

sets of substrings taken amongst the given `n`

substrings. It can happen that some substrings are duplicate but since their ranks are not the same in `s`

they are considered as different substrings.

The function returns the percentage formatted as a float with 10 decimals but the result is tested at 1e.-9 (see function assertFuzzy in the tests).

### Example:

Given string s = “444996, 699990, 666690, 096904, 600644, 640646, 606469, 409694, 666094, 606490” composing a set of n = 10 substrings (hence 45 combinations), `pos_average`

returns `29.2592592593`

.

In a set the `n`

substrings will have the same length ( > 0 ).

## The solution in Java code

Option 1:

```
public class PositionAverage {
public static double posAverage(String s) {
String[] strings = s.split(",");
int matchs = 0;
double of = 0;
for (int i = 0; i < strings.length; i++)
strings[i] = strings[i].trim();
for (int i = 0; i < strings.length; i++) {
for (int j = i + 1; j < strings.length; j++)
for (int k = 0; k < strings[i].length(); k++) {
matchs += (strings[i].charAt(k) == strings[j].charAt(k)) ? 1 : 0;
of++;
}
}
return matchs * 100 / of;
}
}
```

Option 2:

```
class PositionAverage {
private static double pairPercentage(String s1, String s2) {
int lg = s1.length(); int count = 0;
for (int pos = 0; pos < lg; pos++) {
if (s1.charAt(pos) == s2.charAt(pos))
count += 1;
}
return (double)count / lg;
}
public static double posAverage(String s) {
String[] strings = s.split(", ");
double result = 0.0; int cnt = 0; int lg = strings.length;
for (int k = 0; k < lg; k++) {
for (int i = k + 1; i < lg; i++) {
result += pairPercentage(strings[k], strings[i]);
cnt += 1;
}
}
result = 100.0 * result / cnt;
return Math.floor(result * Math.pow(10.0, 10)) / Math.pow(10.0, 10);
}
}
```

Option 3:

```
public class PositionAverage {
public static double posAverage(String s) {
long posCount = 0;
long matchCount = 0;
String[] parts = s.split(", ");
for(int i=0; i<parts.length-1; i++){
for(int k=i+1; k<parts.length; k++){
for(int z=0; z<parts[k].length(); z++){
posCount++;
if(parts[i].charAt(z)==parts[k].charAt(z)) matchCount++;
}
}
}
return (double)matchCount / (double) posCount * 100.0;
}
}
```

## Test cases to validate our solution

```
import org.junit.Test;
import org.junit.runners.JUnit4;
import static org.junit.Assert.*;
import org.junit.Test;
public class PositionAverageTest {
private static void assertFuzzy(String s, double exp){
System.out.println("Testing " + s);
boolean inrange;
double merr = 1e-9;
double actual = PositionAverage.posAverage(s);
inrange = Math.abs(actual - exp) <= merr;
if (inrange == false) {
System.out.println("Expected mean must be near " + exp +", got " + actual);
}
assertEquals(true, inrange);
}
@Test
public void test() {
assertFuzzy("466960, 069060, 494940, 060069, 060090, 640009, 496464, 606900, 004000, 944096", 26.6666666667);
assertFuzzy("444996, 699990, 666690, 096904, 600644, 640646, 606469, 409694, 666094, 606490", 29.2592592593);
assertFuzzy("4444444, 4444444, 4444444, 4444444, 4444444, 4444444, 4444444, 4444444", 100);
assertFuzzy("0, 0, 0, 0, 0, 0, 0, 0", 100);
}
}
```