Smallest alphabet greater than a given character
Last Updated :
11 Nov, 2023
Given a list of sorted characters consisting of both Uppercase and Lowercase Alphabets and a particular target value, say K, the task is to find the smallest element in the list that is larger than K.
Letters also wrap around. For example, if K = ‘z’ and letters = [‘A’, ‘r’, ‘z’], then the answer would be ‘A’.
Examples:
Input : Letters = ["D", "J", "K"]
K = "B"
Output: 'D'
Explanation:
The Next greater character of "B" is 'D'
since it is the smallest element from the
set of given letters, greater than "B".
Input: Letters = ["h", "n", "s"]
K = "t"
Output: 'h'
Prerequisites: Binary Search
Approach: Binary Search can be applied to find the index of the smallest character in the given Set of Letters such that the character at that index is greater than K. If the element at the current mid is smaller than or equal to K, binary search is applied on the Right half, else it is applied on the left half.
C++
#include <bits/stdc++.h>
using namespace std;
char nextGreatestAlphabet(vector< char >& alphabets, char K)
{
int n= alphabets.size();
if (K>=alphabets[n-1]) return alphabets[0];
int l = 0, r = alphabets.size() - 1;
int ans = -1;
while (l <= r) {
int mid = (l + r) / 2;
if (alphabets[mid] > K)
{
r = mid - 1;
ans = mid;
}
else
l = mid + 1;
}
return alphabets[ans];
}
int main()
{
vector< char > letters{ 'A' , 'K' , 'S' };
char K = 'L' ;
char result = nextGreatestAlphabet(letters, K);
cout << result << endl;
return 0;
}
|
Java
class GFG
{
static char nextGreatestAlphabet( char alphabets[],
char K)
{
int n = alphabets.length;
if (K>=alphabets[n- 1 ])
return alphabets[ 0 ];
int l = 0 , r = alphabets.length - 1 ;
int ans = - 1 ;
while (l <= r)
{
int mid = (l + r) / 2 ;
if (alphabets[mid] > K)
{
r = mid - 1 ;
ans = mid;
}
else
l = mid + 1 ;
}
return alphabets[ans];
}
public static void main(String[] args)
{
char letters[] = { 'A' , 'r' , 'z' };
char K = 'z' ;
char result = nextGreatestAlphabet(letters, K);
System.out.println(result);
}
}
|
Python 3
def nextGreatestAlphabet(alphabets, K):
n = len (alphabets)
if (K > = alphabets[n - 1 ]):
return alphabets[ 0 ]
l = 0
r = len (alphabets) - 1
ans = - 1
while (l < = r):
mid = int ((l + r) / 2 )
if (alphabets[mid] > K):
r = mid - 1
ans = mid
else :
l = mid + 1
if (alphabets[ans] < K):
return alphabets[ 0 ]
else :
return alphabets[ans]
letters = [ 'A' , 'r' , 'z' ]
K = 'z'
result = nextGreatestAlphabet(letters, K)
print (result)
|
C#
using System;
class GFG {
static char nextGreatestAlphabet( char [] alphabets,
char K)
{
int n= alphabets.Length;
if (K >= alphabets[n-1])
return alphabets[0];
int l = 0, r = alphabets.Length - 1;
int ans = -1;
while (l <= r)
{
int mid = (l + r) / 2;
if (alphabets[mid] > K)
{
ans = mid;
r = mid - 1;
}
else
l = mid + 1;
}
return alphabets[ans];
}
public static void Main()
{
char [] letters = { 'A' , 'r' , 'z' };
char K = 'z' ;
char result = nextGreatestAlphabet(letters, K);
Console.Write(result);
}
}
|
Javascript
<script>
function nextGreatestAlphabet(alphabets, K)
{
var l = 0,
r = alphabets.length - 1;
var ans = -1;
while (l <= r)
{
var mid = (l + r) / 2;
if (alphabets[mid] > K) {
ans = mid;
r = mid - 1;
} else l = mid + 1;
}
return alphabets[ans];
}
var letters = [ "A" , "K" , "S" ];
var K = "L" ;
document.write(nextGreatestAlphabet(letters, K));
</script>
|
The Time Complexity of the above approach is, O(log N) where N is the number of characters in the given set of Letters.
Approach#2: Using upper
This approach compares each letter in the input list to the given character, finds the smallest letter greater than the given character, and prints it.
Algorithm
1. Convert all letters to uppercase for case-insensitive comparison.
2. Initialize the smallest greater letter to None.
3. Iterate over all letters in the list.
4. If the current letter is greater than the given character k and smaller than the current smallest greater letter, then update the smallest greater letter to the current letter.
5. If no greater letter was found, print “No greater letter found”, else print the smallest greater letter.
C++
#include <iostream>
#include <vector>
#include <algorithm>
int main() {
std::vector<std::string> letters = { "D" , "J" , "K" };
std::string k = "B" ;
std::transform(letters.begin(), letters.end(), letters.begin(), [](std::string& letter) {
std::transform(letter.begin(), letter.end(), letter.begin(), :: toupper );
return letter;
});
std::transform(k.begin(), k.end(), k.begin(), :: toupper );
std::string smallestGreaterLetter = "" ;
for ( const auto & letter : letters) {
if (letter > k && (smallestGreaterLetter.empty() || letter < smallestGreaterLetter)) {
smallestGreaterLetter = letter;
}
}
if (smallestGreaterLetter.empty()) {
std::cout << "No greater letter found" << std::endl;
} else {
std::cout << smallestGreaterLetter << std::endl;
}
return 0;
}
|
Java
import java.util.ArrayList;
public class SmallestGreaterLetter {
public static void main(String[] args) {
ArrayList<String> letters = new ArrayList<>();
letters.add( "D" );
letters.add( "J" );
letters.add( "K" );
String k = "B" ;
ArrayList<String> uppercaseLetters = new ArrayList<>();
for (String letter : letters) {
uppercaseLetters.add(letter.toUpperCase());
}
k = k.toUpperCase();
String smallestGreaterLetter = null ;
for (String letter : uppercaseLetters) {
if (letter.compareTo(k) > 0 && (smallestGreaterLetter == null ||
letter.compareTo(smallestGreaterLetter) < 0 )) {
smallestGreaterLetter = letter;
}
}
if (smallestGreaterLetter == null ) {
System.out.println( "No greater letter found" );
} else {
System.out.println(smallestGreaterLetter);
}
}
}
|
Python3
letters = [ "D" , "J" , "K" ]
k = "B"
letters = [letter.upper() for letter in letters]
k = k.upper()
smallest_greater_letter = None
for letter in letters:
if letter > k and (smallest_greater_letter is None or letter < smallest_greater_letter):
smallest_greater_letter = letter
if smallest_greater_letter is None :
print ( "No greater letter found" )
else :
print (smallest_greater_letter)
|
C#
using System;
using System.Collections.Generic;
class SmallestGreaterLetter
{
public static void Main( string [] args)
{
List< string > letters = new List< string >
{
"D" ,
"J" ,
"K"
};
string k = "B" ;
List< string > uppercaseLetters = new List< string >();
foreach ( string letter in letters)
{
uppercaseLetters.Add(letter.ToUpper());
}
k = k.ToUpper();
string smallestGreaterLetter = null ;
foreach ( string letter in uppercaseLetters)
{
if ( string .Compare(letter, k) > 0 &&
(smallestGreaterLetter == null || string .Compare(letter, smallestGreaterLetter) < 0))
{
smallestGreaterLetter = letter;
}
}
if (smallestGreaterLetter == null )
{
Console.WriteLine( "No greater letter found" );
}
else
{
Console.WriteLine(smallestGreaterLetter);
}
}
}
|
Javascript
let letters = [ "D" , "J" , "K" ];
let k = "B" ;
letters = letters.map(letter => letter.toUpperCase());
k = k.toUpperCase();
let smallestGreaterLetter = null ;
letters.forEach(letter => {
if (letter > k && (smallestGreaterLetter === null || letter < smallestGreaterLetter)) {
smallestGreaterLetter = letter;
}
});
if (smallestGreaterLetter === null ) {
console.log( "No greater letter found" );
} else {
console.log(smallestGreaterLetter);
}
|
Time complexity: O(n), where n is the number of letters in the input list. This is because we iterate over all the letters in the list once.
Space complexity: O(1), as we are using a constant amount of extra memory to store the variables used in the algorithm, regardless of the size of the input list.
Share your thoughts in the comments
Please Login to comment...