'Find missing letter in list of alphabets

I am trying to solve the following issue:

Find the missing letter in the passed letter range and return it. If all letters are present in the range, return undefined.

the inputs that I will get as strings are:

abce (Which should return d)
bcd (which should return undefined)
abcdefghjklmno (which should return i)
yz (which should return undefined)

my code currently looks like this:

  function fearNotLetter(str) {
  //create alphabet string
  //find starting letter in alphabet str, using str
  //compare letters sequentially
  //if the sequence doesn't match at one point then return letter
  //if all letters in str appear then return undefined

  var alphabet = ("abcdefgheijklmnopqrstuvwxyz");
  var i = 0;
  var j = 0;
  while (i<alphabet.length && j<str.length) {
    i++;
    if (alphabet.charCodeAt(i) === str.charCodeAt(j)) {
      i++;
      j++;      
    }
    else if (alphabet.charCodeAt(i) !== str.charCodeAt(j)) {
      i++;
      j++;
      if (alphabet.charCodeAt(i) === str.charCodeAt(j-1)) {
        return alphabet.charCodeAt(i-1);  
      }
    }
  }
}

fearNotLetter('abce');

Thanks for your help as always!

javascript

Solution 1:^[1]

I would do it like this:

function fearNotLetter(str) {
    var i, j = 0, m = 122;
    if (str) {
        i = str.charCodeAt(0);
        while (i <= m && j < str.length) {
            if (String.fromCharCode(i) !== str.charAt(j)) {
                return String.fromCharCode(i);
            }
            i++; j++;
        }
    }
    return undefined;
}

console.log(fearNotLetter('abce'));        // "d"
console.log(fearNotLetter('bcd'));         // undefined
console.log(fearNotLetter('bcdefh'));      // "g"
console.log(fearNotLetter(''));            // undefined
console.log(fearNotLetter('abcde'));       // undefined
console.log(fearNotLetter('abcdefghjkl')); // "i"

i can go from 97 to 122, this interval corresponds to the ASCII codes of the lower case alphabet.

If you want it not to be case sensitive, just do str = str.toLowerCase() at the beginning of the function.

Solution 2:^[2]

I think this is the simplest code to do this:

function skippedLetter(str) {
    for (var i = 0; i < str.length - 1; i++) {
        if (str.charCodeAt(i + 1) - str.charCodeAt(i) != 1) {
            return String.fromCharCode(str.charCodeAt(i) + 1);
        }
    }
}

alert(skippedLetter('abce'));

This version will reject illegal input, accept both upper and lower case, check that there is only 1 hole in the range, and that there is exactly 1 character missing.

function skippedLetter(str) {
    if (!str.match(/^[a-zA-Z]+$/)) return;
    var letter = "", offset = str.charCodeAt(0);
    for (var i = 1; i < str.length; i++) {
        var diff = str.charCodeAt(i) - i - offset;
        if (diff == 1) letter += String.fromCharCode(i + offset++)
        else if (diff) return;
    }
    if (letter.length == 1) return letter;
}

alert(skippedLetter('123567'));		// illegal characters
alert(skippedLetter(''));		// empty string
alert(skippedLetter('a'));		// too short
alert(skippedLetter('bc'));		// nothing missing
alert(skippedLetter('df'));		// skipped letter = e
alert(skippedLetter('GHIKLM'));		// skipped letter = J
alert(skippedLetter('nOpRsT'));		// cases mixed
alert(skippedLetter('nopxyz'));		// too many characters missing
alert(skippedLetter('abcefgijk'));	// character missing more than once
alert(skippedLetter('abcefgfe'));	// out of order

Solution 3:^[3]

Note that you have a typo in alphabet: There are two "e"s.

You could split the string into an array, then use the some method to short-circuit the loop when you don't find a match:

function fearNotLetter(str) {
  var alphabet = 'abcdefghijklmnopqrstuvwxyz',
      missing,
      i= 0;
  
  str.split('').some(function(l1) {
    var l2= alphabet.substr(i++, 1);
    if(l1 !== l2) {
      if(i===1) missing= undefined;
      else      missing= l2;
      return true;
    }
  });
  
  return missing;
}

console.log(fearNotLetter('abce'));             //d
console.log(fearNotLetter('bcd'));              //undefined
console.log(fearNotLetter('abcdefghjklmno'));   //i
console.log(fearNotLetter('yz'));               //undefined

Solution 4:^[4]

Another function that may help:

var alphabet = "abcdefgheijklmnopqrstuvwxyz";
function fearNotLetter(a) {
  function letterIndex(text, index) {
    var letter = text.charAt(0);
    if (alphabet.indexOf(letter) !== index) { return alphabet.charAt(index); } else { return letterIndex(text.substring(1), index + 1) }
  }
  if (alphabet.indexOf(a) === -1) {
    return letterIndex(a, alphabet.indexOf(a.charAt(0)));
  }
  return undefined;
}
fearNotLetter("abc"); //Undefined
fearNotLetter("abce"); //d
fearNotLetter("fgi"); //h

Solution 5:^[5]

This will do what you're looking for:

Hit run and check your console

function missingLetter (str) {
    var alphabet = ("abcdefghijklmnopqrstuvwxyz");
    var first = alphabet.indexOf(str[0]);
    var strIndex = 0;
    var missing;

    for (var i = first ; i < str.length ; i++) {
        if (str[strIndex] === alphabet[i]) {
            strIndex++;
        } else {
            missing = alphabet[i];
        }
    }
    return missing;
}

console.log(missingLetter("abce"));
console.log(missingLetter("bcd"));
console.log(missingLetter("abcdefghjklmno"));
console.log(missingLetter("yz"));

Solution 6:^[6]

I think that you wanted to say that if a string doesn't start with "a" than return "undefined". So here's my code:

 function fearNotLetter(str) {
   var alphabet = ("abcdefgheijklmnopqrstuvwxyz");
   var i = 0;
   var j = 0;
   while (i < alphabet.length && j < str.length) {
     if (alphabet.charAt(i) != str.charAt(j)) {
       i++;
       j++;
       if (alphabet.charAt(i - 1) == "a") {
         return "undefined";
       } else {
         return (alphabet.charAt(i - 1));
       }
     }
     i++;
     j++;
   }
 }

 alert(fearNotLetter('abce'));

Here's the working JsFiddle.

You wanted the code to return the missing letter so I used CharAt.
You can make an array of letters and then search through it to see if it maches with letters from the string....

Solution 7:^[7]

function fearNotLetter(str) {

  var a = str.split('');
  var array = [];
  var j = 0;

  for (var i = 1; i < a.length; i++) {
    var d = a[i].charCodeAt(0);
    var c = a[i - 1].charCodeAt(0);

    var delta = d - c;

    if (delta != 1) {
      array[i] = String.fromCharCode(a[i - 1].charCodeAt(0) + 1);
    }
  }

  str = array.join('');

  if (str.length === 0) {
    return undefined;
  } else {
    return str;
  }
}

fearNotLetter('abcefr');

Solution 8:^[8]

This is an even shorter answer thanks to RegExp() that allows you to create a Regular Expression on the fly and use match() to strip off the given letters from a generated String that has all the letters in the given range:

function fearNotLetter(str) {
  var allChars = '';
  var notChars = new RegExp('[^'+str+']','g');
  for (var i=0;allChars[allChars.length-1] !== str[str.length-1] ;i++)
    allChars += String.fromCharCode(str[0].charCodeAt(0)+i);
  return allChars.match(notChars) ? allChars.match(notChars).join('') : undefined;

}

Solution 9:^[9]

How about this one? it finds all missing letters anywhere between the first and the last given letters:

function fearNotLetter(str) {
  var strArr = str.split('');
  var missingChars = [], i = 0;
  var nextChar = String.fromCharCode(strArr[i].charCodeAt(0)+1);
  while (i<strArr.length - 1) {
    if (nextChar !== strArr[i+1]){
      missingChars.push(nextChar);
      nextChar = String.fromCharCode(nextChar.charCodeAt(0)+1);
    } else {
      i++;
      nextChar = String.fromCharCode(strArr[i].charCodeAt(0)+1);
    }
  }

  return missingChars.join('') === '' ? undefined : missingChars.join('') ;
}

console.log(fearNotLetter("ab"));

Solution 10:^[10]

Here is what I use:

function fearNotLetter(str) {
        var firstLtrUnicode = str.charCodeAt(0),
            lastLtrUnicode = str.charCodeAt(str.length - 1);
        var holder = [];
        for (var i=firstLtrUnicode; i<=lastLtrUnicode; i++) {
            holder.push(String.fromCharCode(i));
        }
        var finalStr = holder.join('');
        if ( finalStr === str ) { return undefined; }
        else { return holder.filter( function(letter) {
            return str.split('').indexOf(letter) === -1;
        }).join(''); } }

Solution 11:^[11]

Try this:

function fearNotLetter(str) {
    var alp = ('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ').split(''), i;
    for (i =  alp.indexOf(str.charAt(0)); i < str.length; i++) {
        if (str.split('').indexOf(alp[i]) === -1) {
            return alp[i];
        }
    }
    return undefined;
}

fearNotLetter('bcd');

Solution 12:^[12]

Here's my solution, which i find to be quite easy to interpret:

function fearNotLetter(str) {
  var missingLetter;
  for (var i = 0; i < str.length; i++) {
    if (str.charCodeAt(i) - str.charCodeAt(i-1) > 1) {
      missingLetter = String.fromCharCode(str.charCodeAt(i) - 1);
    }
  }
  return missingLetter;
}

Solution 13:^[13]

I just did this challenge. I am a beginner to Javascript so this was my approach, very simple, sometimes you don't have to use the methods they provide but they also help. I hope you can understand it.

function fearNotLetter(str) {

var alphabet= "abcdefghijlmnopqrstuvwxyz";
var piece =alphabet.slice(0, str.length+1);




for(var i=0; i < piece.length; i++ ){
if(str.charCodeAt(0) != 97){

return undefined;
}

else if(str.indexOf(piece[i])===-1){
  return piece[i];
}
}// for loop

}

fearNotLetter("abce");// It will return d
fearNotLetter("xy");//It will return undefined
fearNotLetter("bce");//It will return undefined

Solution 14:^[14]

  function fearNotLetter(str) {
  //transform the string to an array of characters    
  str = str.split('');

  //generate an array of letters from a to z
  var lettersArr = genCharArray('a', 'z');
  //transform the array of letters to string
  lettersArr = lettersArr.join('');
  //substr the a to z string starting from the first letter of the provided 
  string
  lettersArr = lettersArr.substr(lettersArr.indexOf(str[0]), str.length);
  //transform it again to an array of letters
  lettersArr = lettersArr.split('');
  //compare the provided str to the array of letters
  for(var i=0; i<lettersArr.length;i++){
    if(str[i] !== lettersArr[i])
      return lettersArr[i];
  }
  return undefined;
}

function genCharArray(charA, charZ) {
    var a = [], i = charA.charCodeAt(0), j = charZ.charCodeAt(0);
    for (; i <= j; ++i) {
        a.push(String.fromCharCode(i));
    }
    return a;
}

fearNotLetter("bcd");

Solution 15:^[15]

Here's my another answer in missing letters:

function fearNotLetter(str) {
  var alphabet = 'abcdefghijklmnopqrstuvwxyz';
  var first = alphabet.indexOf(str[0]);
  var last = alphabet.indexOf(str[str.length-1]);
  var alpha = alphabet.slice(first,last);

  for(var i=0;i<str.length;i++){
    if(str[i] !== alpha[i]){
      return alpha[i];
    }
  } 
}

console.log(fearNotLetter("abce"));

Solution 16:^[16]

Overview:

 const fearNotLetter = str => {
  if(str.length < 26) {
    return String.fromCharCode( 
      str.split("")
      .map(x=> x.charCodeAt(0))
      .sort((a,b) => a-b)
      .find((x,i,a) => a[i+1]-x > 1) + 1
    );
  }
}

1 liner:

const fearNotLetter = str => str.length < 26 ? String.fromCharCode(str.split("").map(x=> x.charCodeAt(0)).sort((a,b) => a-b).find((x,i,a) => a[i+1]-x > 1) + 1) : undefined;

Solution 17:^[17]

function fearNotLetter(str) {  
  var string = array. join("");
  for (var i = 0; i < string. length; i++) {                    
    if (string. charCodeAt(i + 1) - string. charCodeAt(i) != 1) {
      return String. fromCharCode(string. charCodeAt(i) + 1);
    } 
  }
  return undefined 
}

Sources

This article follows the attribution requirements of Stack Overflow and is licensed under CC BY-SA 3.0.

Source: Stack Overflow

Solution	Source
Solution 1
Solution 2
Solution 3	Rick Hitchcock
Solution 4	Mindastic
Solution 5	ChadF
Solution 6	sergiu reznicencu
Solution 7	ggglni
Solution 8	Saba Ahang
Solution 9
Solution 10
Solution 11	Castaglia
Solution 12	Yup.
Solution 13	Alberto Verissimo
Solution 14
Solution 15	C.Sales
Solution 16
Solution 17	Nick

'Find missing letter in list of alphabets

Solution 1:[1]

Solution 2:[2]

Solution 3:[3]

Solution 4:[4]

Solution 5:[5]

Solution 6:[6]

Solution 7:[7]

Solution 8:[8]

Solution 9:[9]

Solution 10:[10]

Solution 11:[11]

Solution 12:[12]

Solution 13:[13]

Solution 14:[14]

Solution 15:[15]

Solution 16:[16]

Solution 17:[17]