Comment puis-je supprimer automatiquement un seul élément d'une liste dans Scala et combler le vide?

Pour répondre directement à votre question, je pense que vous êtes à la recherche pour patchpar exemple pour supprimer l'élément d'indice 2 ("c"):

List("a","b","c","d").patch(2, Nil, 1)      //List(a, b, d)

où Nil est ce que nous sommes en la remplaçant avec, et 1 est le nombre de caractères à remplacer.

Mais, si vous faites cela:

J'ai quatre listes qui sont associés les uns avec les autres par l'indice; un
liste des magasins les noms de parcours, on stocke le temps le début de la classe dans
un simple int format (c'est à dire 130), l'un des magasins de "am" ou "pm", et un
les magasins les jours de classes par int

vous allez passer un mauvais moment. Je vous suggère d'utiliser un case class:

case class Course(name: String, time: Int, ampm: String, day: Int)

et de les stocker dans un Set[Course]. (Enregistrement de l'heure et les jours comme Ints n'est pas une bonne idée non plus, - avoir un regard sur java.util.Calendar à la place.)

Tout d'abord, quelques sidenotes:

1. List n'est pas un indice basé sur la structure. Tous les index-opérations orientées prendre le temps linéaire. Pour l'index-les algorithmes Vector est un bien meilleur candidat. En fait, si votre algorithme requiert index c'est un signe certain que vous êtes vraiment ne pas s'exposer à la Scala de capacités fonctionnelles.

2. map sert pour transformer une collection d'éléments "A" de la même collection d'éléments "B" à l'aide d'un passé transformateur fonction à partir d'un seul "A" à un seul "B". Il ne peut pas changer le nombre d'éléments résultant. Probablement que vous avez confondu map avec fold ou reduce.

De réponse sur la mise à jour de votre question

Bien, voici une solution fonctionnelle, qui fonctionne efficacement sur les listes:

val (resultCourses, resultTimeList, resultAmOrPmList, resultDateList)
  = (courses, timeList, amOrPmList, dateList)
      .zipped
      .filterNot(_._1 == input)
      .unzip4

Mais il ya un hic. J'ai réellement venu à être très étonné de découvrir que les fonctions utilisées dans cette solution, qui sont donc de base pour les langages fonctionnels, n'étaient pas présents dans le standard de Scala bibliothèque. Scala a pour 2 et 3-aire n-uplets, mais pas les autres.

Pour résoudre ce que vous aurez besoin de ce qui suit implicite extensions importés.

implicit class Tuple4Zipped 
  [ A, B, C, D ] 
  ( val t : (Iterable[A], Iterable[B], Iterable[C], Iterable[D]) ) 
  extends AnyVal 
  {
    def zipped 
      = t._1.toStream
          .zip(t._2).zip(t._3).zip(t._4)
          .map{ case (((a, b), c), d) => (a, b, c, d) }
  }

implicit class IterableUnzip4
  [ A, B, C, D ]
  ( val ts : Iterable[(A, B, C, D)] )
  extends AnyVal
  {
    def unzip4
      = ts.foldRight((List[A](), List[B](), List[C](), List[D]()))(
          (a, z) => (a._1 +: z._1, a._2 +: z._2, a._3 +: z._3, a._4 +: z._4)
        )
  }

Cette mise en œuvre nécessite Scala 2.10 car il utilise la nouvelle Valeur effective des Classes de fonctionnalité pour proxénétisme les types existants.

J'ai d'ailleurs inclus dans une petite bibliothèque d'extensions appelées Sexteaprès en fonction de votre projet sur lequel vous serez en mesure de simplement en ajoutant un import sext._ déclaration.

Bien sûr, si vous voulez, vous pouvez simplement composer ces fonctions directement dans la solution:

val (resultCourses, resultTimeList, resultAmOrPmList, resultDateList)
  = courses.toStream
      .zip(timeList).zip(amOrPmList).zip(dateList)
      .map{ case (((a, b), c), d) => (a, b, c, d) }
      .filterNot(_._1 == input)
      .foldRight((List[A](), List[B](), List[C](), List[D]()))(
        (a, z) => (a._1 +: z._1, a._2 +: z._2, a._3 +: z._3, a._4 +: z._4)
      )

La réponse, je suis sur le point de donner peut-être de dépasser ce que vous avez appris jusqu'à présent dans votre cours, donc, si c'est le cas je m'excuse.

Tout d'abord, vous avez droit à la question de savoir si vous devriez avoir quatre listes - fondamentalement, il semble que vous avez besoin est un objet qui représente un cours:

/**
 * Represents a course.
 * @param name the human-readable descriptor for the course
 * @param time the time of day as an integer equivalent to 
 *             12 hour time, i.e. 1130
 * @param meridiem the half of the day that the time corresponds 
 *                 to: either "am" or "pm"
 * @param days an encoding of the days of the week the classes runs.
 */
case class Course(name : String, timeOfDay : Int, meridiem : String, days : Int)

avec laquelle vous pouvez définir un cours individuel

val cs101 = 
  Course("CS101 - Introduction to Object-Functional Programming", 
         1000, "am", 1)

Il y a de meilleures façons de définir ce type (mieux représentations de 12 heures de temps, une meilleure façon de représenter les jours de la semaine, etc), mais je ne compte pas s'écarter de l'original de votre énoncé du problème.

Compte tenu de cela, vous auriez une liste unique de cours:

val courses = List(cs101, cs402, bio101, phil101)

Et si vous vouliez trouver et supprimer tous cours correspondant à un nom donné, on peut écrire:

val courseToRemove = "PHIL101 - Philosophy of Beard Ownership"
courses.filterNot(course => course.name == courseToRemove)

De manière équivalente, en utilisant le trait de soulignement sucre syntaxique en Scala pour des littéraux de fonction:

courses.filterNot(_.name == courseToRemove)

Si il y avait le risque qu'un plus qu'un cours peut avoir le même nom (ou que vous êtes filtrage basé sur certains critères secondaires à l'aide d'une expression régulière ou un préfixe match) et que vous souhaitez la supprimer uniquement la première occurrence, puis vous pouvez définir votre propre fonction pour le faire:

def removeFirst(courses : List[Course], courseToRemove : String) : List[Course] =
  courses match {
    case Nil => Nil
    case head :: tail if head == courseToRemove => tail
    case head :: tail => head :: removeFirst(tail)
  }