Java 检查两个字符串是否是彼此的置换_Java

Java 检查两个字符串是否是彼此的置换

java

Java 检查两个字符串是否是彼此的置换,java,Java,如何确定两个字符串是否是彼此的排列对两个字符串的字符进行排序比较结果，看它们是否相同编辑： `public boolean sort(String x, String y) { if (x.length() != y.length()) { System.out.println("false"); return false; } System.out.println(sort(x).equals(

如何确定两个字符串是否是彼此的排列

对两个字符串的字符进行排序

比较结果，看它们是否相同

编辑：

   `public boolean sort(String x, String y) {
       if (x.length() != y.length()) {
           System.out.println("false");
           return false;
       }
       System.out.println(sort(x).equals(sort(y)));
       return sort(x).equals(sort(y));
   }`

上面的方法相当有效-O（n*log（n）），并且，如其他人所示，使用标准JavaAPI非常容易实现。更有效的（但也需要更多的工作）是计数和比较每个字符的出现情况，使用字符值作为计数数组的索引

我不认为有一种有效的方法可以递归地进行。一种低效的方法（O（n^2），如果直接实施，则更糟）是：

如果两个字符串由一个相同的字符组成，则返回true
否则：
- 从第一个字符串中删除一个字符
- 查看第二个字符串中是否出现此字符
- 如果不存在，则返回false
- 否则，删除所述字符并将算法递归地应用于两个字符串的剩余部分

将@Michael Borgwardt的话转化为代码：

public boolean checkAnagram(String str1, String str2) {

    if (str1.length() != str2.length())
      return false;

    char[] a = str1.toCharArray();
    char[] b = str2.toCharArray();

    Arrays.sort(a);
    Arrays.sort(b);

    return Arrays.equals(a, b);
}

按字符对两个字符串进行排序，并比较它们是否相同（O（n logn）时间，O（n）空间），或

计算两个字符串的字符频率，并比较它们是否相同（O（n）时间，O（n）空间）

创建一个Hashmap，第一个字符串的字符作为键，发生次数作为值；然后遍历第二个字符串，对于每个字符，查找哈希表，如果大于零，则减少数字。如果找不到条目或条目已为0，则字符串不是彼此的排列。显然，字符串必须具有相同的长度。

您可以看一看，然后首先检查长度（

），如果它们不相同，就不能是彼此的排列。现在创建两个

HashMap

。迭代每个字符串，并输入每个字符在字符串中出现的次数。例如，如果字符串是aaaaa，则映射将只有一个元素具有键a和值5。现在检查两个贴图是否相同。这是一个

O（n）

算法

使用代码段编辑：

boolean checkPermutation(String str1, String str2) {

char[] chars1 = str1.toCharArray();
char[] chars2 = str2.toCharArray();

Map<Character, Integer> map1 = new HashMap<Character, Integer>();
Map<Character, Integer> map2 = new HashMap<Character, Integer>();

for (char c : chars1) {
   int occ = 1;
   if (map1.containsKey(c) {
       occ = map1.get(c);
       occ++;
   }
   map1.put(c, occ);
}

// now do the same for chars2 and map2

if (map1.size() != map2.size()) {
   return false;
}
for (char c : map1.keySet()) {

    if (!map2.containsKey(c) || map1.get(c) != map2.get(c)) {
        return false;
    }
}

return true;
}

布尔校验置换（字符串str1、字符串str2）{
char[]chars1=str1.toCharArray（）；
char[]chars2=str2.toCharArray（）；
Map map1=新的HashMap（）；
Map map2=新的HashMap（）；
for（字符c:chars1）{
int-occ=1；
if（图1.containsKey（c）{
occ=map1.get（c）；
occ++；
}
map1.put（c、occ）；
}
//现在对chars2和map2执行相同的操作
如果（map1.size（）！=map2.size（））{
返回false；
}
for（char c:map1.keySet（））{
如果（！map2.containsKey（c）| map1.get（c）！=map2.get（c））{
返回false；
}
}
返回true；
}

我正在开发一个Java库，它可以简化您的任务。您只能使用两个方法调用：

boolean arePermutationsOfSameString(String s1, String s2) {
    s1 = $(s1).sort().join(); 
    s2 = $(s2).sort().join();
    return s1.equals(s2);
}

测试用例附言在这种情况下，您可以克隆强制性的一行程序：

boolean isAnagram(String s1, String s2) {
    return ImmutableMultiset.copyOf(Chars.asList(s1.toCharArray())).equals(ImmutableMultiset.copyOf(Chars.asList(s2.toCharArray())));
}

（只是为了好玩。我不建议将此提交给你的作业。）

根据你的要求，这里有一个使用递归的完整解决方案。现在你所要做的就是：

弄清楚这是什么语言

把它翻译成Java

祝你好运：-）

我做到了这一点，它运行得又好又快：

public static boolean isPermutation(String str1, String str2)
{
    char[] x = str1.toCharArray();
    char[] y = str2.toCharArray();
    Arrays.sort(x);
    Arrays.sort(y);
    if(Arrays.equals(x, y))
        return true;
    return false;
}

我是用C#做的

公共布尔权限（字符串s、字符串t）{
如果（s.length（）！=t.length（））{
返回false；
}
int[]letters=new int[256]；//假定字符集为ASCII
char[]s_数组=s.toCharArray（）；
对于（字符c:s_数组）{///count s中每个字符的数目
字母[c]++；
}
对于（int i=0；i您可以尝试使用XOR，如果一个字符串是另一个字符串的渗透，那么它们应该具有基本相同的字符。唯一的区别就是字符的顺序。因此，使用XOR技巧可以帮助您摆脱顺序，只关注字符
public static boolean isPermutation(String s1, String s2){
    if (s1.length() != s2.length()) return false;
    int checker = 0;
    for(int i = 0; i < s1.length();i++ ){
        checker ^= s1.charAt(i) ^ s2.charAt(i);
    }

    return checker == 0;
}

公共静态布尔值isPermutation（字符串s1、字符串s2）{
如果（s1.length（）！=s2.length（））返回false；
int-checker=0；
对于（int i=0；i

}
公共布尔值IsPermutationOther（字符串str，字符串other）{
如果（str==null | | other==null）
返回false；
如果（str.length（）！=other.length（））
返回false；
Map characterCount=新建HashMap（）；
对于（int i=0；i
HashMap中的线性时间解决方案。遍历并将第一个字符串放入HashMap中，保留每个字符的计数。遍历第二个字符串，如果它已经在HashMap中，则将计数减少1。最后，如果所有字符都在字符串中，则HashMap中的每个字符的值都将为0
public class StringPermutationofEachOther {
    public static void main(String[] args)
    {

    String s1= "abc";
    String s2 ="bbb";
    System.out.println(perm(s1,s2));
}
    public static boolean perm(String s1, String s2)
    { HashMap<Character, Integer> map = new HashMap<Character, Integer>();
    int count =1;
        if(s1.length()!=s2.length())
        {
            return false;
        }
            for(Character c: s1.toCharArray())
            {
                if(!map.containsKey(c))
                    map.put(c, count);

                else
                    map.put(c, count+1);

            }
            for(Character c: s2.toCharArray())
            {
                if(!map.containsKey(c))
                    return false;

                else
                    map.put(c, count-1);
            }
            for(Character c: map.keySet())
            {
                if(map.get(c)!=0)
                    return false;
            }
        return true;
    }


}

public类字符串相互置换{
公共静态void main（字符串[]args）
{
字符串s1=“abc”；
字符串s2=“bbb”；
系统输出println（perm（s1，s2））；
}
公共静态布尔perm（字符串s1、字符串s2）
{HashMap map=newhashmap（）；
整数计数=1；
如果（s1.length（）！=s2.length（））
{
返回false；
}
for（字符c:s1.toCharArray（））
{
如果（！map.containsKey（c））
地图放置（c，计数）；
其他的
地图放置（c，国家）
public boolean permitation(String s,String t){
      if(s.length() != t.length()){
          return false;
          }

       int[] letters = new int[256];//Assumes that the character set is ASCII
       char[] s_array = s.toCharArray();

       for(char c:s_array){         /////count number of each char in s
             letters[c]++;
        }
       for(int i=0;i<t.length();i++){
             int c = (int)t.charAt(i);
             if(--letters[c]<0){
                  return false;
             }
        }
        return true;
}

public static boolean isPermutation(String s1, String s2){
    if (s1.length() != s2.length()) return false;
    int checker = 0;
    for(int i = 0; i < s1.length();i++ ){
        checker ^= s1.charAt(i) ^ s2.charAt(i);
    }

    return checker == 0;
}

             import java.io.*;
                      public class permute 
                    {
                              public static String sort(String s)
                              {
                                     char[] str = s.toCharArray();
                                    java.util.Arrays.sort(str);
                                    return new String(str);
                              }
                      public static boolean permutation(String s,String t)
                     {
                            if(s.length()!=t.length())
                           {
                                   return false;
                           }
                                   return sort(s).equals(sort(t));
                     }
    public static void main(String[] args)            throws IOException
    {
           BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
           String string = null;
           boolean x=true;
           System.out.println("Input String:");
           string = bf.readLine();
           System.out.println("Input another String:");
           String result = bf.readLine();
           String resultant = sort(string);
           if(x==permutation(result,resultant))
           {
                    System.out.println("String"+" "+"("+result+")"+"is a permutation of String"+" "+"("+string+")");
           }
           else
           {
                    System.out.println("Sorry No anagram found");
           }       
    }

public boolean isPermutationOfOther(String str, String other){
    if(str == null || other == null)
        return false;
    if(str.length() != other.length())
        return false;

    Map<Character, Integer> characterCount = new HashMap<Character, Integer>();
    for (int i = 0; i < str.length(); i++) {
        char c = str.charAt(i);
        int count = 1;
        if(characterCount.containsKey(c)){
            int k = characterCount.get(c);
            count = count+k;
        }

        characterCount.put(c, count);

    }

    for (int i = 0; i < other.length(); i++) {
        char c = other.charAt(i);
        if(!characterCount.containsKey(c)){
            return false;
        }

        int count = characterCount.get(c);
        if(count == 1){
            characterCount.remove(c);
        }else{
            characterCount.put(c, --count);
        }
    }

    return characterCount.isEmpty();
}

public class StringPermutationofEachOther {
    public static void main(String[] args)
    {

    String s1= "abc";
    String s2 ="bbb";
    System.out.println(perm(s1,s2));
}
    public static boolean perm(String s1, String s2)
    { HashMap<Character, Integer> map = new HashMap<Character, Integer>();
    int count =1;
        if(s1.length()!=s2.length())
        {
            return false;
        }
            for(Character c: s1.toCharArray())
            {
                if(!map.containsKey(c))
                    map.put(c, count);

                else
                    map.put(c, count+1);

            }
            for(Character c: s2.toCharArray())
            {
                if(!map.containsKey(c))
                    return false;

                else
                    map.put(c, count-1);
            }
            for(Character c: map.keySet())
            {
                if(map.get(c)!=0)
                    return false;
            }
        return true;
    }


}

// run time N, no sorting, assume 256 ASCII char set
public static boolean isPermutation(String v1, String v2) {

    int length1 = v1.length();
    int length2 = v2.length();
    if (length1 != length2)
        return false;

    int s1[] = new int[256];
    int s2[] = new int[256];

    for (int i = 0; i < length1; ++i) {
        int charValue1 = v1.charAt(i);
        int charValue2 = v2.charAt(i);
        ++s1[charValue1];
        ++s2[charValue2];
    }

    for (int i = 0; i < s1.length; ++i) {

        if (s1[i] != s2[i])
            return false;
    }
    return true;
  }
}

@Test
public void testIsPermutation_Not() {
    assertFalse(Question3.isPermutation("abc", "bbb"));
}

@Test
public void testIsPermutation_Yes() {
    assertTrue(Question3.isPermutation("abc", "cba"));
    assertTrue(Question3.isPermutation("abcabcabcabc", "cbacbacbacba"));
}

public class TwoStrgPermutation {

public int checkForUnique(String s1, String s2)
{
    int[] array1 = new int[256];
    int[] array2 = new int[256];

    array1 = arrayStringCounter(array1,s1);
    array2 = arrayStringCounter(array2,s2);

    if(Arrays.equals(array1, array2))
        return 0;
    else
        return 1;
}

public int[] arrayStringCounter(int[] array,String s)
{
    int val;
    for(int i=0;i<s.length();i++)
    {
        val = (int)s.charAt(i);
        array[val]++;
    }

    return array;
}

public static void main(String[] args) {
    // TODO Auto-generated method stub

    InputStreamReader in = new InputStreamReader(System.in);
    BufferedReader br = new BufferedReader(in);
    TwoStrgPermutation obj = new TwoStrgPermutation();
    try {
        String string1 = br.readLine();
        String string2 = br.readLine();

        int len1 = string1.length();
        int len2 = string2.length();

        if(len1==len2)
        {
            int result = obj.checkForUnique(string1,string2);
            if (result == 0){
                System.out.println("yes it is a permutation");
            }
            else if (result >0)
            {
                System.out.println("no it is not");
            }
        }
        else
        {
            System.out.println("no it is not");
        }

    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

}

}

>>>def isPermutation = lambda x, y: set([i for i in x]) == set([j for j in x])
>>>isPermutation("rasp", "spar")
>>>True

int is_permutation(char *s1, char *s2)
{
    if ((NULL == s1) ||
        (NULL == s2)) {
        return false;
    }

    int static const
    _capacity = 256;    // Assumption
    int
    charNums[_capacity] = {0};
    char
    *cRef1 = s1,
    *cRef2 = s2;
    while ('\0' != *cRef1 && '\0' != *cRef2) {
        charNums[*cRef1] += 1;
        charNums[*cRef2] -= 1;
        cRef1++;
        cRef2++;
    }

    if ('\0' != *cRef1 || '\0'  != *cRef2) {
        return false;
    }

    for (int i = 0; i < _capacity; i++) {
        if (0 != charNums[i]) {
            return false;
        }
    }

    return true;
}

   `public boolean sort(String x, String y) {
       if (x.length() != y.length()) {
           System.out.println("false");
           return false;
       }
       System.out.println(sort(x).equals(sort(y)));
       return sort(x).equals(sort(y));
   }`

    private static bool IsPermutation(string str1, string str2)
    {
        if (str1.Length != str2.Length)
            return false;

        var dictionary = new Dictionary<char, int>();

        foreach(var x in str1)
        {
            if (dictionary.ContainsKey(x))
                dictionary[x] += 1;
            else
                dictionary.Add(x, 1);
        }

        foreach (var y in str2)
        {
            if (dictionary.ContainsKey(y))
            {
                if (dictionary[y] > 0)
                    dictionary[y] -= 1;
                else
                    return false;
            }
            else
                return false;
        }

        foreach(var el in dictionary)
        {
            if (el.Value != 0)
                return false;
        }

        return true;
    }

    public static boolean isPermutation(String s1, String s2) {
    if (s1.length() != s2.length()) {
        return false;
    }else if(s1.length()==0 ){
        return true;
    }
    else if(s1.length()==1){
        return s1.equals(s2);
    }
    char[] s = s1.toCharArray();
    char[] t = s2.toCharArray();

    for (int i = 0; i < s.length; i++) {
        for (int j = 0; j < t.length; j++) {

            if (s.length == s1.length() && (i == 0 && j == t.length - 1) && s[i] != t[j]) {
                return false;
            }
            if (s[i] == t[j]) {
                String ss = new String(s);
                String tt = new String(t);
                s = (ss.substring(0, i) + ss.substring(i + 1, s.length)).toCharArray();
                t = (tt.substring(0, j) + tt.substring(j + 1, t.length)).toCharArray();

                System.out.println(new String(s));
                System.out.println(new String(t));

                i = 0;
                j = 0;
            }
        }
    }
    return s[0]==t[0] ;
}

he Big Bang Theory
B B  Tehgiangyroeh
e Big Bang Theory
B B  Tegiangyroeh
 Big Bang Theory
B B  Tgiangyroeh
Big Bang Theory
BB  Tgiangyroeh
ig Bang Theory
B  Tgiangyroeh
g Bang Theory
B  Tgangyroeh
 Bang Theory
B  Tangyroeh
Bang Theory
B Tangyroeh
Bng Theory
B Tngyroeh
Bg Theory
B Tgyroeh
B Theory
B Tyroeh
BTheory
BTyroeh
Bheory
Byroeh
Beory
Byroe
Bory
Byro
Bry
Byr
By
By
B
B
true

boolean arePermutation(String s1, String s2) { 
  if(s1.lenght() != s2.lenght()) {
     return false;
   }
   return mySort(s1).equals(mySort(s2));
 }

  String mySort(String s) {
   Char letters[] = s.toCharArray();
   Arrays.sort(letters);
   return new String(letters);
}

    String str= "abcd";
    String str1 ="dcazb";
    int count=0;

    char s[]= str.toCharArray();
    char s1[]= str1.toCharArray();

    for(char c:s)
    {
        count = count+(int)c ;
    }

    for(char c1:s1)
    {
        count=count-(int)c1;

    }

    if(count==0)
    System.out.println("String are Anagram");
    else
    System.out.println("String are not Anagram");

}

// maps keys to a corresponding unique prime
static Map<Integer, Integer> primes = generatePrimes(255); // use 255 for
                                                            // ASCII or the
                                                            // number of
                                                            // possible
                                                            // characters

public static boolean permutations(String s1, String s2) {
    // both strings must be same length
    if (s1.length() != s2.length())
        return false;

    // the corresponding primes for every char in both strings are multiplied together
    int s1Product = 1;
    int s2Product = 1;

    for (char c : s1.toCharArray())
        s1Product *= primes.get((int) c);

    for (char c : s2.toCharArray())
        s2Product *= primes.get((int) c);

    return s1Product == s2Product;

}

private static Map<Integer, Integer> generatePrimes(int n) {

    Map<Integer, Integer> primes = new HashMap<Integer, Integer>();

    primes.put(0, 2);

    for (int i = 2; primes.size() < n; i++) {
        boolean divisible = false;

        for (int v : primes.values()) {
            if (i % v == 0) {
                divisible = true;
                break;
            }
        }

        if (!divisible) {
            primes.put(primes.size(), i);
            System.out.println(i + " ");
        }
    }

    return primes;

}

private static boolean is_permutation(String s1, String s2) {
    HashMap<Character, Integer> map = new HashMap<Character, Integer>();
    int count = 1;
    if(s1.length()!=s2.length()) {
        return false;
    }
    for(Character c: s1.toCharArray()) {
        if(!map.containsKey(c)) {
            map.put(c, 1);
        }
        else {
            map.put(c, map.get(c) + 1);
        }
    }
    for(Character c: s2.toCharArray()) {
        if(!map.containsKey(c)) {
            return false;
        }
        else {
            map.put(c, map.get(c) - 1);
        }
    }
    for(Character c: map.keySet()) {
        if(map.get(c) != 0) { return false; }
    }
    return true;
}

bool is_permutation1(string str1, string str2) {
    sort(str1.begin(), str1.end());
    sort(str2.begin(), str2.end());
    for (int i = 0; i < str1.length(); i++) {    
        if (str1[i] != str2[i]) {
            return false;
        }
    }
    return true;
}

import java.io.*;
class permute_compare2str
{
    static String[] arr= new String [1200];
    static int p=0;
    void permutation(String s,String t)
    {
        if (s.length()==0)
        {
            arr[p++]=t;
            return;
        }
        for(int i=0;i<s.length();i++)
            permutation(s.substring(0,i)+s.substring(i+1),t+s.charAt(i));
    }
    public static void main(String kr[])throws IOException
    {
        int flag = 0;
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("Enter the first String:");
        String str1 = br.readLine();
        System.out.println("Enter the second String:");
        String str2 = br.readLine();
        new permute_compare2str().permutation(str1,"");
        for(int i = 0; i < p; ++i)
        {
            if(arr[i].equals(str2))
            {
                flag = 1;
                break;
            }
        }
        if(flag == 1)
            System.out.println("True");
        else
        {
            System.out.println("False");
            return;
        }
    }
}

void permutations(String s, String t)
    {
        if (s.length()==0)
        {
            System.out.print(t+" ");
            return;
        }
        for(int i=0;i<s.length();i++)
            permutations(s.substring(0,i)+s.substring(i+1),t+s.charAt(i));
    }

    public boolean checkIfPermutation(String str1, String str2) {
      if(str1.length()!=str2.length()){
        return false;
      }
      int str1_sum = getSumOfChars(str1);
      int str2_sum = getSumOfChars(str2);
      if (str1_sum == str2_sum) {
        return true;
      }
      return false;
}

public int getSumOfChars(String str){
      int sum = 0; 
      for (int i = 0; i < str.length(); i++) {
        sum += str.charAt(i);
      }
      return sum;
}