Язык Си. Вычисление параметра отбора матриц. Не хватает мощности. Помогите посчитать

[ura_111]

4) И ещё, реагирует ли твой компилятор на ключевое слово "const". Я до недавнего времени был убеждён, что статические массивы в си можно задавать только так:

4.jpg

[Ar2emiS]

1) F5 не работает
памяти хватает

[GreenWizard]

M[0][i2][i3]==rand()%2;

крутое присвоение, блин)

как думаешь, почему и я, и сотни тысяч программистов других, так сильно настаиваем на том же идиотском форматировании? потому мы такие-сякие ******** и советуем херню, вместо реальной помощи, так?)

[ura_111]

"const" пробывал?

Создай новый, пустой проект и попробуй:

5.jpg

[evg_m]

for (n=2; n<=100; n++)
{
    int H[k][n];
    for (a=0.90; a>=0.5; a=a-0.00015)
    {
        p=1;
        D0=a*sqrt(k*n);
         int ***M=(int ***)malloc(c * sizeof(*M));

всего-то n{=100-2} * a{=(0.9 -0.5)/0.00015} ~30000 операций по выделению памяти.
и это не считая выделения памяти в дальнейших вложенных циклах для каждого из ранее использованных циклов (выделений памяти).

 for (i2=0; i2<c; i2++)
	{
	   M[i2]=(int **)malloc(k * sizeof(*M[i2]));
           for (i3=0; i3<k; i3++)
	   {
	  	M[i2][i3]=(int *)malloc(n * sizeof(*M[i2][i3]));
           }
        }

минимизировать операции по выделению (выделить один раз ДО начала циклов с запасом на самый "большой" случай).

[ura_111]

Нет evg_m, человек подсчитал максимально занятую память (я давал такое задание) и ещё привёл скриншот реального заполнения ОЗУ (я заметил, что при запуске программы занято всего лишь 13Мб) - поэтому вопрос с памятью закрыт.
___________________________________ _______________________

Экспериментируй только с копиями программы, а оригинал - не трогай.

Ar2emiS, вот что сделай: во все ключевые места программы (циклы, условия, после циклов....) размести вывод ключевой информации, например:

int main()
{
	//srand(time(NULL)); 
	int l=20000,k=34; 
	int c=2000;                             
unsigned int timer;
int p=1,n,i1,i2,i3,q;
int flag,flag1,flag2=0; 
double dd,D0,D;	
double a;

printf("1) vce perenennue operedelenu\n");

for (n=2; n<=100; n++)
{
    int H[k][n];
    for (a=0.90; a>=0.5; a=a-0.00015)
    {

if (a==выводит, после каждой тысячи прохода цикла)
printf("2) \n");

        p=1;
        D0=a*sqrt(k*n);
         int ***M=(int ***)malloc(c * sizeof(*M));
	 for (i2=0; i2<c; i2++)
	{

if (i2==выводит, после каждого 300-го прохода цикла)
printf("3) \n");

	   M[i2]=(int **)malloc(k * sizeof(*M[i2]));
           for (i3=0; i3<k; i3++)
	   {
	  	M[i2][i3]=(int *)malloc(n * sizeof(*M[i2][i3]));
           }
        }
 ...............................
.................................
................................

Ты понимаешь? Тебя должно интересовать, когда программа зацикливается, а по выводам "ключевых точек" ты можешь кое что об этом сказать.

[GreenWizard]

Лучше бы задание уточнили, а то я тут код его причесал и малость в осадок выпал...... с чем сравнивать матрицы? судя по коду, с первой случайной? тогда её не следует включать в ответ т. к. для неё d = 0.......

нужно найти 20.000 матриц подходящих или сделать 20.000 попыток найти хоть одну матрицу? опять же, судя по коду, второй вариант описан, но тогда массив матриц вовсе не нужен

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

[Ar2emiS]

Да, понял, займусь этим. Спасибо.

[GreenWizard]

Заморочился я и написал, вроде, решение.... сразу предупреждаю:
- писал для стандартного с++11 и не уверен, что та твоя приблуда поймёт код
- старался делать попроще, но есть моменты, которые ну никак проще не написать (или это слишком долго\неудобно)... функции, работа с указателями и т.д.
- задача мне до конца не понятна, увы, поэтому не факт что решил именно твою задачу

Сам код:

#include <stdio.h>                
#include <locale.h>
#include <ctype.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>

typedef unsigned char MATRIX_CELL;

struct TMatrix{
	MATRIX_CELL cells[INT_MAX]; // описываем бесконечную матрицу
};

int matrixSize(int k, int n){
	return(k * n * sizeof(MATRIX_CELL));
}

void fill_matrix(TMatrix* matrix, int* D, int k, int n){
	int N = k * n; // кол-во ячеек в матрице
	int sum = 0;
	for(int i = 0; i < N; ++i) { // избегаем 2-д массива\цикла
		int cell = rand() % 2;
		sum += cell;
		matrix->cells[i] = cell;
	}
	*D = sum; // квадрат расстояния от 0
}

// сортируем расстояния по убыванию (можно быстрее, применив др. алгоритм)
void sortDistByDesc(int* arr, int n){
	//bubble sort
	bool swapped = true;
	int j = 0;
	while (swapped) {
		swapped = false;
		j++;
		for (int i = 0; i < n - j; i++) {
			if (arr[i] < arr[i + 1]) {
				swapped = true;
				int t = arr[i];
				arr[i] = arr[i + 1];
				arr[i + 1] = t;
			}
		}
	}
}

int main(){
	srand(time(NULL)); 
	long timer = clock();

	int totalMatrix = 20000, k = 34; 
	int selectCountMin = 800;
	int selectCountMax = 1600;
	// массив расстояний
	int* distMap = (int*)malloc(totalMatrix * sizeof(int));
	for (int n = 2; n <= 100; n++) {
		int size = matrixSize(k, n); // реальный размер памяти под матрицу

		char* allMatrix = (char*)malloc(totalMatrix * size);
		// заполняем массив матриц и расстояний
		for(int ind = 0; ind < totalMatrix; ind++){
			fill_matrix((TMatrix*)&allMatrix[ind * size], &distMap[ind], k, n);
		}

		int maxD = k * n; // максимальное расстояние между матрицами (квадрат)
		// расстояние до целевой матрицы от нуля
		int targetD = 0; // или distMap[0];
		if(targetD != 0){
			for(int ind = 0; ind < totalMatrix; ind++){
				distMap[ind] = abs(targetD - distMap[ind]);
			}
		}
		
		// сортируем массив расстояний
		sortDistByDesc(distMap, totalMatrix);

		// массив отсортирован, поэтому distMap[selectCountMax + 1] даст такое D
		// которое заведомо даст более selectCountMax + 1 матриц
		unsigned int D = distMap[selectCountMax + 1];
		// ищем такую матрицу, которая удалена более чем на limitMax
		for(int i = selectCountMax; i >= selectCountMin; i--){
			if(distMap[i] > D){
				D = distMap[i];
				// мы нашли такое D, которое даст необходимую нам выборку
				printf("n = %d\n", n);
				double a = (double)D / (double)maxD; 
				printf("a = %.5f\n", a);
				printf("number of matrices = %d\n", i);
				printf("\n");
				break;
			}
		}

		free(allMatrix);
	}

	timer = clock() - timer; 
	printf("time = %.1f\n", (double)timer / CLOCKS_PER_SEC);
	system("pause"); // ожидание нажатия клавиши 
	return 0;
}

Матрицы нигде явно не используются, поэтому allMatrix можно выбросить и сэкономить память\время, но оставил т. к. прирост незначительный скорости
Основное время уходит на сортировку, поэтому можно ещё ускорить процесс, но я не знаю какие вы алгоритмы изучали + лень было т. к. это не совсем те оптимизации, которые мне интересны

Был ещё вариант похожий на твой, но с бинарным перебором (не от 0.5 до 0.9, а типа 0.5 -> 0.75 -> ..... -> 0.51 -> 0.52 -> 0.515 -> ....), но он сложнее, немного медленнее и, главное, был нестабильным (где-то я накосячил, но где - не понять), поэтому не привожу его

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

[Ar2emiS]

Спасибо, обязательно разберу Ваш код.