Reasoning behind shifting over the text whem mismatch occurs in KMP algorithm?

I am not sure that you've got problems with
understanding in only this point, so, if you don't
mind, I'll just describe (with as much explanation
as possible) the whole algorithm. The answer to
your question is probably in the last paragraph,
but you'd better read it all to understand my
terminology better.
During the KMP algorithm, you are, actually,
counting nearly the same values as in the table
(this is usually called prefix function). So when
you get to position i in the text, you need to
count the maximum length of a substring in the
text ending in position i which equals some prefix
of the pattern. It is quite clear that if and only
if the length of this substring is equal to length
of the pattern, you have found the pattern in the
text.
So, how do you count this prefix function value
fast? (I suppose that you count these for the
pattern using some O(n^2) algorithm, which is not
enough fast).
Let's suppose that we've already did everything
for the first i1 symbols of the text
and we are now working with position
i . We will also need the
prefixfunction value for the previous symbol of
the text: p[i1] .
Let's compare text[i] and pattern[p[i1]]
(indexation from 0, if you don't mind). We already
know that pattern[0:p[i1]1] ==
text[i1+p[i1],i1] : that's the definition
of p[i1] . So, if text[i] ==
pattern[p[i1]] , we now know that
pattern[0:p[i1]] == text[i1+p[i1] ,
i]', and that's why p[i] = p[i  1]. But the
interesting part starts when text[i] !=
pattern[p[i1]] .
When these symbols are different, we start
jumping. The reason for that is that we want to
find the next possible prefix as fast as we can.
So, how we do it. Just look at the picture here and follow the explanation
(the yellow parts are substrings found for
text[i1] ). We're trying to find some
string s : s:=s1+text[i] .
Because of the prefixfunction definition,
s1=s2, c=test[i] . But we already know
(from finding the value for
text[i1] ) that two yellow parts in
the picture are the same, so s3
actually equals s1 , and so
s3=s1 . So we can find the length of
s1 : it is table[p[i1]] .
So now if c1=text[i] , we should stop:
we've found p[i] , it is
s1.length + 1 . And if
c1!=text[i] , we can just repeat the
same jumping, looking now at the first
table[table[p[i1]]] symbols of the
pattern, and so we go on until we find the answer,
or we get to the first 0 symbols in this case
p[i]:=0 .

Related to : Reasoning behind shifting over the text whem mismatch occurs in KMP algorithm?

Finding "decent" numbers algorithm reasoning? 
OK, the thinking goes something like this.
Once you've worked out how many 5s and how many 3s you want, you
should frontload the 5s. The ordering makes no odds to whether the
number is decent; but it'll be bigger if the 5s are at the front.
The number of 3s you want should be the smallest number that satisfies
the constraints, because then you'll have more 5s, making for a bigger
number.
The nu

While concatenating two columns an output mismatch occurs 
Concatenating strings, where one of your strings are NULL will always
yield NULL.
For example: SELECT NULL + 'Moo' will result in NULL  always.
ISNULL() accepts 2 arguments and will return the second when the first
resolves to NULL  BOL
Do you mean to do this?
SELECT [Badge Id] = v.PassNo
,VisitorName = VName
,[Name(Department)] = ISNULL(e.eName, '') + ISNULL('

What charactershifting / pseudoencryption algorithm is used here? 
is anybody familiar with this sort of obfuscation scheme in the
Windows world?
Once you understand it correctly, it's just a trivial rotation cipher
like ROT13.
Why would anyone use this?
Well, in general, this is very common. Let's say you have some data
that you need to obfuscate. But the decryption algorithm and key have
to be embedded in software that the viewers have. There's no point

Parallel algorithm that does a small insertion/shifting 
One possible approach.
Due to the ambiguity of your shifting (0, 1, 0, 1, 0, 1, 1, 1 and 0,
1, 0 ,0 all produce the same data offset pattern, for example) it's
not possible to just create a prefix sum of the shift pattern to
produce the relative offset at each position. An observation we can
make, however, is that a valid offset pattern will be created if each
zero in the shift pattern gets repl

KMP algorithm with one mismatch allowed in Java 
public class KMPStringSearch {
/**
* Searches for all occurances of the word in the sentence. Runs
in O(n+k)
* where n is the word length and k is the sentence length.
*
* @param word The word that is being searched
* @param sentence The collections of word over which the search
happens.
* @return The list of starting indices of the matched word in the
sentence.



