Question

我在 Scala

中有一个

val arr = Array("a", "a", "b", "b", "c", "d")

func addNotificationForAlarm(alarm: MyAlarm) {

    let myAlarmNotifContent = UNMutableNotificationContent()
    myAlarmNotifContent.title = "Reminder"
    myAlarmNotifContent.body = alarm.activity
    myAlarmNotifContent.sound = UNNotificationSound.default()

    if alarm.repeatDays.count == 1 {

    } else {

        for index in 1...alarm.repeatDays.count {
            createNotif(date: alarm.date, weekDay: index, content: myAlarmNotifContent)
        }
    }

}

private func createNotif(date: Date, weekDay: Int, content: UNNotificationContent) {

    var dateComponent = DateComponents()
    dateComponent.weekday = weekDay
    dateComponent.hour = Calendar.current.dateComponents([.hour], from: date).hashValue
    dateComponent.minute = Calendar.current.dateComponents([.minute], from: date).hashValue

    let myAlarmTrigger = UNCalendarNotificationTrigger(dateMatching: dateComponent, repeats: true)

    setupNotificationSettings()

    let identifier = "Your-Notification"
    let request = UNNotificationRequest(identifier: identifier, content: content, trigger: myAlarmTrigger)
    let center = UNUserNotificationCenter.current()
    center.add(request, withCompletionHandler: { (error) in
        if error != nil {
            //TODO: Handle the error
        }
    })
}

有没有办法让它只返回“c”，“d”

Answer 1

arr.groupBy(identity).collect {
  case (str, instances) if instances.length == 1 => str
}

你可以在结尾或任何你想要的地方打电话给.toArray ......

Answer 2

尝试Array#distinct

scala> val arr = Array("a", "a", "b", "b", "c", "d")
arr: Array[String] = Array(a, a, b, b, c, d)

scala> arr.distinct
res0: Array[String] = Array(a, b, c, d)

顺便提一下In Scala how do I remove duplicates from a list?

的副本

如果您只想要非重复值，请按键和出现次数进行存储，然后按出现次数进行过滤。

  it("returns distincts only"){

    val array = Array("a", "a", "b", "b", "c", "d")

    val x = array.groupBy(identity)
      .filter(_._2.length == 1)
      .keys

    assert(x == Set("c", "d"))
  }

Answer 3

这样可行，但我不知道这是否是最好的答案。

arr.groupBy(identity).filter(_._2.length == 1).map(_._1).toArray

这将返回Array（“c”，“d”）

Answer 4

val arr = Array("a", "a", "b", "b", "c", "d")
arr.foldRight(List[String]()){
  case (i,ar )=>
    if (arr.count(_==i)==1)
      i::ar
    else ar
}

Answer 5

或者但基本相同的方法

arr.groupBy(identity).mapValues(_.size).filter(x => x._2 == 1).keys.toArray

Answer 6

arr.groupBy(x=>x).filterNot(_._2.size==2).keys.toArray

Answer 7

答案取决于您想要优化的内容。

让我们说你不介意多次穿越。然后就像，

val answer = array
  .groupBy(identity)
  .filter(_._2.length == 1)
  .map(_._1)
  .toArray

或者，

val answer = array
  .map(s => (s,1))
  .reduceByKey(_ + _)
  .filter({ case (key, count) => count == 1 })
  .map({ case (key, count) => key })
  .toArray

但是让我们说你想在一次遍历中完成它并且不介意使用额外的空间，那么你可以做以下事情，

有一点需要注意的是，我们需要一个已经看过Strings的“商店”，对于我们数组中的每个字符串，我们必须检查是否已经看过它。

所以......这里的重点是为这家商店做出最合适的选择。这个商店最重要的要求是，

“它应提供有效（最好是恒定时间）contains或exists功能”。

因此，Set是我们商店的有效选择。

现在，

val (_, answer) = array
  .foldLeft((Set.empty[String], Set.empty[String]))({
    case ((seen, collected), s) => seen.contains(s) match {
      case true => (seen, collected - s)
      case false => (seen + s, collected)
    }
  })

如何消除scala中数组中出现两次的单词

7 个答案: