标签: anagram

在尝试显示数组字符的每个组合而不重复字母时遇到问题.

public static String[] getAllLists(String[] elements, int lengthOfList)
{
    //initialize our returned list with the number of elements calculated above
    String[] allLists = new String[(int)Math.pow(elements.length, lengthOfList)];

    //lists of length 1 are just the original elements
    if(lengthOfList == 1) return elements; 
    else
    {
        //the recursion--get all lists of length 3, length 2, all the way up to 1
        String[] allSublists = getAllLists(elements, lengthOfList - 1);

        //append the sublists to each element
        int arrayIndex = 0;

        for(int i = 0; i < …

我写了下面的代码来检查anagram是否想知道这是完美的,有没有更好的方法在目标C中实现相同的

-(BOOL) findAnagram :(NSString *) string1 :(NSString *) string2
{
    int len = string1.length;
    if (len != string2.length)
    {
        return false;
    }

    for (int i=0; i < len; i++)
    {
        int h = 0;
        int q = 0;
        for (int k = 0;  k < len ; k ++)
        {
            if ([string1 characterAtIndex:i] == [string1 characterAtIndex:k])
            {
                h++;
            }
            if ([string1 characterAtIndex:i] == [string2 characterAtIndex:k])
            {
                q++;
            }
        }

        if (h!=q)
        {
            return false;
        }
    }
    return TRUE;
}

我试图用Ruby获取一个单词的所有字谜但我的代码不起作用,我只得到字符串'ant'的三个结果.任何帮助将非常感激.

class Anagram
    attr_reader :word
  def initialize(word)
    @word = word.downcase
  end

  def anagram_maker
    @word_bank = []
    index = @word.length
    minus_one = index - 1

    while (index * minus_one) != 0
      anagram = @word.split('').shuffle.join
      @word_bank << anagram
      index -= 1
    end
    @word_bank = @word_bank.uniq
  end

  def display
    anagram_maker
    if @word_bank.count > 1
      @word_bank.each do |anagram|
        puts anagram
      end
    else
      puts "Not enough letters for an anagram"
    end
  end

end

不知道还有什么可以尝试.

我需要一种非蛮力算法来确定您要从一个单词中删除的最小字母数量，才能使其成为回文拼写字母。

例如：abba-> 0，abbac-> 0，aabbfghj-> 3，a-> 0，abcdefghij-> 9。

蛮力算法看起来像这样：

1. Send word to method (2.) with counter 0
2. Check if any anagrams of word is palindrome, if yes return counter, if no go to 3.
3. Remove head of word, send to method (2.) with counter++

我相信暴力破解方法的复杂度为O（n * n！）（因为每个单词都有n！个字谜和n个字母要删除）。例如，对于字符串n = 1000，这将花费太长时间。因此，我需要一个更好的算法，但不确定如何检查字符串以确定要删除的字母数量。

由于n> 1的所有回文在某处aba具有对/字母倍数（具有pair aa，abcbapair aa和bb，aaabhas aaa），所以我考虑过删除字母的所有倍数，然后返回新单词-1的长度，或者返回长度为0的长度。这适用于很多单词，但对于某些单词仍然无效。例如：

"aabbfghj" (remove pairs) …

免责声明

大家好，我知道很少有Javascript问题/答案可以用来弄清楚如何找到两个单词是否是字谜。

我不只是在寻找一个可以弄清楚两个单词/字符串是否是字谜的函数。我正在寻找一种比下面提供的功能更快的功能。目前，我相信以下函数的时间复杂度为O（n log n）。

我想找出一个函数，该函数的时间复杂度为O（n）或运行时间比提供的函数快。

码

const isAnagram = (str1, str2) => {

  str1 = str1.toLowerCase();
  str2 = str2.toLowerCase();


  if (str1.length !== str2.length) {
     return false
  }

  let sortStr1 = str1.split('').sort().join('').trim();
  let sortStr2 = str2.split('').sort().join('').trim();

  return sortStr1 === sortStr2
 };

console.log(isAnagram('dog', 'goD')); //true

我一直在研究重新排列单词字母的算法,但是找到正确的单词需要很长时间.

var
  Form1: TForm1;
  DictionaryArray : array[0..2000] of string;

const Numbrs : string = '123456789';

implementation

{$R *.dfm}

function GenerateSequence(CPoint : String; L : Integer): String;
var
  Increaser : array[1..8] of Integer;
  i : Integer;
  AnagramSequence : String;
begin
  FillChar(Increaser, SizeOf(Increaser), 0);
  for i := 1 to Length(CPoint) do
    Increaser[9 - i] := StrToInt(CPoint[L + 1 - i]);

  //==========================================//

  if Increaser[8] <= L then
    Increaser[8] := Increaser[8] + 1;

  if Increaser[8] > L then
  begin
    Increaser[8] := 1;
    Increaser[7] := …

我希望这个要求是合法的.我正在为工程师学习python的编程课程,所以我对这个行业有点新意.无论如何,在我的作业中,我被要求编写一个函数,接收两个字符串,并检查一个是另一个的(置换/ Anagrm).(这意味着如果它们的每个字母都有完全相同的字母和相同数量的外观)

我在搜索时发现了一些很棒的代码,但我仍然没有弄清楚我的代码有什么问题(对我来说,了解我的学习过程很重要).

我们有一个测试文件,假设检查我们的功能,它给了我这个错误:

Traceback (most recent call last):
File "C:\Users\Or\Desktop\?????\4\hw4\123456789_a4.py", line 110, in <module>
test_hw4()
File "C:\Users\Or\Desktop\?????\4\hw4\123456789_a4.py", line 97, in test_hw4
test(is_anagram('Tom Marvolo Riddle','I Am Lord Voldemort'), True)
File "C:\Users\Or\Desktop\?????\4\hw4\123456789_a4.py", line 31, in is_anagram
s2_list.sort()
NameError: global name 's2_list' is not defined

这是我的代码:

def is_anagram(string1, string2):    

    string1 = string1.lower() #turns Capital letter to small ones
    string2 = string2.lower()
    string1 = string1.replace(" ","") #turns the words inside the string to one word
    string2 = string2.replace(" ","")

    if len(string1)!= len(string2):
        return …

我写了一个anagram求解算法,但是没有用.

for word in wordlist: #Checking for equal length
    if sorted(word.replace("\n", "")) == sorted(anagram):
        possible.append(word)

我需要使用len(word) - 1来取走\n.

我正在从"破解编码面试"一书中做一些练习题,并希望让一些人查看我的代码以查找错误和优化.任何反馈将不胜感激.

问题:编写一个方法来判断两个字符串是否是字谜.

/*
Time complexity: O(n^2)
Space complexity: O(n)
*/
bool IsAnagram(std::string str1, std::string str2)
{
    if(str1.length() != str2.length())
        return false;
    for(int i = 0; i < str1.length();i++)
    {
        bool found = false;
        int j = 0;
        while(!found && j < str2.length())
        {
            if(str1[i] == str2[j])
            {
                found = true;
                str2[j] = NULL;
            }
            j++;
        }
        if(!found)
            return false;
    }
    return true;
}

这个函数的输入是两个字符串,目的是判断这两个字符串是否是字谜.例如,"qwerty"和"qetyrw"是anagram,这意味着重新排列第一个字符串中的字符可以得到第二个字符串.并且不要求区分大小写."qwerty"和"QWerTY"也是字谜.我只是混淆了我的功能,什么也没有返回.我的功能如下:

def is_anagram(string_a,string_b):
    """returns True if the strings are anagrams of each other

    str, list -> boolean"""
    new_a=string_a.lower()
    new_b=string_b.lower()
    i=0
    if len(string_a)!=len(string_b):
        return False
    else:
        while i<=len(new_a)-1:
            if new_a[i] in new_b:
                list(new_b).remove(new_a[i])
            i=i+1
            break
        if len(list(new_b))==0:
            return True
        else:
            return False