2
votes

Changer les éléments d'un tableau en C

Je veux donc changer les éléments d'un tableau avec 32 entiers "n" fois.

Tous les éléments doivent être sur la position suivante et le dernier doit être sur le premier.

J'ai essayé quelque chose comme ceci:

while(scanf("%d", &n) != EOF)
{
    for(int j=0; j<n; j++)
    for(int i=1; i<31; i++)
    {
        t[0]=t[31];
        tmp=t[i];
        t[i]=t[i+1];
    }
}

Je ne sais pas comment utiliser la variable tmp pour résoudre ce problème.

voici l'élément du tableau: p >

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

et cela devrait ressembler à ceci si le n = 1:

32 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

c arrays rotation swap

6 commentaires

Qu'entendez-vous par «commutateur»? Pouvez-vous donner un exemple?

Vous stockez t [i] dans tmp mais ne faites rien avec cette valeur. Pourriez-vous fournir un exemple minimal, complet et vérifiable avec le reste du code nécessaire?

op signifie faire pivoter les éléments, et non pas les déplacer et encore moins les changer

Si vous dessinez l'exécution sur papier, cela vous aidera. Général lors du changement, enregistrez d'abord le t [i] dans tmp , puis effectuez le changement

@DardaiIstvan veuillez modifier votre question et mettre toutes les clarifications là et non dans un commentaire illisible. Et, oui, un morceau de papier et un crayon sont d'excellents outils pour ce genre de problèmes (pour la plupart des problèmes en fait)

@DardaiIstvan c'est mieux, mais pensez à formater correctement votre question. C'est très simple, il suffit d'investir quelques minutes pour apprendre. Pensez également à ajouter la sortie pour n = 3 ou plus, juste pour être sûr. Et vous pourriez résumer à 4-5 éléments qui faciliteraient la compréhension

4 Réponses :

1
votes

Votre échange est incorrect, il devrait ressembler à ceci:

int main(int argc, char** argv) {
    char t[33] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ123456"; // 33 elements to leave space for '\0'
    int n;
    while (scanf(" %d", &n) == 1)
    {
        for (int j = 0; j < n; j++)
            for (int i = 0; i < 31; i++)
            {
                char temp = t[i];
                t[i] = t[i + 1];
                t[i + 1] = temp;
            }
        printf("string: %s\n", t);
    }
    return 0;
}

De plus, si vous voulez une boucle infinie comme celle-ci, je vous recommande de sauter les espaces dans le scanf , comme ceci:

while (scanf(" %d", &n) == 1) // note the space before %d

Dans l'ensemble, voici à quoi cela pourrait ressembler:

char temp = t[i];
t[i] = t[i + 1];
t[i + 1] = temp;

2 commentaires

Je pense que cela peut être fait sans aucune variable temporaire.

@Blaze merci pour votre réponse! ça marche maintenant!

2
votes

Ce qui suit n'est pas une modification de votre code, mais une solution plus efficace avec le runtime de O (n):

void rightshift(char array[LENGTH])
{
    int i, next = array[0];

    for (i = 1; i < LENGTH; i++)
    {
        char temp = array[i];
        array[i] = next;
        next = temp;
    }

    array[0] = next;
}

0 commentaires

0
votes

Comme les éléments sont décalés d'une position à chaque fois, vous pouvez le rendre plus efficace. Vous n'avez pas besoin d'utiliser une variable temporaire pour chaque élément mais uniquement pour le premier / dernier. Vous n'avez pas besoin d'échanger chaque paire d'éléments adjacents.

void rotate_by_1(char array[], size_t elem)
{
    int i;

#ifdef ROTATE_LEFT
    // Rotate in one direction...
    char tmp = array[0];
    for (i = 0; i < elem-1; i++)
    {
        array[i] = array[i+1];
    }
    array[elem-1] = tmp;
#endif

#ifdef ROTATE_RIGHT
    // Rotate in the other direction...
    char tmp = array[elem-1];
    for (i = elem-1; i > 0; i--)
    {
        array[i] = array[i-1];
    }
    array[0] = tmp;
#endif
}

Non testé ...

0 commentaires

0
votes

Tout d'abord, notez que pour faire pivoter un tableau avec 32 éléments n fois, il vous suffit de le faire tourner n% 32 fois. Comme alternative, qui n'est peut-être pas la plus rapide, aux solutions déjà fournies, le code ci-dessous copie deux mandrins de mémoire du tableau d'origine dans l'ordre inverse qui équivaut au décalage vers la droite d'un tableau n fois.

#define LEN 32
#define NUMBER_OF_ROTATIONS 56

int array_to_rotate[LEN];

int* tmp = malloc(sizeof(int) * LEN);

int n = NUMBER_OF_ROTATIONS % LEN;

// copying the last n elements of array_to_rotate to the beginning of tmp array
memcpy(tmp, (array_to_rotate + LEN - n), n * sizeof(int));

// copying first (LEN - n) elements of array_to_rotate behind the elements already copied to tmp array
memcpy((tmp + n), array, (LEN - n) * sizeof(int));

//replacing the original array with the one obtained after rotation n times
memcpy(array, tmp, sizeof(int) * LEN));

free(tmp);

0 commentaires