Уплотненного цикл заполнения массива

Question

Я пытаюсь создать вложенный цикл, который заполняет значения в массиве от 1 до 20.

IE), массив = {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(int i = 0; i<20; i++) 
{ 
    array[i] = j; 
} 

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

Вложенный цикл, который вы создали выше, будет делать именно то, что вы описали. Для каждого цикла внешнего цикла он выполнит полные 20 циклов внутреннего цикла. поэтому в общей сложности вы выполните его 21 * 20 раз.

Также будьте осторожны с вашим индексом. Вы хотите начать с int i = 0 до i < 20, который петли ровно 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], вы должны петли

для (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]; 

тогда действительные indicies являются 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, " ")); 
} 

Или вместо алгоритмов вы можете использовать диапазон, основанный на выражении. Например,

#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 по петле и измерить размер вашего массива, как указано выше.