There is a wonderful article at the following link explaining what is the Covid virus and its vaccine like, from an IT guy’s perspective.
Reverse Engineering the source code of the BioNTech/Pfizer SARS-CoV-2 Vaccine – Articles (berthub.eu)
From that article, we learn that DNA is like hard disk, RNA is RAM memory and BioNTech/Pfizer vaccine uses RNA segments, a novel approach in vaccine technology.
The aim of the vaccine is to inject some RNA segments of the virus into the body so that body can develop necessary arms against the actual virus.
A segment of the virus RNA is like:
AUG UUU GUU UUU CUU GUU UUA UUG CCA CUA GUC UCU AGU CAG UGU GUU
The DNA and RNA consists of molecules, called nucleotides. They are A, C, G and U. And these nucleotides are grouped into three-nucleotide parts, called codons, like AUG above.
We expect the RNA in the vaccine will be the same but they are not. Vaccine RNA is somewhat different:
AUG UUC GUG UUC CUG GUG CUG CUG CCU CUG GUG UCC AGC CAG UGU GUU
Some nucleotides in the vaccine are replaced by some other ones and this does make any difference because resultant three-nucleotide part are synonyms.
Ok, they are synonyms but why are they replaced at all, just for the sake of being synonyms?
For some reason, this conversion made by replacing the parts in virus with their synonyms makes the vaccine more efficient.
And after this conversion we have this table:

The table shows virus and vaccine RNA and replaced nucleotides are marked by an exclamation mark under them.
When we look at the strings and the resultant table, it seems easy to create the same table using powershell string and array manipulations.
First approach to do that may be using compare-object command two compare arrays and display the differences, after creating arrays of three-nucleotide parts out of the virus and vaccine strings.
The following code can be used for this purpose:
$RNAVirus="AUG UUU GUU UUU CUU GUU UUA UUG CCA CUA GUC UCU AGU CAG UGU GUU" -split " "
$RNAVaccine="AUG UUC GUG UUC CUG GUG CUG CUG CCU CUG GUG UCC AGC CAG UGU GUU" -split " "
Compare-Object -ReferenceObject $RNAVirus -DifferenceObject $RNAVaccine
The above command will create the following output:

We may love the output because it clearly shows what is different in the strings, but other than us nobody will love it, especially the biologists.
So, we must create exactly the output shown in the first figure.
Then, second approach may be using the strings as arrays and comparing the characters one by one and saving the result in a new array, then displaying them successively.
The code for the second approach is:
$RNAVirus="AUG UUU GUU UUU CUU GUU UUA UUG CCA CUA GUC UCU AGU CAG UGU GUU"
$RNAVaccine="AUG UUC GUG UUC CUG GUG CUG CUG CCU CUG GUG UCC AGC CAG UGU GUU"
$length=$RNAVirus.Length
$result=@{}
$resultantstring=""
for ($i=0;$i -lt $length;$i++) {
if ($RNAVirus[$i] -eq $RNAVaccine[$i]) {
$result[$i]=" "
}
else {
$result[$i]="!"
}
}
$RNAVirus
$RNAVaccine
for ($i=0;$i -lt $length;$i++) {
$resultantstring=$resultantstring+$result[$i]
}
$resultantstring
This code produces the exact output we want:

In the article, it is said that exact array of nucleotides is a couple of thousands long. If a biologist asks us to do a similar thing for all those thousands of nucleotides, then we should change our approach once again because it will not be nice to display them in longitudunal lines.
We may change the code a little bit and display the arrays column-wise. The code will be:
$RNAVirus="AUG UUU GUU UUU CUU GUU UUA UUG CCA CUA GUC UCU AGU CAG UGU GUU"
$RNAVaccine="AUG UUC GUG UUC CUG GUG CUG CUG CCU CUG GUG UCC AGC CAG UGU GUU"
$length=$RNAVirus.Length
$result=@{}
for ($i=0;$i -lt $length;$i++) {
if ($RNAVirus[$i] -eq $RNAVaccine[$i]) {
$result[$i]=" "
}
else {
$result[$i]="!"
}
}
for ($i=0;$i -lt $length;$i++) {
#$RNAVirus[$i],$RNAVaccine[$i],$result[$i]
$RNAVirus[$i]+" "+$RNAVaccine[$i]+" "+$result[$i]
}
And the output may make everyone happy, all the time:

Now it is better suited to display thousands of nucleotides.