嵌套循環填充數組

Question

我想創建一個嵌套for循環，填充1到20的數組中的值。

IE）array = {1,2,3,4,5,6 ，7,8,9,10,11,12,13,14,15,16,17,18,19,20}

int array [20];

for(int i = 0; i<21; i++) 
{ 
    for(int j =1; j<21; j++) 
    { 
     array[i] = j; 
     cout<< array[i]; 
    } 

} 

假設數組索引應該計入「i」，並且應該等於「j」，它也在計數。數組元素在填充時被打印到控制檯。

我期望1 -20打印出來一次，但是當我運行代碼時，1-20打印出多次。有人能告訴我這個問題嗎？謝謝！

Answer 1

您的外部循環運行21次，您的內部循環運行20次外部循環迭代，因此總共有21 * 20 = 420打印語句。

你可以簡單地做

for(int i = 0 ; i < array.length ; i++) 
{ 
    array[i] = i + 1; 
    cout << array[i] << endl; 
} 

Answer 2

如果你看看你的陣列，當你完成，這也將是隻是一系列20年代。第一個循環說「做20次」，然後第二個循環說「設置並打印該數組元素的值20次」。你需要做的是包括檢查你是否將正確的j值賦值給正確的數組[i]值，並且只在這種情況下設置值。例如：

if (j == i + 1) array[i] = j; 

Answer 3

爲什麼你需要一個嵌套循環？

for(int i = 0; i<20; i++) 
{ 
    array[i] = i + 1; 
    cout<< array[i]; 
} 

Answer 4

是的，你有兩個循環時，你只需要一個：

for(int i = 0; i<21; i++) 
{ 
    array[i] = i + 1; 
    cout<< array[i]; 
} 

Answer 5

爲了填補數組，並打印你只需要兩個簡單的for循環

for(int i = 0; i<20; i++) 
{ 
    array[i] = j; 
} 

for(int j =0; j<20; j++) 
{ 
    cout<< array[i]; 
} 

結果

您在上面創建的嵌套循環將完成您所描述的內容。 對於外部for循環的每個循環，它將執行內部循環的全部20個循環。 所以你總共會執行21 * 20次。

另請注意您的索引。你想從int i = 0開始到，它正好循環20次。

Answer 6

我不知道你爲什麼試圖在你的數組中打印單個元素，但這裏沒有必要使用嵌套循環。實際上，一個循環根本不需要：

// vector version 
std::vector<int> vec(20); 
std::iota(vec.begin(), vec.end(), 1); 

// array version 
int arr[20]; 
std::iota(std::begin(arr), std::end(arr), 1); 

如果你想打印出整個數組你初始化後：

std::copy(vec.begin(), vec.end(), std::ostream_iterator<int>(std::cout, "\n")); 

Answer 7

我看到很多人回答了關於這個問題，所以我不會重複它們，我只是提到你正在寫數組大小。 如果有int array[20]，你應該循環

的for（int i = 0;我< ;我++） 最後索引是19

Answer 8

外環21次重複的內循環

for(int i = 0; i<21; i++) 
{ 
    for(int j =1; j<21; j++) 
    { 
     array[i] = j; 
     cout<< array[i]; 
    } 

} 

內部循環執行的操作與分配數組元素的相同數字相同。此外您的代碼有缺陷，因爲由於外循環youare試圖訪問元件陣列[20]不存在，因爲，如果該陣列被定義爲

int arrat[20]; 

那麼有效索引是0 - 19.

對不操心寫正確需要的環路或迴路可以使用標準算法std::iota

例如

#include <iostream> 
#include <numeric> 
#include <iterator> 
#include <algorithm> 

int main() 
{ 
    const size_t N = 20; 
    int array[N]; 

    std::iota(std::begin(array), std::end(array), 1); 
    std::copy(std::begin(array), std::end(array), std::ostream_iterator<int>(std::cout, " ")); 
} 

或者，您可以使用基於範圍的for語句來代替算法。例如

#include <iostream> 

int main() 
{ 
    const size_t N = 20; 
    int array[N]; 
    int i = 1; 

    for (int &x : array) 
    { 
     x = i++; 
     std::cout << x << ' '; 
    } 
} 

Answer 9

如果你真的想使用嵌套解決方案（例如遊戲板座標），那麼這是我的解決方案。

// nesting arrays for example game board coordinates                                  

#include <iostream> 

    int main(){ 
    int x = 20; 
    int y = 40; 

    int array[x][y]; 

    // initialize array of variable-sized.                                 
    for(int i = 0; i < x; ++i){ 
    for(int j = 0; j < y; ++j){ 
     array[i][j] = 0; // or something like i + j + (i * (y-1)) if you wish                        
     // and send it to cout                                    
     std::cout << array[i][j] << " "; 
    } 
    std::cout << std::endl; 
    } 
    //notice, that when sent to cout like this, x and y flips on screen, but                        
    //logics of coordinates is ok                                   

    // and then do something usefull with it                                

    return EXIT_SUCCESS; 
} 

Answer 10

int size = 20; 

for (int i = 0; i < size; i++) 
    { int array[i]; 
     array[i] = i + 1; 
     cout << array[i]<< " "; 
    } 

你可以填充1 for循環的數組，衡量你的陣列像上述的大小。