Python De La Matrice De Rotation

Je suis donc la mise en œuvre d'un bloc de swap algorithme en python.

L'algorithme que je suis est-ce:

Initialiser Un = arr[0..j-1] et B = arr[d..n-1]
1) effectuer les opérations suivantes jusqu'à ce que la taille de A est égale à la taille de B

a) Si l'Une est plus courte, diviser B en Bl et Br tels que Br est de même
la longueur A. Swap Un et Br à changer ABlBr en BrBlA. Maintenant
est à sa place définitive, afin de se reproduire sur des morceaux de B.

b) Si A est plus, diviser en Al et Ar, tels que Al est de même
la longueur B Swap Al et B pour le changer AlArB en BArAl. Maintenant B
est à sa place définitive, afin de se reproduire sur des morceaux de A.

2), Enfin, quand A et B sont de taille égale, bloc d'échange.

Le même algorithme a été implémenté en C sur ce site, des La Matrice De Rotation

Mon code python pour le même est

a = [1,2,3,4,5,6,7,8]

x = 2

n = len(a)


def rotate(a,x):
    n = len(a)

    if x == 0 or x == n:
        return a

    if x == n -x:
        print(a)
        for i in range(x):
            a[i], a[(i-x+n) % n] = a[(i-x+n) % n], a[i]
        print(a)
        return a

    if x < n-x:
        print(a)
        for i in range(x):
            a[i], a[(i-x+n) % n] = a[(i-x+n) % n], a[i]
        print(a)
        rotate(a[:n-x],x)
    else:
        print(a)
        for i in range(n-x):
            a[i], a[(i-(n-x) + n) % n] = a[(i-(n-x) + n) % n] , a[i]
        print(a)
        rotate(a[n-x:], n-x)

rotate(a,x)
print(a)

J'obtiens le droit des valeurs à chaque étape, mais les récursive appel de fonction ne retourne pas le résultat escompté, et je n'arrive pas à comprendre la cause. Quelqu'un peut m'expliquer quel est le problème avec ma récursivité ? et que peut-être la solution de rechange possible.

InformationsquelleAutor Sam | 2013-06-27

16

Vous pouvez faire pivoter une liste en Python à l'aide d'un deque:
```
>>> from collections import deque
>>> d=deque([1,2,3,4,5])
>>> d
deque([1, 2, 3, 4, 5])
>>> d.rotate(2)
>>> d
deque([4, 5, 1, 2, 3])
>>> d.rotate(-2)
>>> d
deque([1, 2, 3, 4, 5])
```
Ou avec la liste des tranches:
```
>>> li=[1,2,3,4,5]
>>> li[2:]+li[:2]
[3, 4, 5, 1, 2]
>>> li[-2:]+li[:-2]
[4, 5, 1, 2, 3]
```
Noter que la convention de signe est opposé avec deque.faire pivoter vs tranches.

Si vous voulez une fonction qui a la même convention de signe:
```
def rotate(l, y=1):
   if len(l) == 0:
      return l
   y = -y % len(l)     # flip rotation direction
   return l[y:] + l[:y]

>>> rotate([1,2,3,4,5],2)
[4, 5, 1, 2, 3]
>>> rotate([1,2,3,4,5],-22)
[3, 4, 5, 1, 2]
>>> rotate('abcdefg',3)
'efgabcd'
```
Pour numpy, il suffit d'utiliser np.rouleau
```
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.roll(a, 1)
array([9, 0, 1, 2, 3, 4, 5, 6, 7, 8])
>>> np.roll(a, -1)
array([1, 2, 3, 4, 5, 6, 7, 8, 9, 0])
```
Ou vous pouvez utiliser un numpy version de la même rotate ci-dessus (encore une fois noter la différence de signe vs np.roll):
```
def rotate(a,n=1):
    if len(a) == 0:
        return a
    n = -n % len(a)     # flip rotation direction
    return np.concatenate((a[n:],a[:n]))  
```
- il y a beaucoup de python que je pourrais utiliser comme vous l'avez suggéré. Cependant, il m'a été donné comme un défi que j'ai eu à mettre en œuvre sans l'aide de la méthode interne. Si vous pourriez suggérer une modification dans le code ci-dessus, ce serait génial
- Si li est un numpy.tableau, l'ajout ne pas concaténer deux tableaux, mais font un élément de plus à la place. Comment puis-je faire votre opération de rotation avec un tableau numpy ?
- voir modifier
- J'aime votre réponse beaucoup, je souhaite juste que j'ai vu cette réponse plus tôt, dans l'intervalle, j'ai fait ça: np.concatenate((a[n:],a[:n]))
- Selon IPython %timeit, np.concatenate( ( a[n:], a[:n] ) ) semble 10 fois plus vite 🙂
- a[n], a[:n] ) ) est en effet plus rapide. Il ne ralentit pour les grandes baies. Semblable à l'Python réponse que j'ai donné, je suppose. Merci! Je vais le rajouter.
InformationsquelleAutor dawg
7

Un simple et de sténographie syntaxe de la matrice de rotation en Python est
```
arr = arr[numOfRotations:]+arr[:numOfRotations]
```
Exemple:
```
arr = [1,2,3,4,5]
rotations = 4
then 

arr = arr[4:]+arr[:4]
```
nous donne

[5,1,2,3,4]

InformationsquelleAutor Yashwanth Chowdary Kata
5

Avez-vous réellement besoin de mettre en œuvre le bloc de swap ou vous êtes simplement à la recherche pour faire pivoter le tableau? En python, vous pouvez faire de la CW et CWW rotations à l'aide de
```
zip(*arr[::-1])
```
et
```
zip(*arr)[::-1]
```
- Pouvez-vous expliquer plus?
- Cette réponse n'est pas réellement répondre à la question, comme il le fait dans le sens horaire et dans le sens inverse des rotations sur 2D tableaux. Je vais probablement supprimer cette réponse plus tard aujourd'hui.
InformationsquelleAutor wflynny
4

J'ai trouvé un problème que j'avais besoin de Droite et de Gauche, des rotations pour les grandes valeurs de k (où k est le nombre de rotations), donc, j'ai mis en œuvre les fonctions suivantes quelle que soit la taille de k.

Droit de Rotation Circulaire (de gauche à droite: 1234 -> 4123):
```
def right_rotation(a, k):
   # if the size of k > len(a), rotate only necessary with
   # module of the division
   rotations = k % len(a)
   return a[-rotations:] + a[:-rotations]
```
Gauche Rotation Circulaire (de droite à gauche: 1234 -> 2341):
```
def left_rotation(a, k):
   # if the size of k > len(a), rotate only necessary with
   # module of the division
   rotations = k % len(a)
   return a[rotations:] + a[:rotations]
```
Sources:
- https://stackoverflow.com/a/46846544/7468664
- https://stackoverflow.com/a/9457923/7468664
InformationsquelleAutor Ângelo Polotto
1

J'attends que lorsque vous passez une tranche de un à votre appel récursif, vous n'êtes pas en passant de la même variable de plus. Essayer de passer une dans son intégralité et de la partie supérieure /inférieure limites de votre tranche comme des arguments supplémentaires à votre fonction.

Par exemple envisager de cette fonction:
```
def silly(z):
  z[0] = 2
```
J'ai juste essayé la suivante:
```
>>> z = [9,9,9,9,9,9]
>>> silly(z)
>>> z
[2, 9, 9, 9, 9, 9]
>>> silly(z[3:])
>>> z
[2, 9, 9, 9, 9, 9]
```
Où vous pouvez voir la modification de la tranche n'a pas été retenue par l'ensemble

Par curiosité, quels résultats obtenez-vous & quels résultats attendez-vous?
- L'ajout d'impression '(id(z))' dans 'idiot' de la fonction serait utile.
- Bon point, thx
InformationsquelleAutor user1245262

vous pouvez utiliser ce code pour rotation à gauche en python tableau

import copy
def leftRotate(arr,n) :
    _arr = copy.deepcopy(arr)
    for i in range(len(arr)-n):
        arr[i] = arr[i+n]
    for j in range(n):
        arr[(len(arr)-n)+j] = _arr[j]

arr = [1, 2, 3, 4, 5, 6, 7] 
leftRotateby = 3
leftRotate(arr,leftRotateby)
print arr 
#output:: [4, 5, 6, 7, 1, 2, 3]

InformationsquelleAutor a.patidar

Vous devez vous connecter pour publier un commentaire.