Array, kleine foutje

[jimowns]

Hey,

Ik ben een klein oefeingentje aan het maken met arrays.

Oefening:
- Een rij van 100 gehele getallen wordt ingelezen. Verschuif de inhoud van de rij 3 plaats naar voor, gebruik geen 2de array om alles te kopieren.

probleem:
wanneer ik het compile dan krijg ik dit als output de getallen afdrukt naar wens, maar op laatste drukt hij de laatste 3 getallen dubbel af. normaal moet ik krijgen 0 1 2 maar ik krijg 0 1 2 0 1 2.

output:
3
4
5
6
7
8
9
10
11
....
97
98
99
0
1
2
0
1
2

Hier is mijn code:
[CPP]
int[] array = new int[100];
int teller = 0;

// opvullen van elementen in de array:: 0,1,2,3,4,5,6,....,97,98,99
for (int i = 0; i < 100; i++)
array = i;
// De eerste 3 elementen als laatste inbrengen
for (int j = 2; j >= 0; j--)
{
array[(array.Length - 1) - j] = array[teller];
teller++;
}

// array ieders 3plaatsen naar voor.
for (int i = 3; i < 100; i++)
array[i - 3] = array;

foreach(int drukAf in array)
Console.WriteLine(drukAf);
[/CPP]

ik heb een code gemaakt dat het correct uitvoerd, maar dit mocht niet van de leerkracht.
[CPP]
int[] array = new int[100];

for (int i = 0; i < 100; i++)
array = int.Parse(Console.ReadLine());

int temp0 = array[0];
int temp1 = array[1];
int temp2 = array[2];

for (int i = 0; i < 100; i++)
array[i - 3] = array;

array[97] = temp2;
array[98] = temp1;
array[99] = temp0;

foreach(int drukAf in array)
Console.WriteLine(drukAf);
[/CPP]

Met vriendelijke groeten, Jim

 

[Westerland]

Wat zijn dan de niet vertelde eisen van de leerkracht ? het lijkt mij een vrij lastige opdracht op elementen in een array te verplaatsen zonder tijdelijke opslag.
Hoe dan ook als je 2 dingen gaat wisselen van plaats, dan gaat er 1 van de 2 waardes verloren. in je bovenste voorbeeld zijn ook 97 98 99 verloren gegeaan (en die extra 0,1,2 die er bij gekomen zijn).

 

[jimowns]

We mogen geen gebruik maken van een intellisence (want we moeten de code gemakkelijk overcopieren naar andere talen toe) , we mogen geen 2de array nemen, de waardes niet opslaan in datatypes.
De rest is wel toegestaan, het is echt een lastig oefening, normaal heb ik nooit last gehad met programmeren, maar bij deze oefening precies wel

sorry van daarboven dat de waarder 97 98 99 verlore zijn want heb ze er perongeluk bij getekend bij de output.


Met vriendelijke groeten,
Jim

 

[Westerland]

en het groter maken van de array dan nodig ? (101 ipv 100) dan heb je namelijk tijdelijke opslag en voldoe je evengoed aan de eisen ?

 

[jimowns]

ik weet het niet of dat mag, normaal gezien wel, want dat heeft ze natuurlijk niet erbij gezegd.

ik zal het in januari wel tehoren krijgen .

Dankwel Westerland

Code:
[CPP]
// array van 103 elementen, waarvan 3 reserve staan voor opslag van de eerste 3 elementen
// om vanachter bij te voegen zonder 99,98,97 waarde te verliezen.
int[] array = new int[103];
int teller = 0;

try
{
// 100 elementen worden ingelezen, met de waarde van i
for (int i = 0; i < 100; i++)
array = i;
// de eerste 3 elementen worden vanachter geplaatst
for (int j = 2; j >= 0; j--)
{
array[(array.Length - 1) - j] = array[teller];
teller++;
}
// elk element 3plaatsen naar voor
for (int i = 3; i < 100; i++)
array[i - 3] = array;
// Output
foreach (int drukAf in array)
Console.WriteLine(drukAf);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
throw new Exception("Foutieve invoer");
}
[/CPP]




Met vriendelijke groeten,
Jim

 

[Westerland]

Hoop voor je dat dit wel goedgekeurd wordt dan anders zou ik het ook niet weten ^^

 

[CoD_NL]

Je kan het 'XOR swap algoritme' gebruiken om de waardes te verwisselen zonder tijdelijke variabelen. Je code wordt dan iets als:

[cpp]
int[] arr = Enumerable.Range(0, 100).ToArray<int>();
int len = arr.Length;
int rowCount = 3;
int swapStart = len - rowCount;

for (int i = 0; i < len - rowCount; i++)
{
int loc = swapStart++ % len;

arr ^= arr[loc];
arr[loc] ^= arr;
arr ^= arr[loc];
}
[/cpp]

 

[Westerland]

dat is wel een hele mooie manier om het op te lossen ^^

 

[CoD_NL]

In de code ben ik wel vergeten om eerst te controleren of arr en arr[loc] niet aan elkaar gelijk zijn. Indien ze wel gelijk zijn worden alle bits immers gewoon op 0 gezet.