Question

检查给定字符串中所有字母的最佳逻辑是什么。

如果提供的字符串中有26个字母都可用，我想检查并执行操作。例如。用五十个酒壶包装盒子。

使用Hash会有用吗？
还是使用位图？或任何其他方式？

顺便说一句，我的代码是Java格式。

Answer 1

使用BitMap，我假设你的意思是不区分大小写。

更新：托马斯的解决方案比以下更有效。 :)使用那个。

    //
    String test  = "abcdefeghjiklmnopqrstuvwxyz";

    BitSet alpha = new BitSet(26);
    for(char ch : test.toUpperCase().toCharArray())
        if(Character.isLetter(ch))
            alpha.set(ch - 65);

    System.out.println(alpha.cardinality() == 26);

Answer 2

尚未完全优化：

public static void main(String... a) {
    String s = "Pack my box with five dozen liquor jugs.";
    int i=0;
    for(char c : s.toCharArray()) {
        int x = Character.toUpperCase(c);
        if (x >= 'A' && x <= 'Z') {
            i |= 1 << (x - 'A');
        }
    }
    if (i == (i | ((1 << (1 + 'Z' - 'A')) - 1))) {
        System.out.println("ok");
    }
}

Answer 3

我会去寻找位图。如果每次将位图中的条目设置为1时递增计数器，则可以在看到所有字母后立即返回。我希望这不是为了强制执行密码要求。

Answer 4

保持大小为26的boolean数组。数组的每个位置都表示是否存在特定字符（a为0，b为1等）。最初所有都设置为false。现在逐个字符地逐字扫描字符串，将该字符的值设置为true。最后，检查所有26个索引是否都包含true。

Answer 5

26个布尔值的数组就足够了，每个条目代表字母上的字母。您可以在找到该字母时将条目设置为true。

Answer 6

我会在26个字母上找一个筛子算法。只是我的$ .02。

编辑：包含26个字母表的26个值的数组。然后扫描字符串，在遇到它时检查每个字母。最后，检查是否已检查了26个字母。

Answer 7

    public class Pangram {
    public static boolean isPangram(String test){
        for (char a = 'A'; a <= 'Z'; a++)
            if ((test.indexOf(a) < 0) && (test.indexOf((char)(a + 32)) < 0))
                return false;
        return true;
    }

    public static void main(String[] args){
        System.out.println(isPangram("the quick brown fox jumps over the lazy dog"));//true
        System.out.println(isPangram("the quick brown fox jumped over the lazy dog"));//false, no s
        System.out.println(isPangram("ABCDEFGHIJKLMNOPQRSTUVWXYZ"));//true
        System.out.println(isPangram("ABCDEFGHIJKLMNOPQSTUVWXYZ"));//false, no r
        System.out.println(isPangram("ABCDEFGHIJKL.NOPQRSTUVWXYZ"));//false, no m
        System.out.println(isPangram("ABC.D.E.FGHI*J/KL-M+NO*PQ R\nSTUVWXYZ"));//true
        System.out.println(isPangram(""));//false
        System.out.println(isPangram("Pack my box with five dozen liquor jugs."));//true
    }
}

Answer 8

尝试这一点，它易于理解

import java.util.*;

public class Pnagram{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        String Str=sc.nextLine();
        Set<Character> set = new HashSet<Character>();

        for(char c:Str.toUpperCase().toCharArray()){
            if(Character.isLetter(c))
            set.add(c);
        }
        if(set.size()==26)
            System.out.println("pnagram");
        else
            System.out.println("not pnagram");
    }
}

Answer 9

您可以为要检查的字母表中的每个字母迭代字符串。找到您要找的信后，继续下一个。如果你不这样做，就中止。这是一些伪代码：

found = true;
for (letter in letters) {
    if (!string.contains(letter)) {
        found = false;
        break;
    }
}

这样您就不需要存储每个字母的信息，但您必须为每个字母反复搜索字符串。你最终使用的将取决于你的要求：它应该快吗？它应该使用少量内存吗？你的决定。：）

Answer 10

public static void main(String[] args) {

    String A ="asdfsdafasdf";
    String B ="abcdefghijklmnopqrstuvwxyz";
    String C ="ASDFGFHWER";
    String result = "NO";

    String letters[] = {A,B,C};
    int length = letters.length;

    for(int j=0; j< length; j++){
        String letter = letters[j].toLowerCase();
        int letterLength = letter.length();
        for(char i='a'; i<'z'+1; i++){
            if(letter.contains (""+i)){
                result ="YES";
            } else{
                result = "NO";
            }
        }
        System.out.println(result);
    }
}

