We use cookies to ensure you have the best browsing experience on our website. Please read our cookie policy for more information about how we use cookies.
not sure why people just downvote an honest question instead of responding with an answer - everyone is here to learn.
"As a rule of thumb, C++ pointers should only refer to objects allocated wth new."
you can read here for more explanation:
Section A3.8. Pointers
http://www.horstmann.com/ccj2/ccjapp3.html
So basically, the 'new' operator will return a address (what a pointer stores) to the heap-allocated contiguous memory block, a.k.a. 'array' of ints, thus ".... new int[n]", where n = 10 would return the beginning address of the contiguous memory block(s).
(which in total would usually be 10 * 4 bytes(sizeof(int)) )
The reason you would use a heap-allocated block of contiguous memory a.k.a. 'array', is because you do NOT know the exact number representing the size of the array at COMPILE TIME.
So basically std::cin >> n; int* A = new int[n]; -> here 'n' will be known at RUNTIME, when the user interacts with the program and enters some number.
BUT! Performing calculations also based on non-const/already known values and using the result as the array size will not work either...
Depending on the compiler, but in GCC using g++, try doing all this with a stack allocated array - it MIGHT let you, and then try it with the -pedantic-errors flag and the compiler WON'T let you do such stuff...
TL;DR
So basically when you DO NOT KNOW the size of an array beforehand (like a hard-coded value '10' for example, or a const int or so) - use heap-allocated arrays!
" ...AND N); is used to stop when N arrives at value 0, he decreases the N value for each iteration, so basically is the stop condition for the while loop cause the AND operator with a 0 value returns 0, it was pretty ingenious. Also he deletes the pointer to avoid memory leaks, very important.
In your solution
You havent accepted input to you array arr[]
And neither have you printed the output (reverse order)
All you have done is declared the size of the array.
(jorgechiquinv) Yep! Same here (excpet without the whiles, that looks clean, I like it). I threw a couple of runtime exceptions to handle the constraints on N and Ai. I also had N as a reference to a variable named arraySize just for fun :)
You shouldn't use arrays like that. In fact, a is initialized with the first value of n what is garbage, something like 39281233, because is initialized in compile time not execution time, for dinamic size you must use pointers and the keyword new or vector from std.
here why n is initialise first?(cin >> n;) and then a[n] is declared...if we do the otherway round(that is declaring a[n] first and then initialising cin >> n;) the compiler is showing error ...why is it soo???plz explain
Its the termination condition for the whilr loop. For every number greater than or equal to 1 "and" treats its as 1, so when it reaches 0 the "and" will give the output 0 which will terminate the while loop.
@slanger125 You also want to make sure use delete[] A and not just delete A
delete[] A frees the entire array from memory
delete A will just free the pointer and leave the array in memory creating a memory leak.
First of all thanks for sharing your solution. I really appreciate it. But i found a bug. There is no exit condition for the first while loop. It will keep writing in the unauthorised memory and crash. It should be like this.
The firts while loop finishes when cin reads EOF, i.e. when cin finishes to read the whole input stream.
Another way is using scanf from C, it returns the number of input data assigned or the defined macro EOF (-1) when there is nothing less to read, so you can do the next one:
For those of you who are wondering how the 1st while loop will terminate , it will terminate only if you type 'false' or 'eof' . It is a fancy way of solving this question but it is not optimised way because it takes a hell lot of machine cycles and instructions .
take a look
Despite the code posted by JChiquin passed all of the test cases, the Visual Studio console did not give the same output until I modified the first while loop as:
Arrays Introduction
You are viewing a single comment's thread. Return to all comments →
My solution without using vector:
wow. thats pretty smart can you tell me where you learned it or walk me through your though proccess for
thats for dynamically allocating memory ie it adjusts its size according to the input during runtime
how different is it from the "malloc"?
malloc() is a function in C, and New is for C++
what is it mean by *A=new int[N]? why new keyword used? and what will happen by this expression?
not sure why people just downvote an honest question instead of responding with an answer - everyone is here to learn.
"As a rule of thumb, C++ pointers should only refer to objects allocated wth new." you can read here for more explanation: Section A3.8. Pointers http://www.horstmann.com/ccj2/ccjapp3.html
So basically, the 'new' operator will return a address (what a pointer stores) to the heap-allocated contiguous memory block, a.k.a. 'array' of ints, thus ".... new int[n]", where n = 10 would return the beginning address of the contiguous memory block(s). (which in total would usually be 10 * 4 bytes(sizeof(int)) )
The reason you would use a heap-allocated block of contiguous memory a.k.a. 'array', is because you do NOT know the exact number representing the size of the array at COMPILE TIME. So basically
std::cin >> n; int* A = new int[n];-> here 'n' will be known at RUNTIME, when the user interacts with the program and enters some number. BUT! Performing calculations also based on non-const/already known values and using the result as the array size will not work either... Depending on the compiler, but in GCC using g++, try doing all this with a stack allocated array - it MIGHT let you, and then try it with the-pedantic-errorsflag and the compiler WON'T let you do such stuff...TL;DR So basically when you DO NOT KNOW the size of an array beforehand (like a hard-coded value '10' for example, or a const int or so) - use heap-allocated arrays!
Can you explain me this step: " while(cout<
It means that while the statement in the parenthesis is true, keep executing the statements inside the while loop.
what
AND N
do?
" ...AND N); is used to stop when N arrives at value 0, he decreases the N value for each iteration, so basically is the stop condition for the while loop cause the AND operator with a 0 value returns 0, it was pretty ingenious. Also he deletes the pointer to avoid memory leaks, very important.
Heres another solution:
In your solution You havent accepted input to you array arr[] And neither have you printed the output (reverse order) All you have done is declared the size of the array.
array size is also wrong
(jorgechiquinv) Yep! Same here (excpet without the whiles, that looks clean, I like it). I threw a couple of runtime exceptions to handle the constraints on N and Ai. I also had N as a reference to a variable named arraySize just for fun :)
I have a doubt .why you use the CONST???????
to not able the program change value of n further
Why did you add '&& N' in 'while(cout<
That's because only with
coutthe loop will never end, so I add other constraints, whenNwill be 0 the loop will end (N is like an inverse iterator).Sorry my english
thank you ^^
You shouldn't use arrays like that. In fact,
ais initialized with the first value ofnwhat is garbage, something like39281233, because is initialized in compile time not execution time, for dinamic size you must use pointers and the keywordneworvectorfromstd.Why does my comment have negative votes?
Interesting the:
part of the code worked for me. Should this be tested for my hackerrank and marked as incorrect when used to commplete this challenge?
a[i-1]
can you tell me how it is working?
how this line is working i am not able to understand for (; i >0; i--) cout << a[i- 1] <<" ";
while (i >0) cout << a[--i] <<" ";
int n, i = 0; cin >> n; int a[n];
thanks, Jorge, that worked for me
what 's "and" in while mean?
Its the termination condition for the whilr loop. For every number greater than or equal to 1 "and" treats its as 1, so when it reaches 0 the "and" will give the output 0 which will terminate the while loop.
while(cout<
delete[] A; what's this statement doing?
It is used to free the memory assigned to A because its no longer needed.
@slanger125 You also want to make sure use delete[] A and not just delete A delete[] A frees the entire array from memory delete A will just free the pointer and leave the array in memory creating a memory leak.
First of all thanks for sharing your solution. I really appreciate it. But i found a bug. There is no exit condition for the first while loop. It will keep writing in the unauthorised memory and crash. It should be like this.
The firts while loop finishes when
cinreads EOF, i.e. whencinfinishes to read the whole input stream.Another way is using
scanffrom C, it returns the number of input data assigned or the definedmacro EOF(-1) when there is nothing less to read, so you can do the next one:Those are the way of reading in c++ the whole input, there is challenges where the input size is not given
Sorry my english.
yes!!helped a lot
What exactly is delete[] A ??
it is to delete the dynamically allocated memory from heap.
there should be one more condition in the first while loop
otherwise, will be an infinit loop. thumps up, nice approach
See the comment above, it already has been explained
can u pls explain me both the while statements, i am not getting it.
Can you explain, how did the array get reversed?
actually Array didn't get reversed we are printing in reverse order (i.e from last index to first).
Hi, the snippet is not working in codeblocks. Is there any particular reason behind it?
P.s - I am new to this.
Truly elegant. Shouldn't we free A or set it to NULL as well?
You have to free A (
delete[] A), if only set it to NULL you'll lose the block of memory and cause a leak memory.Sorry my english.
why we must cout N
For those of you who are wondering how the 1st while loop will terminate , it will terminate only if you type 'false' or 'eof' . It is a fancy way of solving this question but it is not optimised way because it takes a hell lot of machine cycles and instructions . take a look
while (cin >> A[i++] && (i < N)); 00B324BD mov eax,dword ptr [i]
00B324C0 mov ecx,dword ptr [A]
00B324C3 lea edx,[ecx+eax*4]
00B324C6 mov dword ptr [ebp-11Ch],edx
00B324CC mov eax,dword ptr [i]
00B324CF add eax,1
00B324D2 mov dword ptr [i],eax
00B324D5 mov esi,esp
00B324D7 mov ecx,dword ptr [ebp-11Ch]
00B324DD push ecx
00B324DE mov ecx,dword ptr [imp?cin@std@@3V?char_traits@D@std@@@1@A (0B3D098h)]
00B324E4 call dword ptr [__imp_std::basic_istream >::operator>> (0B3D09Ch)]
00B324EA cmp esi,esp
00B324EC call __RTC_CheckEsp (0B312DFh)
00B324F1 mov dword ptr [ebp-0FCh],eax
00B324F7 mov edx,dword ptr [ebp-0FCh]
00B324FD mov eax,dword ptr [edx]
00B324FF mov ecx,dword ptr [ebp-0FCh]
00B32505 add ecx,dword ptr [eax+4]
00B32508 mov esi,esp
00B3250A call dword ptr [__imp_std::ios_base::operator bool (0B3D0D0h)]
00B32510 cmp esi,esp
00B32512 call __RTC_CheckEsp (0B312DFh)
00B32517 movzx ecx,al
00B3251A test ecx,ecx
00B3251C je main+0E8h (0B32528h)
00B3251E mov eax,dword ptr [i]
00B32521 cmp eax,dword ptr [N]
00B32524 jge main+0E8h (0B32528h)
00B32526 jmp main+7Dh (0B324BDh)
while (cout << A[--N] << ' ' && N); 00B32528 mov eax,dword ptr [N]
00B3252B sub eax,1
00B3252E mov dword ptr [N],eax
00B32531 push 20h
00B32533 mov esi,esp
00B32535 mov ecx,dword ptr [N]
00B32538 mov edx,dword ptr [A]
00B3253B mov eax,dword ptr [edx+ecx*4]
00B3253E push eax
00B3253F mov ecx,dword ptr [imp?cout@std@@3V?char_traits@D@std@@@1@A (0B3D0D4h)]
00B32545 call dword ptr [__imp_std::basic_ostream >::operator<< (0B3D0A4h)]
00B3254B cmp esi,esp
00B3254D call __RTC_CheckEsp (0B312DFh)
00B32552 push eax
00B32553 call std::operator<< > (0B314A6h)
00B32558 add esp,8
while (cout << A[--N] << ' ' && N); 00B3255B mov dword ptr [ebp-108h],eax
00B32561 mov ecx,dword ptr [ebp-108h]
00B32567 mov edx,dword ptr [ecx]
00B32569 mov ecx,dword ptr [ebp-108h]
00B3256F add ecx,dword ptr [edx+4]
00B32572 mov esi,esp
00B32574 call dword ptr [__imp_std::ios_base::operator bool (0B3D0D0h)]
00B3257A cmp esi,esp
00B3257C call __RTC_CheckEsp (0B312DFh)
00B32581 movzx eax,al
00B32584 test eax,eax
00B32586 je main+150h (0B32590h)
00B32588 cmp dword ptr [N],0
00B3258C je main+150h (0B32590h)
00B3258E jmp main+0E8h (0B32528h)
this is nice but allocating memory havent been tocuched in previous lessons...
thanks bro, it was helpful.
your code requires to enter char/string so it can print the value
Despite the code posted by JChiquin passed all of the test cases, the Visual Studio console did not give the same output until I modified the first while loop as:
while (std::cin >> A[i++] && i<N);Did anyone stop by the same issue?
You may reuse
Nand ditchiHi, I had not think it, but can be done like this:
that helped a lott thanks very much