Is there an approach to finding the ASCII distance between two strings of 5 characters

I am trying to find a way to calculate and print the Ascii distance between a string from user input

 Scanner scan = new Scanner(System.in);
	System.out.print("Please enter a string of 5 uppercase characters:");
	String userString = scan.nextLine();

and a randomly generated string

 int leftLimit = 65; // Upper-case 'A'
    int rightLimit = 90; // Upper-case 'Z'
    int stringLength = 5;
    Random random = new Random();
    String randString = random.ints(leftLimit, rightLimit + 1)
    	.filter(i -> (i <= 57 || i >= 65) && (i <= 90 || i >= 97))
    	.limit(stringLength)
    	.collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append)
    	.toString();

Is there a way to calculate the distance without having to separate each individual character from the two strings, comparing them and adding them back together?

Use Edit distance (Levenshtein distance)

You can

• 1. Implement your own edit distance based on the algorithm on wikipedia,
• 2. you can use an existing source code, for that look at rosetta code.
• 3. use an existing library like apache LevenshteinDistance

you can also check

• Levenshtein Distance on stackoverflow

Create an 2D array fill the array with distances - you can index directly into the 2D array to pull out the distance between the characters.
So one expression that sums up a set of array accesses.

Streams are, well, as the name says, streams. They don't work very well unless you can define an operation strictly on the basis of one input: One element from a stream, without knowing its index or referring to the entire collection.

Here, that is a problem; after all, to operate on, say, the 'H' in your input, you need the matching character from your random code.

I'm not sure why you find 'separate each individual character, compare them, and add them back together' is so distasteful to you. Isn't that a pretty clean mapping from the problem description to instructions for your computer to run?

The alternative is more convoluted: You could attempt to create a mixed object that contains both the letter as well as its index, stream over this, and use the index to look up the character in the second string. Alternatively, you could attempt to create a mix object containing both characters (so, for inputs ABCDE and HELLO, an object containing both A and H), but you'd be writing far more code to get that set up, then the simple, no-streams way.

So, let's start with the simple way:

int difference = 0;
for (int i = 0; i < stringLength; i++) {
    char a = inString.charAt(i);
    char b = randomString.charAt(i);
    difference += difference(a, b);
}

You'd have to write the difference method yourself - but it'd be a very very simple one-liner.

Trying to take two collections of some sort, and from them create a single stream where each element in the stream is matching elements from each collection (so, a stream of ["HA", "EB", "LC", "LD", "OE"]) is generally called 'zipping' (no relation to the popular file compression algorithm and product), and java doesn't really support it (yet?). There are some third party libraries that can do it, but given that the above is so simple I don't think zipping is what you're looking for here.

If you absolutely must, I guess i'd look something like:

// a stream of 0,1,2,3,4
IntStream.range(0, stringLength)
// map 0 to "HA", 1 to "EB", etcetera
.mapToObj(idx -> "" + inString.charAt(idx) + randomString.charAt(idx))
// map "HA" to the difference score
.mapToInt(x -> difference(x))
// and sum it.
.sum();

public int difference(String a) {
   // exercise for the reader
}

Here is my code for this (ASCII distance) in MATLAB

function z = asciidistance(input0)

if nargin ~= 1

    error('please enter a string');

end

size0 = size(input0);

if size0(1) ~= 1

	error ('please enter a string');

end

length0 = size0(2);

rng('shuffle');

a = 32;
b = 127;

string0 = (b-a).*rand(length0,1) + a;

x = char(floor(string0));

z = (input0 - x);

ascii0 = sum(abs(z),'all');
ascii1 = abs(sum(z,'all'));

disp(ascii0);
disp(ascii1);

disp(ascii0/ascii1/length0);

end

This script also differentiates between the absolute ASCII distance on a per-character basis vs that on a per-string basis, thus resulting in two integers returned for the ASCII distance.

I have also included the limit of these two values, the value of which approaches the inverse of the length of strings being compared. This actually approximates the entropy, E, of every random string generation event when run.

After standard error checking, the script first finds the length of the input string. The rnd function seeds the random number generator. the a and b variables define the ASCII table minus non-printable characters, which ends at 126, inclusively. 127 is actually used as an upper bound so that the next line of code can generate a random string of variables of input length. The following line of code turns the string into the alphanumeric characters provided by the ASCII table. The following line of code subtracts the two strings element-wise and stores the result. The next two lines of code sum up the ASCII distances in the two ways mentioned in the first paragraph. Finally, the values are printed out, as well as providing the entropy, E, of the random string generation event.