Ersetzen Sie Konsonanten in einer Zeichenfolge mit dem nächsten Konsonanten im Alphabet

Question

Hier versuche ich, eine Zeichenfolge einzugeben und die Zeichenfolge Buchstaben mit Konsonanten Zeichenfolge zu vergleichen. Wenn der eingegebene Buchstabe und der Konsonant übereinstimmen, sollte die Ausgabe den nächsten Konsonantenbuchstaben drucken.

Hier sind j und v Konsonant, also nächster Buchstabe nach j ist k, ebenfalls nach v wir haben w.

BufferedReader bf = new BufferedReader(new InputStreamReader(System.in)); 
System.out.print("Enter any string = "); 
String inputString = bf.readLine().toLowerCase(); 

for(int i=0; i < inputString.length(); i++){ 
    inputChar = inputString.charAt(i); 

    String consonants = "BCDFGHJKLMNPQRSTVWXYZ".toLowerCase(); 
    for(int j = 0; j < consonants.length(); j++){ 
     stringChar = consonants.charAt(j); 

     if(inputChar == stringChar){ 
     } 

    } 
} 

Answer 1

String consonants = "BCDFGHJKLMNPQRSTVWXYZ".toLowerCase(); 

String inputString = "java"; 

String retStr = ""; 

inputString = inputString.toLowerCase(); 

for(int i=0; i < inputString.length(); i++) 
{ 
    char inputChar = inputString.charAt(i); 

    int indexOfCons = consonants.indexOf(inputChar); 

    if (indexOfCons != -1) 
    { 
      indexOfCons++; 

      // if the letter is Z, then go around to B 
      if (indexOfCons == consonants.length()) 
      { 
       indexOfCons = 0; 
      } 
      retStr += consonants.charAt(indexOfCons); 
    } 
    else 
    { 
      retStr += inputChar; 
    } 
} 
System.out.println(retStr); 

Ausgänge:

Kawa

Answer 2

Die beiden anderen Antworten erzeugen den richtigen Ausgang, aber sie sind nicht sehr effizient, so dass hier mein nehmen ist.

Ihre consonants sollte eine Konstante sein, und sollte einfach als Kleinbuchstaben angegeben werden. Als Konstante sollte sie in Großbuchstaben angegeben werden (CONSONANTS).

ein Zeichen für Zeichen Ersatz zu tun, der effizienteste Weg ist, um die char[] des ursprünglichen Zeichenfolge erhalten toCharArray() verwenden, ändern die das Array und erstellen new String(char[]) eine neue Zeichenfolge verwendet wird.

Der einfachste Weg, den Index eines Buchstabens in der CONSONANTS Konstante zu finden, ist die indexOf() Methode zu verwenden.

Um einen Überlauf beim Hinzufügen von 1 zum Index zu vermeiden, verwenden Sie den Modulo-Operator (%).

private static final String CONSONANTS = "bcdfghjklmnpqrstvwxyz"; 

private static String shiftConsonants(String input) { 
    char[] chars = input.toLowerCase().toCharArray(); 
    for (int i = 0; i < chars.length; i++) { 
     int idx = CONSONANTS.indexOf(chars[i]); 
     if (idx != -1) 
      chars[i] = CONSONANTS.charAt((idx + 1) % CONSONANTS.length()); 
    } 
    return new String(chars); 
} 

Test:

System.out.println(shiftConsonants("Java")); // prints: kawa 

---

Hier ist eine alternative Lösung, die den ursprünglichen Fall behält.

private static final String CONSONANTS = "bcdfghjklmnpqrstvwxyz"; 
private static String shiftConsonants(String input) { 
    char[] chars = input.toCharArray(); 
    for (int i = 0; i < chars.length; i++) { 
     char ch = chars[i]; 
     char lower = Character.toLowerCase(ch); 
     int idx = CONSONANTS.indexOf(lower); 
     if (idx != -1) { 
      char next = CONSONANTS.charAt((idx + 1) % CONSONANTS.length()); 
      chars[i] = (ch == lower ? next : Character.toUpperCase(next)); 
     } 
    } 
    return new String(chars); 
} 

Test:

System.out.println(shiftConsonants("Java")); // prints: Kawa 

---

Follow-up zu comment by @MistahFiggins:

Casting Würde für jedes Zeichen in int und dann die Nummer ändern und Gießen wieder mehr oder weniger effizient?

Meine Vermutung war falsch. Für die Kleinbuchstabenversion (die erste oben) ist das numerische Inkrement 36% schneller.

private static String shiftConsonants(String input) { 
    char[] chars = input.toLowerCase().toCharArray(); 
    for (int i = 0; i < chars.length; i++) { 
     char ch = chars[i]; 
     if (ch == 'z') 
      chars[i] = 'b'; 
     else if (ch >= 'b' && ch <= 'y' && ch != 'e' && ch != 'i' && ch != 'o' && ch != 'u') { 
      ch = (char)(ch + 1); 
      if (ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u') 
       ch++; 
      chars[i] = ch; 
     } 
    } 
    return new String(chars); 
} 

Wie Sie sehen können, ist es optimiert, um nicht einmal a zu betrachten.

Answer 3

import java.io.BufferedReader; 
import java.io.IOException; 
import java.io.InputStreamReader; 
import java.util.ArrayList; 
import java.util.Arrays; 
import java.util.List; 

public class TestIt { 

    public static void main(String args[]) throws IOException 
    { 
     List<Character> consonantList = new ArrayList<Character>(); 
     consonantList.addAll(Arrays.asList('b','c','d','f','g','h','j','k','l','m','n','p','q','r','s','t','v','w','x','y','z')); 
     BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in)); 
     char[] userInput = bufferedReader.readLine().toLowerCase().toCharArray(); 
     for(int i=0;i<userInput.length;i++) 
     { 
      if(consonantList.contains(userInput[i])) 
      { 
       userInput[i]=consonantList.get((consonantList.indexOf(userInput[i])+1)%21); 
      } 
     } 
     System.out.println(String.valueOf(userInput)); 
    } 
} 

Answer 4

//declare out side of the loop 
String consonants = "BCDFGHJKLMNPQRSTVWXYZ".toLowerCase(); 
//initialize the result 
String op = ""; 

for(int i=0; i < inputString.length(); i++){ 
    inputChar = inputString.charAt(i); 
    //find the index of char 
    int index = consonants.indexOf(inputChar); 
    //if char 'z' then point to 'b' or to the next char 
    op += index==-1 ? inputChar : consonants.charAt(index == consonants.length()-1 ? 0 : index+1); 
} 
System.out.println(op);