Answer 11

这不是最佳解决方案，但易于理解:)！

import java.io.*;
import java.util.*;

public class Solution {

public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    String s = in.nextLine().toUpperCase();
    char[] sarray = s.toCharArray();
    char[] alphabets = {'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'};
    Set<Character> set = new HashSet<Character>();
    for(int i=0;i<sarray.length;i++){
        for(int j=0;j<alphabets.length;j++){
            if(sarray[i] == alphabets[j]){
                set.add(sarray[i]);
                break;
            }
            continue;
        }
    }
    if(set.size() == 26){
        System.out.println("pangram");
    }else{
        System.out.println("not pangram");
    }

}

}

Answer 12

解释

首先，我将所有字符串字符转换为大写字母。

在ASCII表中，您可以找到大写字符范围，即介于65到90之间

A == 65且Z == 90

因此，for循环应从65开始，到90结束。

检查字符串是否包含当前的ASCII字符。

我将整数转换为char并放入＆＃34;＆＃34;成为字符串

if !text.contains((char)i + "") == true

这意味着如果字符串没有i的当前字符，我将return false。

通过在循环中使用char i

，您可以做得更好

static boolean isPangram(String text) {
    //change all chars to upper case
    text = text.toUpperCase();
    //Loop from A to Z
    for(int i = 65 ; i < 91 ; i++){
        //if text not contains return false
        if(!text.contains((char)i + "")){   
            return false;
        }
    }
    return true;
}

Answer 13

不是最佳解决方案，但可行。

String a= new String("the quick brown fox jumps over the lazy dog");
        int n=a.length();
        int[] b= new int[123];
        char x;
        boolean flag=true;
        for(int i=0;i<n;i++)    
    {

        if(a.charAt(i)==' ')
            continue;
        x=Character.toLowerCase(a.charAt(i));
        b[(int)x]++;

    }
    for(int i=97;i<123;i++)
    {
        if(b[i]==0) 
            {
                flag=false;
                break;
            }
    }
    if(!flag)
        System.out.print("No");
        else
        System.out.print("yes");

Answer 14

另一种解决方案，使用数组代替Set

public static boolean isPanagram(String input) {
    if(input == null || input.trim().equals(""))
        return false;

    boolean[] chars = new boolean[26];
    int count = 0;
    for(char c : input.toLowerCase().toCharArray()) {
        if(Character.isAlphabetic(c)) {
            int val = (int) c - 'a';
            if(val >= 0 || val <= 26) {
                if(!chars[val]) {
                    count++;
                    chars[val] = true;
                }
            }
            // checking if all 26 alphabets are set, for every new alphabet found. 
            // so can return true immediately instead of processing entire string
            if(count==26)
                return true;
        }
    }

    return false;
}

Answer 15

尝试这种方法，非常简单并且可以快速运行

public static String checkSentence(String mySentence)
{
    String result = "";
    char[] alphabet = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};

    String missingLetters = "";
    int countMissLetters = 0;

    for (int i = 0; i < alphabet.length; i++)
    {
        if (!mySentence.toLowerCase().contains(String.valueOf(alphabet[i]).toLowerCase()))
            {
                missingLetters = missingLetters + String.valueOf(alphabet[i]) + " ";
                countMissLetters++;
            }
    }

    result = "Letters who are missing: " + missingLetters + "Counted: " + countMissLetters;
    return result;
}

以这个例子

System.out.println(checkSentence("Your own sentence to test."));
System.out.println(checkSentence("abcdefghijklmnoprstuvwxyz"));

将返回此结果

Letters who are missing: a b d f g h i j k l m p q v x z Counted: 16
Letters who are missing: q Counted: 1

Answer 16

我找到了一种检查字符串是否所有字符都是字母的简单方法。

public static boolean isStringLetter(String input) {

    boolean b = false;
    for (int id = 0; id < input.length(); id++) {
        if ('a' <= input.charAt(id) && input.charAt(id) <= 'z') {
            b = true;
        } else if ('A' <= input.charAt(id) && input.charAt(id) <= 'Z') {
            b = true;
        } else {
            b = false;
        }
    }
    return b;
}

检查字符串是否包含字母表中的所有字母

16 个答案: