Интересная книга по C++

А, ну да, развернуть цикл - самое простое решение.

Во-первых, а если не 10 элементов (это интереснее)

Если честно, я считаю всю эту задачу полным идиотизом и не понимаю к чему нужны эти ограничения :).

Затем, если нужно больше 2ух чисел - то тогда:

1). (логичное) какая-нибудь NlogN рекурсивная сортировка (quick-sort/merge-sort), но это требует или разрешения доступа к стеку и работы с указателями, или разрешения на использование массивов (опять та же арифметика указателей), что там запретили.

2). (исходя из идиотских ограничений) используя функцию sort3 можно отсортировать весь массив. Следующим образом: просто запускать sort3 с тройками 2-3-4, 3-4-5,...,3-4-5,4-5-6,...,7-8-9. Может и раньше всё отсортируется думать лень. А дальше берёшь нужное кол-во переменных и всё :)

Блин, вот заняться мне нечем... ну ладно, вот быдлокод, который вам нужен.

Почему быдлокод? Очень даже ничего, только аргументы у нас по-значению передаются. Ссылка слишком крутая абстракция, человек только полчаса назад сел читать SICP. Сможете избавиться от swap?

> Программы можно писать вообще на ассемблере, а ЯП придумали для того чтобы писать программы было проще.

ассемблер не ЯП?

А если потребуется искать не 2 а 10 наибольших чисел?

Кстати, мой вариант поддерживает такое усложнение.

s/ЯП/ЯПВУ/

Хорошо. Дадим же пол-часика товарищам mv и Bwglb3. Может быт сишники еще разродятся.

$10

И даже передачу этого числа аргументом функции поддерживает?

P.S. я не тестировал, так что может быть куча мелких опечаток.

Черт, я настолько далек уже от С, что мелкие опечатки меня ввели в ступор. Не могу собрать. Можешь поправить? Очень хочется поиграться с кодом.

$10

Ну раз желающих больше нет то вот решение:

int first_arg_is_maximum(int n, int x, int a, int b, int c, int d, int e, int f, int g, int h, int i) {
    return ( n == 0 )
        ? 1
        : ( x >= a)
            ? first_arg_is_maximum(n - 1, x, b, c, d, e, f, g, h, i, a)
            : 0;
}

int maxn(int n, int a, int b, int c, int d, int e, int f, int g, int h, int i, int j) {
    return (first_arg_is_maximum(9, a, b, c, d, e, f, g, h, i, j))
        ? (n == 0)
            ? a
            : maxn(n-1, 0, b, c, d, e, f, g, h, i, j)
        : maxn(n, b, c, d, e, f, g, h, i, j, a);
}

int square_of_two_biggest(int a, int b, int c, int d, int e, int f, int g, int h, int i, int j) {
    return maxn(0, a, b, c, d, e, f, g, h, i, j) * maxn(0, a, b, c, d, e, f, g, h, i, j)
        + maxn(1, a, b, c, d, e, f, g, h, i, j) * maxn(1, a, b, c, d, e, f, g, h, i, j);
}

Молодец, читай следующую главу SICP.

Это мне напомнило работу со списками в Прологе. Такое же извращение, но в Прологе по-другому никак, а в С можно записать номного понятнее.

Я обожаю LOR

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

Я обожаю LOR

Молодой человек, все же вместо книжек по C++, стоит почитать SICP, и будете гладким и шелковистым Арамисом.

На боковую!

Для пяти аргументов больших нуля:

template <int k>
int prenu(int a, int b, int c, int d, int e) {
  return !(k)*a+!(k-1)*b+!(k-2)*c+!(k-3)*d+!(k-4)*e;
}
template<int k>                                             
int maks(int m1, int m2, int a, int b, int c, int d, int e) {
#define E prenu<k>(a,b,c,d,e)
  return maks<k+1>(  
        (E > m1) ? E : m1,
        (E > m1) ? m1 : ((E > m2) ? E : m2) ,
        a, b, c, d, e);
}

template <>
int maks<5>(int m1, int m2, int a, int b, int c, int d, int e) {
  return m1*m1+m2*m2;
}
int sum(int a, int b, int c, int d, int e) {
  return maks<0>(0,0,a,b,c,d,e);
}

>Exercise 1.3. Define a procedure that takes three numbers as arguments and returns the sum of the squares of the two larger numbers.

Где сказано, что нельзя использовать циклы и массивы&

Читатель о них еще ничего не знает.

не пойдет, в условии разве было сказано, что числа именно целые ? в условии разве было сказано, что можно пользоваться if'ом ?

не катит, ты использовал if, про который сам же и умолчал

>Молодой человек, все же вместо книжек по C++, стоит почитать SICP

Я не понял к чему ты этот бред развёл. Я тебе говорю на C++ удобно декомпозировать сложные задачи в терминах абстракций, а ты как бы в контр-аргумент нашёл какую-то примитивную головоломку из области алгоритмики с жёсткими лисп-заточенными ограничениями.

> не пойдет, в условии разве было сказано, что числа именно целые ? в условии разве было сказано, что можно пользоваться if'ом ?
Нет, Да.
Кстати, я с вами согласен, совершенно глупо отказываться без каких-либо вменяемых причин от привычных абстракций типа массивов, циклов и прочего.

Лучше таки Кнута он дает практические знания и от его чтения не клонит в сон.

Только вся эта практика уже давно есть в готовых библиотеках и обращение к Кнуту - первый шаг на пути разработки велосипеда.

Вот ещё вариант. Быдлокод, но при таких ограничениях сойдёт:

int f(int a0, int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8, int a9) {
 if (a1 > a0) return f(a1, a0, a2, a3, a4, a5, a6, a7, a8, a9);
 if (a2 > a1) return f(a0, a2, a1, a3, a4, a5, a6, a7, a8, a9);
 if (a3 > a2) return f(a0, a1, a3, a2, a4, a5, a6, a7, a8, a9);
 if (a4 > a3) return f(a0, a1, a2, a4, a3, a5, a6, a7, a8, a9);
 if (a5 > a4) return f(a0, a1, a2, a3, a5, a4, a6, a7, a8, a9);
 if (a6 > a5) return f(a0, a1, a2, a3, a4, a6, a5, a7, a8, a9);
 if (a7 > a6) return f(a0, a1, a2, a3, a4, a5, a7, a6, a8, a9);
 if (a8 > a7) return f(a0, a1, a2, a3, a4, a5, a6, a8, a9, a9);
 if (a9 > a8) return f(a0, a1, a2, a3, a4, a5, a6, a7, a9, a8);

 return a0*a0 + a1*a1;
};

самая грамотная книга для начала: C++ для профессионалов (Professional C++)

> С программированием знаком, хотелось бы изучать именно C++, а не основы программирования.

Страуструп и Алексадреску.

не, не, не, после голого С нихрена не понятно

Да есть, но важно понимать как устроены внутри библиотеки.

Впрочем у меня пока-что сложилось впечатление, что C++ на редкость перегруженная поебота, хотя это и не удивительно, смесь архаичного препроцессора, низкоуровневых хаков и неявнго приведения типов C, уродливой объектной модели, ужасной реализации метапрограммирования на подобии брейнфака и нежизнеспособных попыток создать возможности для fp превратили его в кашу из говна.

поначалу так оно и бывает :) со временем всё встанет на места

да, хотите проникнуться - изучайте исходники хороших проектов

это кстати лучше чем оригинал, ибо читабельно :)

Например, в STL очень унылая очередь с приоритетами. Прикажете искать по другим библиотекам?

Впрочем, вру. Как очередь с приоритетами она может и хороша. Просто для многих алгоритмов бывает полезна старая добрая куча (heap), которая у нее в обрезаном виде внутри, а необрезанной - нету.

>поначалу так оно и бывает :) со временем всё встанет на места

Мне кажется это уже диагноз и пациент неизлечим. У меня до прочтения Страуструба тоже были некоторые предрассудки насчёт С++, но потом торкнуло, особенно последние главы про проектирование, когда вся мозаика складывается в удивительную картину.

Ну раз желающих больше нет то вот решение:

int first_arg_is_maximum(int n, int x, int a, int b, int c, int d, int e, int f, int g, int h, int i) { 
    return ( n == 0 ) 
        ? 1 
        : ( x >= a) 
            ? first_arg_is_maximum(n - 1, x, b, c, d, e, f, g, h, i, a) 
            : 0; 
} 
 
int maxn(int n, int a, int b, int c, int d, int e, int f, int g, int h, int i, int j) { 
    return (first_arg_is_maximum(9, a, b, c, d, e, f, g, h, i, j)) 
        ? (n == 0) 
            ? a 
            : maxn(n-1, 0, b, c, d, e, f, g, h, i, j) 
        : maxn(n, b, c, d, e, f, g, h, i, j, a); 
} 
 
