identificateur non résolu - pour la logique de boucle in

Question

Il s'agit d'un tri de bas en haut. Pendant la boucle, l'itération est substituée par le nombre le plus bas dans le tableau et cela continue jusqu'à la fin.

Comme vous pouvez le voir, je suis en train de refactoriser l'utilisation de la foulée. Malheureusement var lowest = firstIndex me donne quelques problèmes.

Je devrais être capable de compléter cette fonction en utilisant la foulée droite? Je crois que je devrais utiliser stride: to au lieu de stride: through. Merci à Tim pour cette astuce.

func selOrganize(myList: Array<Int>) -> Array<Int> { 1 

    var extract = myList 

    for firstIndex in 0..<extract.count { 

     var lowest = firstIndex 

     for var secondIndex = firstIndex + 1; secondIndex < extract.count; secondIndex++ { 

      if extract[lowest] > extract[secondIndex] { 
       lowest = secondIndex 
    } 
     } 

     if firstIndex != lowest { 
      swap(&extract[firstIndex], &extract[lowest]) 
     } 
    } 
    return extract 
} 

syntaxe Mise à jour

func selOrganize(myList: Array<Int>) -> Array<Int> { 

var extract = myList 

    // var lowest = firstIndex 

    // Do I need 'key'? Should I declare 'lowest' as a variable here? 
    // If I do use it here I get a "'lowest' is unmutable because it's a let" error 
    for (firstIndex, key) in extract.enumerate() { 

     // < > stride uses 'to' and <= >= stride uses through 
     for secondIndex in (firstIndex).stride(to: 0, by: +1) { 

      if extract[lowest] > extract[secondIndex] { 
       lowest = secondIndex 
      } 
     } 

    if firstIndex != lowest { 
     swap(&extract[firstIndex], &extract[lowest]) 
    } 

} 

return extract 
} 

Answer 1

J'ai eu à travailler comme ceci:

func selOrganize(myList: Array<Int>) -> Array<Int> { 

    var extract = myList 

    // Accessing indices is simpler than calling enumerate, and 
    // the function only needs access to the indices, not the 
    // values of the enumeration: 
    for firstIndex in extract.indices { 

     // lowest needs to be defined inside this loop if you 
     // are going to initialize it using firstIndex 
     // because firstIndex isn't defined outside the loop. 
     var lowest = firstIndex 

     // You need to stride from the firstIndex to the end of the 
     // array, so the call to stride should look like this: 
     for secondIndex in firstIndex.stride(to: extract.count, by: 1) { 

      if extract[lowest] > extract[secondIndex] { 
       lowest = secondIndex 
      } 
     } 

     if firstIndex != lowest { 
      swap(&extract[firstIndex], &extract[lowest]) 
     } 
    } 

    return extract 
} 

Answer 2

Stride n'est pas nécessaire, vous pouvez le faire avec la norme for i in start..<end syntaxe

func selOrganize(myList: Array<Int>) -> Array<Int> { 

    var extract = myList 

    for firstIndex in 0..<extract.count { 
    var lowest = firstIndex 
    for secondIndex in (firstIndex + 1)..<extract.count { 
     if extract[lowest] > extract[secondIndex] { 
     lowest = secondIndex 
     } 
    } 

    if firstIndex != lowest { 
     swap(&extract[firstIndex], &extract[lowest]) 
    } 
    } 
    return extract 
} 

Mais en fait, vous pouvez faire la même chose dans une ligne

let sortedList = myList.sort{$0 < $1}