Array in reverse order......?

ok....i have to put an array in reverse order right...

heres my code....its really complicated...and i know there has to be an easier way.

for(int i = 0; i <B.length;i++) { int First = B[0]; int Last = B[B.length]; int A = First; First = Last; Last = A; First ++; Last--; If(B/2 == A) { B[B/2] = A; break; if ((B/2)-1 = A) { A = First; First = Last; Last = A; break; } } }

now even if this is correct, which i doubt.... the compiler is giving me an error at the first { of the first if statement...

thx for the help again! lol

you don't have an "if" statement. you have an "If" statement.

Here's my suggestion:

Create a new empty array for the reversed data. Then iterate through the original array from "front to back," assigning values to the reverse array from "back to front."

If you think carefully about how the Nth element in the original array relates to the Nth from the last element in the reversed array, this can be done in a single line within a for loop.

PS: Did you change your display name? To maintain the friendly atmosphere here at the ranch, we like folks to use real (or at least real-looking) names. Thanks!

Do you really need an array? That is, is this homework? I suspect so, in which case ignore the remainder of this post.

Arrays contain a devastational abstraction leak in more than one place. There is one that you are observing at the moment - that to represent the elements of an ordered sequence in some other way requires an element copy of that sequence. An array exposes three operations (getElementAtIndex, setElementAtIndex, getElementsLength) all of which are bound (symbiotic operations on contract) - which implies other abstraction leaks - but they also bind you to an in-memory representation of the data. For example, a byte[] does more than "hold bytes" it "holds bytes in memory". This is the abstraction leak that I refer to.

If you want your array to look different, you need to change the "in-memory" representation - by way of an element copy. Another example is where you want to append to an array - since elements are fixed in-memory, you are forced to reallocate memory (new array) and perform an element copy. I refer back to the three operations of arrays - if you could simply create an appropriate abstraction (such as an interface (referred to as interface Array)) that represents an array, then write another interface that, for example, "appends" or "reverses" (referred to as OperationArray) and returns an Array that represents your operation, then no element copy is required.

Let's look at an example - for simplicity, we will remove the setElementsAtIndex operation of the Array interface:

interface Array<E> { E getElementAtIndex(int index) throws IndexOutOfBoundsException; int getLength(); } interface ReverseArray { <E> Array<E> reverse(Array<E> a); }

You could easily implement the ReverseArray method without requiring an element copy - let's look at one (not the nicest) way of doing it:

final class ReverseArrayImpl implements ReverseArray { public <E> Array<E> reverse(Array<E> a) { return new Array<E>() { public E getElementAtIndex(int index) throws IndexOutOfBoundsException { if(index < 0 || index >= a.getLength()) { throw new IndexOutOfBoundsException(String.valueOf(index)); } else { return a.getElementAtIndex(a.getLength() - 1 - index); } } public int getLength() { return a.getLength(); } }

So my question comes back to: is it really an array that you want? ...or do you want a structure that has a tighter level of encapsulation (clearly, arrays are flawed - this reason is one of many)? It all comes down to requirements analysis - do you want "an ordered sequence of elements"? ...or "an ordered sequence of elements that are bound to memory"? There are some very odd corner cases where the latter is a valid requirement, but these fall outside of my definition of "software" - which leads me to the conclusion that using arrays for "software" implies a forced requirement defect (excessive contract and excessive requirements implementation). I observe this commonality for many of the things that most developers take for granted, but I use it to my advantage by allowing me to make an informed decision about the correct approach to take - is this what you need for your case?

ContractualJ provides an alternative to arrays (and collections), which I believe are inherently flawed such that they cause great pain due to constantly conceding to their intrinsic requirement defects. The above example code has been implemented more extensively in the net.tmorris.adt.sequence package and has been tested thoroughly (100% code coverage) - in fact, the code above may not even compile - I didn't try it.

I hope this rants helps.

I suck at both English and Java, but I will try to explain how I think I would do. Begin with swapping the first and the last element, then the second and the "last but one" (last-1), and so on, until you reach an index which already has been involved in this swapping process. So, maybe a for loop which iterates until it reaches B.length/2.

Yeah that is a lot of code for a simple task. Using another array is kind of cheating since the point of these sorts of assignments are manipulating arrays, which is a requirement to learning how sorting algorithms work. Arrays are rarely used, but are a good teaching tool, and help you learn things like sorting, which may not be a requirement to use an API, but learning syntax and some API stuff doesn't make you a professional.

simple code for an array of ints:
int lElement = array.length-1, first, last, swap; for(int i =0 i < array.length/2;i++) { if(i==lElement) break; //avoids self swapping when array is even length, not strictly necessary, but good first = array[i]; last = array[lastElement]; swap = first;//could use last first = last; last = swap; lElement--; }

This is off the top of my head but should be close. Buyer beware.

Originally posted by Rusty Shackleford:
Yeah that is a lot of code for a simple task.

The workaround code is verbose ala Java and its inherent defects. It's much much less code in any case:
Given Array<E> a,
a = new ReverseArrayImpl().reverse(a);

The point is learning how to write the reverse method in the API. Using an API is all well and good, but there is a rather large difference between a Java Programmer(one who knows the language and the associated API's) and a complete programmer(Someone who finds API's useful but doesn't actually need them if push came to shove).

ok ive been working on it lol, i guess im retarded or something, it keeps f'n printing the same array twice....heres the code


import java.util.Scanner; public class Assignment1{ public static void main (String[]args){ Scanner scan = new Scanner(System.in); int Count=0; System.out.print("Enter an integer: "); int Num = scan.nextInt(); //Count initialized to 1; int[]B = new int[Num]; System.out.println("Now enter " + Num+" numbers..."); System.out.println(""); for(int i=0;i<B.length;i++) { Count++; System.out.print("Enter the "+Count+" number: "); int num = scan.nextInt(); B[i] = num; } System.out.println("The Array is..."); System.out.println(""); for(int i = 0; i<B.length; i++) { System.out.println(B[i]); } System.out.println("The array in reverse is"); for(int i =0; i <B.length;i++) { int first = B[i]; int last = B[B.length-1]; int swap = first; first = last; last = swap; last --; if (i== (B.length-1)/2) {break;} System.out.println(B[i]); } } }

what the heck is wrong with it....im going quite insane over this..

i tried that reverse code for java, and it said that didnt exist, lol...

//Get the first and last values from array and assign to variables...
int first = B[ i ];
int last = B[B.length-1];

//Exchange variable values...
int swap = first;
first = last;
last = swap;

//So far, so good, but the array itself hasn't changed -- only the variables "first" and "last."

//And now what's happening here?
last --;
//Did you really want to decrement the value of last?
[ January 28, 2006: Message edited by: marc weber ]

The first problem is in your logic in the for loop used to reverse the array.
for(int i =0; i <B.length;i++) { int first = B[i]; int last = B[B.length-1]; int swap = first; first = last; last = swap; last --; if (i== (B.length-1)/2) break; System.out.println(B[i]); }
You assign to the variable first the value of B[i], then you assign to the variable last the value B[B.length - 1], then all you are doing is reassigning these variables to different values, but B[i], and B[B.length -1] are staying the same, you're not doing anything to the elements of the array. Not to mention decrementing the variable last (last --) isn't helping you get anywhere because at the beginning of the loop you reassign the varaible to be the last element in the array over and over again. You should rewrite this loop altoghether because as it stands now, its not going to get you where you want to go.

for(int i = 0; i<B.length;i++) { int A = B[i]; int Dec = B.length; int C= B[Dec-1]; int swap = A; A = C; C= swap; B[i] = A; B[B.length-1] = C; }

ok, on this, how do i decrement from the bottom up??....i tried....

Dec -=1; but say i put in four ints, after the first loop, it keeps the variable C at B[2] util i = Dec;....

lol im almost there, plz help me out thx..

Why don't you try incrementing one variable in the loop and decrementing another at the same time so they meet in the middle?

for(int i = 0, j = arr.length - 1; i < j; i++, j--) { int temp = arr[j]; arr[j] = arr[i]; arr[i] = temp; }
[ January 29, 2006: Message edited by: Craig Tyler ]

omg...i had no idea you could do that!!!...

your a genius guy....and i love you mucho

thank you sooo much

Another solution would be to have a single counter (say i) and calculate the other index based on the array's length and the first counter.

Layne

Originally posted by Layne Lund:
Another solution would be to have a single counter (say i) and calculate the other index based on the array's length and the first counter.

That's what I was trying to suggest. But who listens to a n00b?
[ January 30, 2006: Message edited by: Karl Svensson ]

Originally posted by Karl Svensson:


That's what I was trying to suggest. But who listens to a n00b?

[ January 30, 2006: Message edited by: Karl Svensson ]

Or perhaps great minds think alike.

Sorry for missing your earlier post. Of course, I hope that stating the same thing in a different way might help the OP understand it more clearly.

Layne