Question

对于作业，我被要求在列表中找到最大的字谜组。我相信我必须在另一个循环中有一个累积循环来跟踪最大数量的项目。问题是我不知道如何计算每个字谜的数量。我已经能够根据他们的字谜将数组分组。所以从索引1-3是一个字谜，4-10是另一个，等等。我如何搜索并计算每个字谜中有多少？然后将每一个与之前的计数进行比较。

代码示例：

public static String[] getLargestAnagramGroup(String[] inputArray) {

    ArrayList<String> largestGroupArrayList = new ArrayList<String>();

    if (inputArray.length == 0 || inputArray == null) {
        return new String[0];
    }

    insertionSort(inputArray, new AnagramComparator());

    String[] largestGroupArray = new String[largestGroupArrayList.size()];
    largestGroupArrayList.toArray(inputArray);
    System.out.println(largestGroupArray);
    return largestGroupArray;
}

更新：这就是解决问题的方法。有更有效的方法吗？

public static String[] getLargestAnagramGroup(String[] inputArray) {

    int numberOfAnagrams = 0;
    int temporary = 1;
    int position = -1;
    int index = 0;

    if (inputArray == null) {
        return new String[0];
    }
    insertionSort(inputArray, new AnagramComparator());
    for (index = 0; index < inputArray.length - 1; index++) {
        if (areAnagrams(inputArray[index], inputArray[index + 1])) {
            temporary++;
        } else {
            if (temporary > numberOfAnagrams) {
                numberOfAnagrams = temporary;
                position = index;
                temporary = 1;
            } else if (temporary < numberOfAnagrams) {
                temporary = 1;
            }
        }
    }
    if (temporary > numberOfAnagrams) {
        position = index;
        numberOfAnagrams = temporary;
    }
    String[] largestArray = new String[numberOfAnagrams];
    for (int startIndex = position - numberOfAnagrams + 1, i = 0; startIndex <= position; startIndex++, i++) {
        largestArray[i] = inputArray[startIndex];
    }

    return largestArray;
}

Answer 1

这是一段可以帮助你的代码。

public class AnagramTest {
public static void main(String[] args) {
    String[] input = {"test", "ttes", "abcd", "dcba", "dbac"};

    for (String string : getLargestAnagramGroup(input)) {
        System.out.println(string);
    }
}

/**
 * Gives an array of Strings which are anagrams and has the highest occurrence. 
 * 
 * @param inputArray
 * @return
 */
public static String[] getLargestAnagramGroup(String[] inputArray) {
    // Creating a linked hash map to maintain the order
    Map<String, List<String>> map = new LinkedHashMap<String, List<String>>();

    for (String string : inputArray) {
        char[] charArray = string.toCharArray();
        Arrays.sort(charArray);
        String sortedStr = new String(charArray);
        List<String> anagrams = map.get(sortedStr);
        if (anagrams == null) {
            anagrams = new ArrayList<String>();
        }

        anagrams.add(string);

        map.put(sortedStr, anagrams);
    }

    Set<Entry<String, List<String>>> entrySet = map.entrySet();
    List<String> l = new ArrayList<String>();
    int highestAnagrams = -1;
    for (Entry<String, List<String>> entry : entrySet) {
        List<String> value = entry.getValue();
        if (value.size() > highestAnagrams) {
            highestAnagrams = value.size();
            l = value;
        }
    }

    return l.toArray(new String[l.size()]);
}
}

这个想法是先找到anangrams。我正在使用对字符串的字符数组进行排序并使用LinkedhashMap。

然后我将原始字符串存储在列表中，该字符串可用于打印或重复使用。

你必须继续计算anagram发生的次数，并且该值可用于解决你的问题

Answer 2

这是我在C＃中的解决方案。

  constructor(private loc: Location, private router: Router, private viewportScroller: ViewportScroller) {
this.router.events.pipe(filter(e => e instanceof Scroll)).subscribe((e: any) => {
  console.log(e);

  // this is fix for dynamic generated(loaded..?) content
  setTimeout(() => {
    if (e.position) {
      this.viewportScroller.scrollToPosition(e.position);
    } else if (e.anchor) {
      this.viewportScroller.scrollToAnchor(e.anchor);
    } else {
      this.viewportScroller.scrollToPosition([0, 0]);
    }
  });
});
}

获得阵列中最大的字谜组

2 个答案: