Fonction pour créer un tableau en zigzag?

Question

Je suis en train de créer un tableau de positif et négatifs entiers, ce qui représente des distances nord et sud d'un emplacement - Je dois voir les éléments du tableau en zigzag ordre.

Cela signifie que le plus grand élément apparaît en premier, l'élément plus petit apparaît seconde, et les éléments restants alternent entre les membres plus grandes décroissant de la plus grand et les petits membres croissante du plus petit.

à savoir le tableau [1, 3, 6, 9, -3] devient [9, -3, 6, 1, 3].

J'essaie de compléter la fonction wiggleArrangeArray, qui prend un argument, un tableau entier de n entiers.

Format d'entrée requis, les contraintes et Format de sortie

Je ne sais pas comment dire

« si l'élément du tableau est plus grand que les autres éléments du tableau, affichez-le en premier. "

"si l'élément est plus petit que les autres éléments de la matrice, affichez-le en second."

«puis alterner entre les prochains plus grand nombre, et les prochains numéros les plus petits »

def wiggleArrangeArray(intArr): 
    for i in intArr 
     #if i > other items in intArr 
     #display that i at index value 0 
     #if i < other items in intArr 
     #display that i at index value 1 
     #if i < i at index value 0 and > other items in intArr, display it next 
     #if i > i at index value 1 and < other items in intArr, display it next 
     #repeat last two lines for continuing values 

S'il vous plaît aider si possible. Here's a link à la solution en C++ mais j'en ai besoin en Python. Merci.

Modifier: La fonction doit travailler avec les tests suivants:

f = open(os.environ["OUTPUT_PATH"], "w") 

_intArr_cnt = int(raw_input()) 
_intArr_i=0 
_intARR = [] 
while _intArr_i < _intArr_cnt: 
    _intArr_item = int(raw_input()); 
    _intArr.append(_intArr_item) 
    _intArr_i+=1 

res = wiggleArrangeArray(_intArr); 
for res_cur in res: 
    f.write(str(res_cur) + "\n") 

f.close() 

Answer 1

Le code C++ modifié

Note the algorithm you provided does calculate some sort of zigzag, but it is not the zigzag you are looking for. For future reference I will leave it here.

In the C++ code you provided, they only look for a sequences that satisfies a <b> c <d> e < f, you are looking however for a sequence with the 1-max, 1-min, 2-max, 2-min,...

Votre lien vous fournit une solution que vous pouvez copier presque textuellement dans Python .Vous définissez seulement une fonction swap:

def swap(arr,i,j): 
    t = arr[i] 
    arr[i] = arr[j] 
    arr[j] = t 

Ensuite, vous pouvez simplement modifier le code:

def zigZag(arr): 
    n = len(arr) 
    # Flag true indicates relation "<" is expected, 
    # else ">" is expected. The first expected relation 
    # is "<" 
    flag = True 

    i = 0 
    while i<= n-2: 
     if (flag): # "<" relation expected 
      # If we have a situation like A > B > C, 
      # we get A > B < C by swapping B and C 
      if arr[i] > arr[i+1]: 
       swap(arr,i,i+1) 
     else: # ">" relation expected 
      # If we have a situation like A < B < C, 
      # we get A <C> B by swapping B and C 
      if arr[i] < arr[i+1]: 
       swap(arr,i,i+1) 
     flag = not flag # flip flag 
     i += 1 

l'esprit que c'est plutôt non Pythonic, de sorte que vous pouvez améliorer simplement comme:

def swap(arr,i,j): 
    arr[i],arr[j] = arr[j],arr[i] 

def zigZag(arr): 
    n = len(arr) 
    for i in range(len(arr)-1): 
     if not i&1: 
      if arr[i] > arr[i+1]: 
       swap(arr,i,i+1) 
     elif arr[i] < arr[i+1]: 
      swap(arr,i,i+1) 
    return arr 

Ici l'affectation de tuple est utilisée pour échanger des éléments dans la liste, un est utilisé pour itérer sur les indices, nous pouvons en outre utiliser un elif au lieu d'un if dans un else, et pour j'ai abandonné le flag en utilisant un contrôle modulo.

Votre fonction zigzag

Vous pouvez simplement résoudre le problème par le tri de la liste, et en utilisant deux pointeurs que chaque fois la plus à gauche émettent, le plus à droite et marcher vers l'autre. En d'autres termes quelque chose comme:

def zigZag(arr): 
    srt = sorted(arr) 
    left = 0 
    right = len(srt)-1 
    result = [] 
    while left < right: 
     result.append(srt[right]) 
     right -= 1 
     if left < right: 
      result.append(srt[left]) 
      left += 1 
    return result