Porovnanie poľa so zrkadlom - java, polia, slučky

Dobre, takže mám metódu, ktorú je potrebné prijať v poli plnom ints, potom ho skontrolujte oproti jeho zrkadlu a zistite, s čím najväčším zrkadlom je, že sa zhoduje. Takže napríklad mám pole [7, 1, 2, 9, 7, 2, 1], najväčšie pole, ktoré sa môže zhodovať, je 2, ktoré sa zhoduje [1, 2].

Práve som to rozdelil na 3 metódy. Jeden, ktorý prijíma pole, druhý, ktorý ruší a vracia pole (mirrorArray). a tretí je počítanie veľkosti poľa, ktoré sa zhoduje (groupCount). Tu je to, čo mám zatiaľ:

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;
}

Niekde zlyháva v tretej metóde (vracia 1 namiesto 2) a pusťoval som sa, prečo slučky, ktoré nevrátim, čo chcem. Akákoľvek pomoc by bola veľmi ocenená.

odpovede:

5 pre odpoveď č. 1

Dobre, bol som zvedavý ...

Tu je problém:

int[] tempA = Arrays.copyOfRange(aFor, 0, groupSize);

Vždy porovnávate tempB s prvým čiastkovým poľom dĺžky groupSize alebo. Zmeňte tento riadok na

int[] tempA = Arrays.copyOfRange(aFor, i, i + groupSize);

a malo by to fungovať.

UPRAVIŤ Udržiavajte prípady zlyhania. Zdá sa, že je problém s umiestnením prírastku 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++;
}

Toto nie je najúčinnejšie a optimalizácia môže byť zábavné cvičenie. Jedným z východiskových prístupov by bolo založenie veľkosti skupiny na aFor.length a zníženie. Tak skoro ako maxCount je priradené, môžete sa čoskoro vrátiť.

Upraviť 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;
}

Čo sa stalo, je to, že Arrays.copyOfRange vyplňoval čísla z hraníc nulami. Pridal som aj možnosť predčasného ukončenia, o ktorej som už hovoril. Pravdepodobne existuje viac optimalizácií

---

2 pre odpoveď č. 2

Vaša logika medzi tempA a tempB má problém:

V každej iterácii prvej slučky (orignal) vyberiete množinu hodnôt 0-> groupSize a porovnávate presne so všetkými podobnými sekvenciami veľkostí v opačnom poli, takže prvá iterácia je

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)

Podobne vo všetkých ostatných iteráciách by sa kvôli vašej vstupnej množine údajov nenašla zhoda sekvencií.

Ak teraz zmeníte svoj vstup na [7, 1, 2, 9, 7, 1, 7], maxCount by bol 2

A pre vstup [7, 1, 2, 9, 2, 1, 7], maxCount je 7

Je to však kvôli povahe vášho vstupu a vydania vo vašom kóde.

Problém v kóde je vonkajšia slučka (aFor slučka) nie je vyhodnotená pre každú sekvenciuset tj v iterácii-2 začiarknete iba prvú množinu veľkosti 2 ([7,1]) a ďalšie sady ([1,2], [2,9] ..) sa nikdy neporovnávajú, takže vždy dostanete maxCount = 1 kvôli do predchádzajúceho zápasu.

---

1 pre odpoveď č. 3

Viem, že by sa to na otázku mohlo zdať irelevantné, ale pokúsil som sa urobiť testy bez vytvorenia nových polí (porovnávanie na mieste), dúfam, že to pomôže:

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 pre odpoveď č. 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;
}

---