sort -> sublist -> fold

Нужно именно красивее? Ну тогда в список, потом sort descending, потом take(2), потом map, потом sum

А если без использования списков, тогда как?

sub twomaxum {
    my $sum += $_ * $_ for ( sort {$b <=> $a} @_ )[0, 1];
    return $sum;
}

работает не только с тремя переменными, а вообще с списком чисел. Ограничить количество можно procname($$$).

Если без списков, то это будет не задача на знание Scala. Действительно, будет что-то на подобии

val min = min(a,min(b,c))

a*a+b*b+c*c-min*min

min статически заимпортируй из scala.math

А готовый код покажите, а

Ruby

f = ->(x,y,z){->(l){l.map{|e|e**2}.inject(:+)-l.min**2}[[x,y,z]]}
f[1,2,3] # => 2**2 + 3**2 = 13

Жесть

В существующем решении такие недостатки:

• Непонятно зачем изобреать функцию min, которая и так есть в библиотеке. Тем более не понятно зачем min реализован над тремя параметрами, тогда как остальная логика работает со списками
• Fold + оператор «жопы» вместо использования стандартной функции sum
• Складывание трех квадратов и с последующим вычитанием явно лишняя работа
• Использование List вместо Seq
• Ключевое слово «return» считается дурным тоном, тем более что тут в нем нет необходимости
• В функцию map надо передавать напрямую функцию square без лямбды
• У внутренних функций можно опустить определение типа возвращаемого значения и убрать лишние скобки

В первом приближении все это можно заменить на однострочник:

Seq(1, 2, 3).sorted.drop(1).map(x => x*x).sum

Оно?

    def scalaWay(a: Int, b: Int, c: Int): Int =
    {
      return List(a,b,c).sortWith(_>_).take(2).map (x => x*x).foldLeft(0)(_ + _)
    }

1) У коллекций есть

def sorted[B >: A](implicit ord: math.Ordering[B]): List[A].

2) Используй sum

3) Вроде просто square или square _ должны работать

Спасибо за развернутый ответ.

использование Ordering лучше, чем решение, которое предложил maxcom? Если да, то почему?

Я думаю что лучше его решение

решение на других языках тоже с удовольствием гляну

   a =: +/@:(^&2)@:(0 1 &{)@:({~)\:
   a 6 1 2
40

Вот и подумай, стоит ли вообще писать такие портянки

А это какой язык? О_о

J

Haskell

twoMaxSquareSum xs = sum . map (^2) $ filter (/= minimum xs) xs

это для списков

списки, правда, только трёх элементов.

Clojure

(fn [& numbers] (apply + (map #(* % %) (-> numbers sort rest))))

Уел.

Какая она отвратительная!

twoMaxSquareSum xs = sum . map (^2) $ filter (/= minimum xs) xs

Я так и не распарсил. (/= minimum xs). Как я понимаю, частичное применение, да? Непонятно почему не (/= (minimum xs)). А то вроде получается, что первый аргумент /= это minimum, а второй - xs. В общем, Haskell безумно трудный и нелогичный ;)

У тебя даже круче вышло! А мой вариант можно переписать короче на J?

абсолютно согласен :)

Я думаю со всеми «красивыми» вариантами что тут привели вас пинком выкинут на улицу, потому что для продакшн кода нужны не умение запихнуть решение в как можно более короткую строку, а читабельность и производительность, именно в таком порядке. Поэтому sort'ам вашим сразу вспомнят оверхед для 3 чисел, а не для трёх - nlogn сложность вместо достаточной тут n. А всему вместе - дикую вырвиглазность (замечу что скаловые варианты читаются не лучше чем перловый). Вариант maxcom'а ещё куда ни шло, хотя там и sort.

На C я бы, наверное, принял без претензий только такой вариант:

int twoMaxSquareSum(int a, int b, int c) {
    if (a <= b && a <= c) 
        return b*b + c*c;
    else if (b <= a && b <= c)
        return a*a + c*c;
    return a*a + b*b;
}   

Функционально уж, я думаю, придумаете как это переписать.

Я думаю со всеми «красивыми» вариантами что тут привели вас пинком выкинут на улицу

Ты ошибаешься.

На собеседовании был предложен примерно такой вариант. Интересно стало как ещё можно решить эту задачу

А мой вариант можно переписать короче на J?

Я его даже разпарсить не могу. ;) Не люблю за это J.

Там всё просто

@: - это композиция,

& - частичное применение: a&f дает a f x.

({~)\: - это hook. (fg) x= x f (g x)

~ для коммутации. x f~ y = y f x

\: - дает индексы в отсортированном порядке

{ - взятие элементов по индексу(ам)

Но у тебя прям всё очень коротко. Наверное, особая магия

«Программист на Фортране может написать программу на Фортране на любом языке программирования».

Просто на C нет всех этих вкусностей. А так уж поверь, кому будет охота читать эти портянки, когда всё можно уложить в 1 строку (если она только не вида %$&^%*%^#*^#*422 3443)

На C можно и элегантней решить:

#define min(a, b) (*(a) < *(b) ? (a) : (b))
#define min3(a, b, c) (min(a, min(b, c)))

int
sum(int a, int b, int c)
{
        int *p = min3(&a, &b, &c);

        *p = 0;

        return a*a + b*b + c*c;
}

Эк как ты здорово придумал!

Но у тебя прям всё очень коротко. Наверное, особая магия

На самом деле просто ренение в лоб. ;) С заду на перёд:

*2 — квадрат

⍵[⍒⍵] — сортируем правый аргумент в обратном порядке (grade down)

2↑ — берём первых 2 элемента (take)

+/ — суммируем

Тут даже намёка на элегантность нет. Этот код запутаннее, длиннее и медленнее.

ох надо же! а define обязательно использовать или его можно легко заменить на функцию? я как-то в этом так и не разобрался...

если я не ошибаюсь, дефайны вроде как быстрее работают

def foo(x, y, z):
    return sum(i*i for i in list(sorted((x, y, z)))[1:])

print foo(1, 2, 3)

мой идеальный быдлокод

Извините, но что это за херня?!

Непонятно почему не (/= (minimum xs))

minimum имеет приоритет перед (/=)

но вообще там, кажется, будет правая свертка, то есть функция "(/= minimum)", принимающая xs

UUUNLIMITED CRAPCODE WORKS!

def do_it(first, second, add_this):
    if first > second:
        return [second, first**2 + add_this]
    else:
        return [first, second**2 + add_this]

a, b, c = 5, 7, 6
print(do_it(a, *do_it(b, c, 0))[1])

это восхитительно!

Сам ржу.

EcmaScript 6:

f = (...args) => args.sort((x, y) => y - x)
                     .slice(0, 2)
                     .map((x) => x * x)
                     .reduce((a, x) => a + x);

Ruby:

def f(*args)
  args.sort.slice(-2, 2).map {|x| x*x}.reduce(:+)
end