Swift

Recherche dans un ensemble par position

Note: avec Swift la position du premier élément d’une collection est 0

Première forme:

func rechercheParPosition_1 <_Element>(_ ensemble: Ensemble<_Element>
                                      ,_ aLaPosition: Int) 
                                      -> Bool 
{
   var existe = false
   var index = 1
   var position = aLaPosition - 1
   Initialiser(ensemble)
   while Enumeration(ensemble) && index < position {
      index = index + 1
      Element_Suivant(ensemble)
   }
   if Enumeration(ensemble) && (position == index) { existe = true }
   return existe
}

Deuxième forme: parcours sur ensemble itérable

func rechercheParPosition_2 <_Element>(_ ensemble: Ensemble<_Element>
                                      ,_ position: Int) 
                                      -> Bool 
{
   var existe = false
   var index = 0
   for _ in ensemble {
      if index == position {
         existe = true
         break
      } else {
         index = index + 1
      }
   }
   return existe
}

Tests

func Test_RechercheParPosition() {
   var ensemble = File(10,20,39) // Création d'un ensemble 
   var position = 4
   Afficher(ensemble,rechercheParPosition_1(ensemble,position),position)

   ensemble = Ensemble_Entier() // Création d'un ensemble Vide
   Afficher(ensemble,rechercheParPosition_1(ensemble,position),position)

   var texte = Texte("hello")
   Afficher(texte,rechercheParPosition_1(texte,position),position)

   position = 1
   Afficher(ensemble,rechercheParPosition_2(ensemble,position),position)

   ensemble = Ensemble_Entier() // ensemble Vide
   Afficher(ensemble,rechercheParPosition_2(ensemble,position),position)

   texte = Texte("hello")
   Afficher(texte,rechercheParPosition_2(texte,position),position)
}

La fonction Afficher

On donne la version Swift de la fonction Afficher,dans les tests ci-dessus. On remarque la présence du protocole Monoide utilisé par le framework Schema, celui-ci autorise les opérations de base sur les éléments d’un ensemble dont le type est générique ou polymorphe.

func Presence_Element<Element: Monoide>(_ ensemble: Ensemble<Element>
                                       , _ position: Int) 
                                       -> (existe: Bool,element: Element) 
{
   guard ensemble.elements.indices.contains(position - 1) else {
      return (false,ElementNeutre(ensemble))
   }
   return (true, ensemble[position - 1 ])
}

func Afficher<Element: Monoide>(_ ensemble: Ensemble<Element>
                               ,_ existe: Bool, _ position: Int ) 
{
   let existe = existe
   if existe {
      let (_ ,element) = Presence_Element(ensemble,position)
      print("\(element) trouvé à la position \(position)")
   } else {
      print("Aucun élément à la position = \(position)")
   }
}

copyright A rchitectures A pplicatives A vancées A3-Soft