Вопросы Теги

Вложенное сверление по динамическому списку списка в scala [duplicate]

Вы можете сделать оператор ввода while True loop, чтобы он неоднократно запрашивал вход пользователя и затем прерывал этот цикл, если пользователь вводит ответ, который вам нужен. И вы можете использовать try и except blocks для обработки недействительных ответов. 

while True:

    var = True

    try:
        age = int(input("Please enter your age: "))

    except ValueError:
        print("Invalid input.")
        var = False

    if var == True:
        if age >= 18:
                print("You are able to vote in the United States.")
                break
        else:
            print("You are not able to vote in the United States.")

Переменная var такова, что если пользователь вводит строку вместо целого, программа не будет возвращать «Вы не можете голосовать в Соединенных Штатах ».

2
задан Mika'il 2 May 2014 в 23:29
поделиться

2 ответа

Рекурсивное решение: 

  def generator(x: List[List[Int]]): List[List[Int]] = x match {
    case Nil    => List(Nil)
    case h :: _ => h.flatMap(i => generator(x.tail).map(i :: _))
  }

, которое дает: 

val a = List(List(1, 2, 3), List(4, 5))       
val b = List(List(1, 2, 3), List(4, 5), List(6, 7))

generator(a)    //> List(List(1, 4), List(1, 5), List(2, 4), 
                //| List(2, 5), List(3, 4), List(3, 5))
generator(b)    //> List(List(1, 4, 6), List(1, 4, 7), List(1, 5, 6), 
                //| List(1, 5, 7), List(2, 4, 6), List(2, 4, 7),
                //| List(2, 5, 6), List(2, 5, 7), Listt(3, 4, 6), 
                //| List(3, 4, 7), List(3, 5, 6), List(3, 5, 7))

Обновление: второе case также может быть записано как понимание for, которое может быть немного яснее: 

def generator2(x: List[List[Int]]): List[List[Int]] = x match {
  case Nil    => List(Nil)
  case h :: t => for (j <- generator2(t); i <- h) yield i :: j
}

Обновление 2: для больших наборов данных, если у вас закончилась нехватка памяти, вы можете использовать потоки вместо этого (если имеет смысл обрабатывать результаты пошагово). Например: 

def generator(x: Stream[Stream[Int]]): Stream[Stream[Int]] = 
  if (x.isEmpty) Stream(Stream.empty) 
  else x.head.flatMap(i => generator(x.tail).map(i #:: _))

// NB pass in the data as Stream of Streams, not List of Lists
generator(input).take(3).foreach(x => println(x.toList))

>List(0, 0, 0, 0, 0, 0, 0)
>List(0, 0, 0, 0, 0, 200, 0)
>List(0, 0, 0, 0, 100, 0, 0)
6
ответ дан Ezekiel Victor 20 August 2018 в 14:54
поделиться
  • 1
    Для небольших вложенных списков ваше решение отлично работает, но по какой-то причине для небольшого большего вложенного списка оно взрывается. Я обновил вопрос с точным вложенным списком, который взорвал стек. – Mika'il 2 May 2014 в 22:28
  • 2
    Интересно - он отлично работает для меня, возвращая 1694336 результатов. – DNA 2 May 2014 в 22:30
  • 3
    Странно - я обновил сообщение о том, как я вызываю генератор2 (). Разве это не так, как вы делаете? – Mika'il 2 May 2014 в 22:39
  • 4
    Я добавил внутренние списки один за другим. При добавлении 5-го внутреннего списка он взрывается. Просто не понимаю, почему. Этот список не так велик, как правило, в пределах вычислительной мощности и памяти. – Mika'il 2 May 2014 в 22:43
  • 5
    ОК, у вас заканчивается heap (OutOfMemoryError), а не стек (StackOverflowError). Вероятно, вам просто нужно выделить больше памяти для вашей JVM, используя опцию -Xmx – DNA 2 May 2014 в 22:48

Похоже, ваша проблема может быть описана в терминах рекурсии:

Если у вас есть n списков из списка: int1 list1 размера m и list2, ... list n

  • генерируют комбинации X для списка2 в n (поэтому списки n-1)
  • для каждой комбинации, вы генерируете m новых для каждого значения списка 1.
  • базовый случай равен список одного списка int, вы просто разделили все элементы в списках одиночных элементов.

, поэтому со списком (список (1,2), список (3), список (4, 5) )) результатом вашего рекурсивного вызова является List (List (3,4), List (3,5)), и для каждого вы добавляете 2 комбинации: List (1,3,4), List (2,3,4) , Список (1,3,5), Список (2,3,5).

2
ответ дан vptheron 20 August 2018 в 14:54
поделиться
  • 1
    Да, я просто подумал об этом. Я создаю функцию, которая возьмет тип List [List [Int]] и рекурсивно перейдя по списку, собирая списки по одному и получая их продукт, затем получая следующий список и генерируя продукт с ранее вычисленным продукт. Итак, ((List1 x List 2) x List 3) ... и так далее. – Mika'il 2 May 2014 в 13:16
Другие вопросы по тегам:

Похожие вопросы: