Как сдвиг элементов массива вправо и заменить сдвинутый индекс шпагатом в Visual C++

Question

VISUAL C++ Вопрос

Привет,

У меня есть массив из 3-х элементов, и я хочу, чтобы переместить его элементы вправо и замените сдвинутую ячейку индекса на строку «SHIFTED», и она должна зависеть до тех пор, пока все ячейки не будут иметь строку «SHIFTED».

---

Например:

int a[x]={0,1,2}; 

Начального индекс и элементы заказа:

[0]=0 
[1]=1 
[2]=2 

должен стать в:

первого цикл:

[0]=SHIFTED 
[1]=0 
[2]=1 

второй цикл:

[0]=SHIFTED 
[1]=SHIFTED 
[2]=0 

третий цикл:

[0]=SHIFTED 
[1]=SHIFTED 
[2]=SHIFTED 

Я знаю, что могу сделать это с memmove(), но я не хочу использовать какие-либо функции в нем.

Не могли бы вы помочь мне; вот моя работа:

#include <iostream> 
#include <string> 
#include <stdio.h> 
#include <cstdlib> 
using namespace std; 

int const ARRAY_SIZE=3; 

int main() 
{ 
int Array[ARRAY_SIZE]; 
int iniPostion,newPostion; 
string x="SHIFTED"; 
for(iniPostion=0; iniPostion<ARRAY_SIZE; iniPostion++) 
{ 
    Array[iniPostion] = iniPostion; 
    cout << "Cell [" << iniPostion << "] Initial Element is: (" << Array[iniPostion] << ")" << endl; 
} 
cout << endl; 
for(newPostion=0; newPostion<ARRAY_SIZE; newPostion++) 
{ 
    Array[newPostion]=newPostion; 
    cout << "Cell [" << newPostion << "]  New Element is: ("; 
    if(Array[newPostion-1]<0) 
    { 
    cout << x << ")\n"; 
    } 
    else 
    { 
    cout << Array[newPostion-1] << ")" << endl; 
    } 
} 
return 0; 
} 

Answer 1

Как Петр упомянул в своем ответе, вы не можете назначить строку int. Я предположил, что SHIFTED будет -1.Поэтому каждый раз, когда вы меняете, вы получаете -1 в созданном промежутке.

Вам нужны две петли. Внешние контуры перебирают N (3) раза, а внутренний цикл начинается в конце массива и копирует (n-1)th элемента в положение nth:

for(int count = 0;count < N;count++){ 
    for(newPostion=ARRAY_SIZE-1; newPostion > count;newPostion--) 
     Array[newPostion]=Array[newPostion - 1]; // copy 
    Array[newPostion]= -1; // fill the gap. 

    // print. 
    for(iniPostion=0; iniPostion<ARRAY_SIZE; iniPostion++) { 
     cout << "Cell [" << iniPostion << "] Initial Element is: (" << Array[iniPostion] << ")" << endl; 
    } 
    cout<<endl; 
} 

Sample пробег:

# g++ a.cpp && ./a.out 
Cell [0] Initial Element is: (0) 
Cell [1] Initial Element is: (1) 
Cell [2] Initial Element is: (2) 

Cell [0] Initial Element is: (-1) 
Cell [1] Initial Element is: (0) 
Cell [2] Initial Element is: (1) 

Cell [0] Initial Element is: (-1) 
Cell [1] Initial Element is: (-1) 
Cell [2] Initial Element is: (0) 

Cell [0] Initial Element is: (-1) 
Cell [1] Initial Element is: (-1) 
Cell [2] Initial Element is: (-1) 

Answer 2

У меня есть массив из 3-х элементов, и я хочу, чтобы переместить его элементы вправо и заменить сдвинутый индекс ячейку с «сдвинутым» строкой и это должен цикл, пока все клетки имеет Строка «SHIFTED».

Это не имеет никакого смысла. У вас есть массив чисел (целых чисел), который, конечно, не может содержит строку. Что вы можете сделать, например, вставляя 0 или -1 для обозначения сдвинутого элемента.

Смещение может быть легко реализовано посредством операции std::rotate.

Но поскольку все элементы содержат одно и то же, в конце концов, почему бы вам просто не назначить их напрямую без всякого смещения?

Answer 3

Немного непонятно, как вы можете ожидать, что в массиве целых чисел будет строка («SHIFTED»).

Однако для этой операции вы можете использовать rotate алгоритм:

#include <iostream> 
#include <algorithm> 
#include <string> 

int const ARRAY_SIZE=3; 

void print(std::string* array) { 
    for (int i = 0; i != ARRAY_SIZE; ++i) { 
     std::cout << array[i] << ' '; 
    } 
    std::cout << '\n'; 
} 

int main() 
{ 
    std::string Array[ARRAY_SIZE] = {"0", "1", "2"}; 
    print(Array); 

    //the last item ends up at the beginning of the array 
    std::rotate(Array, Array + ARRAY_SIZE - 1, Array + ARRAY_SIZE); 

    //now overwrite the item that used to be last 
    Array[0] = "SHIFTED"; 
    print(Array); 
    return 0; 
} 

Это, вероятно, будет более простым и эффективным с соответствующим контейнером, например, std::deque или std::list где можно pop_back последнее значение и push_front новое значение.

Answer 4

Это попахивает домашнее задание ..

Есть ли причина, по которой вы не можете просто отслеживать, сколько изменений вы сделали, и просто учитывать это при печати?

#include <iostream> 

int const ARRAY_SIZE=3; 

class Shifter 
{ 
    public: 
     Shifter(const int* array_, size_t size_) 
     : array(array_), size(size_), shifts(0) {} 
     void Shift(size_t steps = 1) { shifts += steps; if(shifts > size) shifts = size; } 
     void Print(std::ostream& os) const; 
    private: 
     const int* array; 
     size_t size; 
     size_t shifts; 
}; 

void Shifter::Print(std::ostream& os) const 
{ 
    for(size_t i = 0; i < size; ++i) 
    { 
     os << "Cell [" << i << "] = "; 
     if(i < shifts) 
      os << "SHIFTED"; 
     else 
      os << array[i - shifts]; 
     os << std::endl; 
    } 
} 

std::ostream& operator <<(std::ostream& os, const Shifter& sh) 
{ 
    sh.Print(os); 
    return os; 
} 

int main(void) 
{ 
    // Initialize the array. 
    int a[ARRAY_SIZE]; 
    for(size_t iniPostion=0; iniPostion < ARRAY_SIZE; iniPostion++) 
     a[iniPostion] = iniPostion; 
    Shifter sh(a, ARRAY_SIZE); 
    std::cout << "Initial contents:" << std::endl; 
    std::cout << sh << std::endl; 

    // Do the shifts. 
    for(size_t newPostion = 0; newPostion < ARRAY_SIZE; newPostion++) 
    { 
     std::cout << "Shift by 1..." << std::endl; 
     sh.Shift(); 
     std::cout << sh << std::endl; 
    } 

    return 0; 
} 

Answer 5

Вот мое простое решение в простом старом C

#include <stdio.h> 
#include <stdlib.h> 
void main(int argc, char **argv) { 

    int MAX_LEN = 11; 
    int numOfShifts = 1; 
    if (argc > 1) { 
     numOfShifts = atoi(argv[1]); 
    } 
    printf("Number of shifts = %d\n",numOfShifts); 

    int arr[] = { 0,1,2,3,4,5,6,7,8,9,10 }; 
    int i; 
    int n; // number of shifts index 

    for (n = 0; n < numOfShifts; n++) { 
     for (i = MAX_LEN - 1; i >= 0; i--) { 
      if (i == 0) { 
       arr[i] = -1; 
      } else { 
       arr[i] = arr[i-1]; 
      } 
     } 
    } 

    // output 
    for(i = 0; i < MAX_LEN; i++) { 
     printf("Arr[%d] = %d\n", i, arr[i]); 
    } 

} 

Answer 6

Вы можете просто двигаться памяти.

// shift down 
int a[ 10 ]; 
memmove(a, a +1, sizeof(a) -sizeof(a[ 0 ]));