int square_of_two_biggest(int a, int b, int c, int d, int e, int f, int g, int h, int i, int j) { 
    return maxn(0, a, b, c, d, e, f, g, h, i, j) * maxn(0, a, b, c, d, e, f, g, h, i, j) 
        + maxn(1, a, b, c, d, e, f, g, h, i, j) * maxn(1, a, b, c, d, e, f, g, h, i, j); 
} 

Ты и правда думаешь, что эта простыня легче для понимания хоть кому-нибудь, кроме сферического читателя SICP в вакууме? А по-моему, даже этому читателю в вакууме проще будет освоить циклы.

Посмотри: «Фундаментальные алгоритмы на С++ в 2х частях» - Роберт Седжвик, мне интересны были книжки по типу «Разработка сетевых приложений в Unix» (правда тут больше не ООП)

>Ты и правда думаешь, что эта простыня легче для понимания хоть кому-нибудь, кроме сферического читателя SICP в вакууме?

Она и у читателя SICP не самые прекрасные чувства вызывает - код просто жесток и ужасен.

> «Фундаментальные алгоритмы на С++ в 2х частях» - Роберт Седжвик

хорошая книжка, но в бумажном варианте сейчас не найдешь

>C++ выпрямляет мозги в направлении грамотного ООП

Что??? Ты грамотное ООП то видел? В плюсах оно весьма и весьма паршивенькое.

Хочется грамотного ООП - прямая дорога к языкам, которые не поощряют применения других парадигм. Smalltalk, например.

>Хочется грамотного ООП - прямая дорога к языкам, которые не поощряют применения других парадигм. Smalltalk, например.

Хочется научиться бегать - прямая дорога к отпиливанию рук.

> Что??? Ты грамотное ООП то видел? В плюсах оно весьма и весьма паршивенькое.

в плюсах оно быстрое, а то что неполное - так это даже плюс, на ЛОР «гуру» такие извращенные решения приводили, например, с перебором полей в рантайме, что хочется заставить их всю жизнь заниматься разбором такого чужого кода, где от простого добавления поля в абсолютно левом месте может что-то отвалиться

«Фундаментальные алгоритмы на С++ в 2х частях» - Роберт Седжвик

хорошая книжка, но в бумажном варианте сейчас не найдешь

зато в электронном виде - влёт, даже на русском есть :)

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

C++ выпрямляет мозги в направлении грамотного ООП

Что??? Ты грамотное ООП то видел? В плюсах оно весьма и весьма паршивенькое.

Хочется грамотного ООП - прямая дорога к языкам, которые не поощряют применения других парадигм. Smalltalk, например.

давайте заканчивать уже фапать на «Шварц» и махать ссаной тряпкой пожелтевшими пергаментами

> но для изучения С++ совсем не то

по хорошем надо учить сначала С, потом С++, а потом писать именно на таком «суржике», ИМХО

но для изучения С++ совсем не то

по хорошем надо учить сначала С, потом С++, а потом писать именно на таком «суржике», ИМХО

здесь сложно возражать, главное только суржиком в меру увлекаться :)

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

в общем для алгоритмов - самое оно, для изучения С++, повторюсь, не стал бы рекомендовать

Вот ещё вариант. Быдлокод, но при таких ограничениях сойдёт:

Эта функция неверна. Вы почему то неверно поняли условие и написали функцию, возвращающую удвоенный квадрат максимального числа.

Как такой вариант?

#include <vector>
using std::vector;

double max(const double &a,const double &b) {
	return a < b?b:a;
}

double sqr(const double & a) {
	return a * a;
}

double f (const vector<int> & Numbers, double used = -1) {
	double ans = -1;
	if (used != -1) {
		for (int i = 0; i < (int)Numbers.size(); ++i)
			if (i != used)
				ans = max(ans,sqr(Numbers[i]) + sqr(Numbers[used]));
	}
	else
		for (int i = 0; i < (int)Numbers.size(); ++i)
			ans = max(ans, f(Numbers,i));
	return ans;
}

гы. для с++ задачу надо формулировать так:

*во время компиляции* посчитать сумму квадратов двух максимальных элементов статически определенного константного массива — тогда вопросы «что можно, что нельзя» отпадут

видимо первая часть решения будет борьба с языком (т.к. int x[const_array[2]]; запрещен), а вторая — решение, умещается в 10 строк кстати.

включая пустые и строки с одной скобкой