val evenMax = numbers.toStream.filter( _ % 2 == 0).max val oddMax = numbers.toStream.filter( _ % 2 == 1).max чем плохо такое решение, кстати

val evenMax = numbers.toStream.filter( _ % 2 == 0).max val oddMax = numbers.toStream.filter( _ % 2 == 1).max чем плохо такое решение, кстати

два раза фильтруешь и сортируешь

и эксепшн кидается на пустой список

А еще есть проблема, же, что возвращать если нет чётных чисел,или нечётных, или вообще, что функция должна возвращать.

два раза фильтруешь и сортируешь

сортировки не должно быть

)

очень загадочно, если я ошибась, прошу указать на мою ошибку, дабы я устранил своё невежество в данном вопросе, пожалуйста

да, я не правильно написал, max и min для стрима это редьюс лефт

как и для списка

если не ошибаюсь, оба наследуют траверсабл ванс

val evenMax = numbers.toStream.filter( _ % 2 == 0).max val oddMax = numbers.toStream.filter( _ % 2 == 1).max чем плохо такое решение, кстати

numbers.toStream.partition(_ % 2 == 0).map(_.max)

можно не конвертировать в стрим; думаю такая же сложность будет

numbers.toStream.partition(_ % 2 == 0).map(_.max)

map на Tuple?

Хмм

Жаль, потом обратно затупливать придется

numbers.toStream.partition(_ % 2 == 0).map(_.max)

память будет использоваться дополнительная

нет?

Ай дунно

Хренью страдаете

а это важно

Решается в два прохода

По коллекции

нужен код

просто fold и в 1 проход, нет?

Тока на f# могу :)

Тока на f# могу :)

я тебя наслушался, немного посмотрел туда, там прикольно

В целом можно в один прохход без фолда

Две переменные под максимумы

Если фолд, то в качестве аккума tuple

Он же кортеж

Тут ключевой вопрос, что делать с валидацией данных

l.foldLeft[(Option[Int], Option[Int])]((None, None)) { case ((odd, even), v) => if (v % 2 == 0) (odd.map(m => math.max(m, v)), even) else (odd, even.map(m => math.max(m, v))) }

хотя нет, днище

почему? по-моему норм

осталось причесать

none всегдя маппиться в none

Можно if в гварды засунуть

Можно даже сравнение туда засунуть

Будет аккуратно и читабельно, но много печатать

там надо нулём инициализировать и отдельно проверять на пустоту

а если максимум отрицательный? )

ну MINVALUE

а если максимум отрицательный? )

чётность не опредлена же для отрицательных чисел ?

не?

для всех целых

N, вот это всё

Да, ошибся, прошу прощения

как то так: val l = List(1,2,3,4) def max(v: Int, prevValue: Option[Int]) = { prevValue match { case None => v case Some(x) => math.max(v, x) } } l.foldLeft[(Option[Int], Option[Int])]((None, None)) { case ((odd, even), v) => if (v % 2 == 0) (Some(max(v, odd)), even) else (odd, Some(max(v, even))) }

var odd = Option.empty[Int] var even = Option.empty[Int] for (i <- numbers) { if (i ℅ 2 == 0) odd match { case Some(old) if old < i => odd = Some(i) case None => odd = Some(i)

ну и для нечетных

Без фолда поинтереснее

лениво с моба писать все

интересно, можно ли не писать "odd = Some(i)" дважды, как-то вывернуть этот иф

varчики подъехали

var odd = Option.empty[Int] var even = Option.empty[Int] for (i <- numbers) { if (i ℅ 2 == 0) odd match { case Some(old) if old < i => odd = Some(i) case None => odd = Some(i)

java style detected

как будто что-то плохое

Будет аккуратно и читабельно, но много печатать

l.foldLeft[(Option[Int],Option[Int])]((None, None)) {   case ((Some(odd), even), v) if v % 2 == 1 && odd < v => (Some(v), even)   case ((odd, even), v) if v % 2 == 1 => (odd, even)   case ((odd, Some(even)), v) if even > v => (odd, Some(v))   case ((odd, even), v) => (odd, even) }

а теперь добавь ещё аналогичные минимумы

Можно не разделять odd и even на 2 и 4 строчке, вместо v написать _

а теперь добавь ещё аналогичные минимумы

Там есть

не, я про поиск 4 чисел

мин/макс чет/нечет

ERROR: S client not available

у фолда сложность линейная

(количество кода, который надо добавить)

да просто скомпозить два моноида

Мне нравится этот подход !

<dependency> <groupId>org.scalaz</groupId> <artifactId>scalaz-core_${scala.suffix.version}</artifactId> </dependency> врывается в тред , да у меня нет sbt на проекте :(

противник джава стайла)

да просто скомпозить два моноида

самое забавное, что, в общем случае, нельзя (надо руками, не автомагически)

val l = List(1,2,3,4) def value(v: Int, prevValue: Option[Int], f: (Int, Int) => Int) = { prevValue match { case None => Some(v) case Some(x) => Some(f(v, x)) } } case class Result(a: Option[Int], b: Option[Int], c: Option[Int], d: Option[Int]) l.foldLeft(Result(None, None, None, None))((r, v) => if (v % 2 == 0) r.copy(a = value(v, r.a, math.min), b = value(v, r.b, math.max)) else r.copy(c = value(v, r.c, math.min), d = value(v, r.d, math.max)) )

общий то зачем

#codegolfday

сделать два инстанса полугруппы для Even и Odd и потом xs.fold[(Option[Even], Option[Odd])]

Имхо Int на Long стоит заменить

Имхо Int на Long стоит заменить

или какую-нибудь магию с тайп-классами

чтобы тип вообще не указывался, а выводился из коллекции

Я сделяль...

let findMax (x:int option) (y:int option)= match x,y with |Some a ,Some b->Some (Math.Max(a,b)) |Some a,_->x |_,Some b->y |_,_->None let isEven (number:int option)= match number with |Some x when x%2=0->Some true |Some x when x%2<>0->Some false |_->None let calcMax arr = arr|>Seq.fold (fun (even,odd) x-> match isEven x with |Some true-?findMax even x),odd) |Some false-?even,(findMax odd x)) |_-?even,odd))

Типизация по вкусу соответственно

в F# смайликами программируют?

у тебя ненужное условие в isEven

да и функция работает неправильно)

хотя там же инт на входе, тогда просто ненужное

Там опшн на входе

Опшн на выходе

тощно)

В условии у нас коллекция опшнов, соответственно и работаем с опшнами по возможности

`lpus.map(lpu => Seq(lpuButton(lpu))) :+ order.fold(collapseButton)(o => ((if (o > 1) Seq(prevButton(o)) else Seq()) :+ showAll) ++ (if (hasNext) Seq(nextButton(o)) else Seq()))`

Так годно? ? Или еще что-нить подкрутить стоит. http://scastie.org/23939

да вроже норм

только двойные скобки убрать

( o => { }) -> { o => }

да, точно проглядел