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.
Loading...
  1. Practice
  2. C++
  3. Introduction
  4. Arrays Introduction
  5. Discussions

Arrays Introduction

  • JChiquin + 24 comments

    My solution without using vector:

    #include <iostream>
int main() {
    int N,i=0;
    cin>>N;
    int *A = new int[N];
    while(std::cin>>A[i++]);
    while(std::cout<<A[--N]<<' ' && N);
    delete[] A;
    return 0;
}
    • glennlopez + 2 comments

      wow. thats pretty smart can you tell me where you learned it or walk me through your though proccess for 

      int *A = new int[N];
      • SudhanshuMohan + 0 comments

        thats for dynamically allocating memory ie it adjusts its size according to the input during runtime

      • akshaybusa67 + 1 comment

        what is it mean by *A=new int[N]? why new keyword used? and what will happen by this expression?

        • meowmix2 + 0 comments

          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

    • Rohith13 + 1 comment

      Can you explain me this step: " while(cout<

      • dalownerx3 + 1 comment

        It means that while the statement in the parenthesis is true, keep executing the statements inside the while loop.

        • arpitarora866 + 1 comment

          what

          AND N

          do?

          • imachin + 1 comment

            " ...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.

    • shihaabmeerun + 1 comment

      Heres another solution:

      int main() {
    int n;  
    cin >> n;
    const int a = n;
    int arr[a];

    return 0;
}
      • MoWaNoob_101 + 1 comment

        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.

        • pardumangarg7 + 0 comments

          array size is also wrong

    • p_rzetelski_note + 1 comment

      (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 :)

      • shaikaslam186 + 1 comment

        I have a doubt .why you use the CONST???????

        • abhikapoor2000_1 + 0 comments

          to not able the program change value of n further

    • ness_eg + 1 comment

      Why did you add '&& N' in 'while(cout<

      • JChiquin + 2 comments

        That's because only with cout the loop will never end, so I add other constraints, when N will be 0 the loop will end (N is like an inverse iterator).

        Sorry my english

        • ness_eg + 0 comments

          thank you ^^

        • narutoitachi329 + 1 comment
          int main() {
  int n, i = 0;
  cin >> n;
  int a[n];
  for (; i < n; i++)
    cin >> a[i];
  for (; i >0; i--)
    cout << a[i- 1] <<" ";
  return 0;
}
          • JChiquin + 1 comment

            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.

    • danielgcwik + 0 comments

      thanks, Jorge, that worked for me

    • 929315787cenmin1 + 1 comment

      what 's "and" in while mean?

      • mo_fa + 0 comments

        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.

    • vishalshukla044 + 0 comments

      while(cout<

    • AbdulQuadir + 1 comment

      delete[] A; what's this statement doing?

      • mo_fa + 1 comment

        It is used to free the memory assigned to A because its no longer needed.

        • alaniane + 0 comments

          @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.

    • sourabhitm + 2 comments

      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.

      int main()
{
    int N,i=0;
    cin>>N;
    int *A = new int[N];
    while(cin>>A[i++] && (i < N));
    while(cout<<A[--N]<<' ' && N);
    delete[] A;
    return 0;
}
      • JChiquin + 0 comments

        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:

        while(scanf("%i",&A[i++])>0);
//or
while(~scanf("%i",&A[i++]));

        Those are the way of reading in c++ the whole input, there is challenges where the input size is not given

        Sorry my english.

      • balavemulakonda + 0 comments

        yes!!helped a lot

    • radico + 1 comment

      there should be one more condition in the first while loop 

      while(cin>>A[i++] and i<N);

      otherwise, will be an infinit loop. thumps up, nice approach

      • JChiquin + 0 comments

        See the comment above, it already has been explained

    • MrNik + 0 comments

      can u pls explain me both the while statements, i am not getting it.

    • nittinsant_seth1 + 1 comment

      Can you explain, how did the array get reversed?

      • Umar_Mukhtar + 0 comments

        actually Array didn't get reversed we are printing in reverse order (i.e from last index to first).

    • das_the_don999 + 0 comments

      Hi, the snippet is not working in codeblocks. Is there any particular reason behind it?

      P.s - I am new to this.

    • grinning_moon_c1 + 1 comment

      Truly elegant. Shouldn't we free A or set it to NULL as well?

      • JChiquin + 0 comments

        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.

    • anbuibz66 + 0 comments

      why we must cout N

    • Umar_Mukhtar + 0 comments

      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)

    • dafnis + 0 comments

      this is nice but allocating memory havent been tocuched in previous lessons...

    • param3108 + 0 comments

      thanks bro, it was helpful.

    • damian_beles + 0 comments
      [deleted]
    • damian_beles + 0 comments
      [deleted]
    • EdinHajdarevic + 0 comments

      your code requires to enter char/string so it can print the value

    • ashutosh_kaushi1 + 0 comments
      [deleted]
    • guilhermenicchio + 1 comment
      [deleted]