D'accord, j'ai donc une méthode qui doit prendre dans un tableau plein de ints, puis vérifiez-le par rapport à son miroir pour voir à quoi correspond le plus grand miroir. Par exemple, j'ai un tableau [7, 1, 2, 9, 7, 2, 1], le plus grand tableau auquel il peut correspondre est 2, étant mis en correspondance à [1, 2].
À l'heure actuelle, je l'ai divisé en 3 méthodes. Un qui accepte le tableau, un autre qui inverse le tableau et le renvoie (mirrorArray). et le 3ème comptant la taille du tableau qui correspond (groupCount). Voici ce que j'ai jusqu'à présent:
public int maxMirror(int[] nums) {
int[] revArray = mirrorArray(nums);
return groupCount(nums, revArray);
}
private int[] mirrorArray(int[] nums) {
int[] newArray = new int[nums.length];
for (int i = nums.length-1, j = 0; i >= 0; i--, j++) {
newArray[j] = nums[i];
}
return newArray;
}
private int groupCount(int[] aFor, int[] bRev) {
int maxCount = 0;
int groupSize = 1;
//get aFor value
for (int i = 0; i < aFor.length; i++) {
int[] tempA = Arrays.copyOfRange(aFor, 0, groupSize);
//loop through bRev and check for matches
for (int j = 0; j < bRev.length; j++) {
int[] tempB = Arrays.copyOfRange(bRev, j, j+groupSize);
if (Arrays.equals(tempA, tempB)) {
maxCount = tempA.length;
}
}
groupSize++;
}
return maxCount;
}
Il échoue quelque part dans la 3ème méthode (retourne un 1 au lieu d'un 2) et je suis perplexe pourquoi les boucles que je n'ai pas retournées ce que je veux. Toute aide serait grandement appréciée.
Réponses:
5 pour la réponse № 1D'accord, j'étais curieux ...
Voici le problème:
int[] tempA = Arrays.copyOfRange(aFor, 0, groupSize);
Vous comparez toujours tempB au premier sous-tableau de longueur groupSize de aFor. Remplacez cette ligne par
int[] tempA = Arrays.copyOfRange(aFor, i, i + groupSize);
et ça devrait marcher.
MODIFIER Gardez les cas d'échec venir .. Semble un problème avec l'emplacement d'incrémentation de groupSize
while (groupSize < aFor.length) {
//get aFor value
for (int i = 0; i < aFor.length; i++) {
int[] tempA = Arrays.copyOfRange(aFor, i, i + groupSize);
//loop through bRev and check for matches
for (int j = 0; j < bRev.length; j++) {
int[] tempB = Arrays.copyOfRange(bRev, j, j+groupSize);
if (Arrays.equals(tempA, tempB)) {
maxCount = groupSize;
}
}
}
groupSize++;
}
Ce n'est pas le plus efficace, et ce pourrait être un exercice amusant à optimiser. Une approche de départ serait de démarrer groupSize at aFor.length et décrémenter. Aussitôt que maxCount est attribué, vous pouvez revenir tôt.
Modifier 2
int groupSize = aFor.length;
while (groupSize >= 0) {
//get aFor value
for (int i = 0; i <= aFor.length - groupSize; i++) { // note this change
int[] tempA = Arrays.copyOfRange(aFor, i, i + groupSize);
//loop through bRev and check for matches
for (int j = 0; j <= bRev.length - groupSize; j++) { // note this change
int[] tempB = Arrays.copyOfRange(bRev, j, j+groupSize);
if (Arrays.equals(tempA, tempB)) {
return groupSize;
}
}
}
groupSize--;
}
return 1;
}
Ce qui se passait, c'est que les tableaux.copyOfRange remplissait des nombres hors limites avec des zéros. J'ai également ajouté l'option de sortie anticipée que j'ai mentionnée plus tôt. Il y a probablement plus d'optimisations qui peuvent être faites
2 pour la réponse № 2
Votre logique entre tempA et tempB a un problème:
Dans chaque itération de la première boucle (orignal), vous choisissez 0-> groupSize ensemble de valeurs et comparez exactement avec toutes les séquences de tailles similaires dans le tableau inverse, donc la première itération est
Orignal array (aFor) : [7, 1, 2, 9, 7, 2, 1]
Reverse array (bRev) : [1, 2, 7, 9, 2, 1, 7]
Iteration-1:
tempA=> [7]
tempB=> [1],[2],[7]...
maxCount = 1; (in first iteration, multiple single value matche)
Iteration-2:
tempA=> [7,1]
tempB=> [1,2],[2,7]...
maxCount = 1; (no match of [7,1], maxCount continues from first iteration)
De même, dans toutes les autres itérations, aucune correspondance de séquence ne sera trouvée en raison de votre jeu de données d'entrée.
Maintenant, si vous changez votre entrée en [7, 1, 2, 9, 7, 1, 7], maxCount serait 2
Et pour l'entrée [7, 1, 2, 9, 2, 1, 7], maxCount est 7
Mais cela est dû à la nature de votre saisie et de votre problème dans votre code.
Le problème dans le code est la boucle externe (aFor loop) doesn "t obtient évalué pour chaque séquenceset ie dans itération-2 vous ne cochez que le premier set de taille 2 ([7,1]) et les autres sets ([1,2], [2,9] ..) ne sont jamais comparés donc vous obtenez toujours maxCount = 1 due au match précédent.
1 pour la réponse № 3
Je sais que cela peut sembler sans rapport avec la question, mais j'ai essayé de faire les tests sans créer de nouveaux tableaux (comparaison sur place), j'espère que cela aide:
public static int getMaxMirrorSub(int[] arr) {
for (int eqLength = arr.length; eqLength >= 0; eqLength--) {
for (int arrayStart = 0; arrayStart < arr.length; arrayStart++) {
for (int mirrorStart = arr.length - 1; mirrorStart >= eqLength - 1; mirrorStart--) {
int indexArray = arrayStart, indexMirror = mirrorStart;
while(indexArray < arr.length
&& indexMirror >= 0
&& arr[indexArray] == arr[indexMirror]){
indexArray++; indexMirror--;
}
if (indexArray - arrayStart == eqLength)
return eqLength;
}
}
}
return 0;
}
0 pour la réponse № 4
public int maxMirror(int[] nums) {
int[] reverse = null;
int max = 0;
for(int i = 0; i < nums.length; i++) {
for(int k = 0; k < nums.length; k++) {
if(i > k) {
} else {
reverse = reverseSection(nums, i, k);
if(searchFor(reverse, nums)) {
if(reverse.length > max) { max = reverse.length; }
}
}
}
}
return max;
}
public int[] reverseSection(int[] nums, int begin, int end) {
int[] nArray = new int[end - begin + 1];
int numbs = end - begin;
for(int i = begin; i <= end; i++) {
nArray[numbs] = nums[i];
numbs--;
}
return nArray;
}
public boolean searchFor(int[] reverse, int[] nums) {
int index = 0;
boolean check = false;
for(int i = 0; i < nums.length; i++) {
if(nums[i] == reverse[index]) {
index++;
if(index >= reverse.length) {
return true;
}
} else {
index = 0;
}
}
return false;
}