Uložení čísla do matice podle souřadnic – C / C++ – Fórum – Programujte.com

Ahoj, jak byste řešili následující problém:

mám dvě pole line a column v nichž jsou například uloženy tyto znaky line = SSAA, column = dbdc. Tyto prvky po odstranění duplicity tvoří nadpisový rámec tabulky (viz níže).

No a já bych teď potřeboval podle kombinace prvků z pole line a column vytvořit čísla, která by představovali souřadnice. Pravidlo by fingovalo tak, že by se vždy vzal první znak z line a první znak z column. Například pro první znak by to bylo A a d - čili souřadnice by byla [A, d]. A do tabulky by se tedy uložila hodnota 1. U druhého znaku by to bylo zase S a b - [S, b]. Do tabulky by se uložila 2.

Je mi jasné, že musím vytvořit dvourozměrné pole, tedy matici. Ale nenapadá mě, jak zajistit to ukládání čísel...

Co ti brani spravyt toto?

matica[0][0] = 1;
matica[1][1] = 2;

vytvoris si prekladac ... dve polia jedno pre index riadkov a jedno pre index stlpcov ... ked dostanes a,A tak najdes "a" v prvej a ziskas poziciu ... to iste spravis s druhou suradnicou ...

No já se to snažím vyřešit tak, že projíždím vytvořenou matici a hledám v ní uložené prvky, které se rovnají prvnímu znaku v poli orig_line a orig_column. Když tyto prvky najdu, tak sečtu souřadnice prvků v matici, čímž dostanu výslednou souřadnici pro uložení čísla 1. Ovšem nedaří se mi přijít na řešení, které by bylo v C funkční.. V kódu níže se jedná o ty tři vnořený for cykly (vím že je to takhle špatně, ale už fakt nevím co s tím).. 

orig_line a orig_column je to původní pole s duplicitními prvky

line a column je pole bez duplicit (potřebné jen pro nadpisový řádek a sloupec v tabulce)

void create_table (char *orig_line, char* orig_column, char *line, char *column)
{
	int a = strlen(line);
	int b = strlen(column);
	char matrix [a] [b];
	matrix [0] [0] = 'M';
	
	/* Naplneni matice znaky pro nadpisovy sloupec v tabulce */
	int i;
	for (i = 0; i < a; i++)
	{
		matrix [i+1] [0] = line[i];
	}
	
	/* Naplneni matice znaky pro nadpisovy radek v tabulce */
	int j;
	for (j = 0; j < b; j++)
	{
		matrix [0] [j+1] = column[j];
	}
	
	/* Naplneni matice pravidly (ciselne hodnoty) */
	int k;
	int x;
	int y;
	for (k = 1; k <= strlen(orig_line); k++)
	{
		for (x = 0; x < a; x++)
		{
			for (y = 0; y < b; y++ )
			{
				if (matrix [x] [y] == orig_line[k] || matrix [x] [y] == orig_column [k]) /* Pri iteraci je to blbost, ale jak jinak? */
				{
					matrix [x+x] [y+y] = k; /* Secteni takhle je taky blbost, ale taky nevim, jak to vyresit jinak */
				}
			}
		}
	}
}

Tak mě napadlo tohle řešení, ale furt nefunguje... procházel jsem to znak po znaku a mělo by to takhle fungovat, tak už nevim..

	/* Naplneni matice ciselnymi hodnoty podle danych souradnic */
	int g_line_coordinate;
	int h_line_coordinate;
	int g_column_coordinate;
	int h_column_coordinate;
	int iter_line;
	int iter_column;
	
	int global;
	for (global = 1; global <= strlen(orig_line); global++)
	{
		int g;
		for (g = 0; g < a; g++)
		{
			int h;
			for (h = 0; h < b; h++)
			{
				if (matrix [g] [h] == orig_line[global])
				{
					g_line_coordinate = g;
					h_line_coordinate = h;
					iter_line = global;
				}
				if (matrix [g] [h] == orig_column[global])
				{
					g_column_coordinate = g;
					h_column_coordinate = h;
					iter_column = global;
				}
				if (iter_line == iter_column)
				{
					int g_result = g_line_coordinate + g_column_coordinate;
					int h_result = h_line_coordinate + h_column_coordinate;
					matrix [g_result] [h_result] = iter_line;
				}
			}
		}
	}

#5 Sprinter

Ja nemam vobec predstavu co sa snazis vytvorit.
Skus rucne vyplnit tu maticu co si ukazal v prvom poste napr takto( mozno to potom pochopim   ): 

	d	b	c
S	(1)	(1+2)	(7-2)
A	(8-1)	(2)	(3)

Ok, takže zadání je například takové (tedy to co já zadávám na vstupu):

S:aAS S:b A:bA A:a

No a nyní rozdělím tyto "slova" podle mezer:

S:aAS

S:b

A:bA

A:a

Potom vezmu pouze první znak a znak, který je hned za dvojtečkou, čili (a oboje uložim do pole):

orig_line = S, S, A, A

orig_column = a, b, b, a

Po odstranění duplicitních znaků dostanu nové pole:

line = S, A

column = a,b

Z pole line a column vytvořím nadpisovou řádku a sloupec tabulky:

Tak a teď se vrátím k poli orig_line a orig_column. A "imaginárně " je očísluji od jedné (píši imaginárně, protože v kódu postačí zjistit délku pole a pak jen iterovat - obě pole budou vždy stejně dlouhé):

No a nyní budu tyto čísla podle znaků ukládat do matice. Takže pro hodnotu 1 to bude takto:

Po projetí všech znaků bude celá tabulka vypadat takto:

No a problém, který řeším je právě to vkládání čísel do matice. V současné době mám napsáno toto:

/* Naplneni matice ciselnymi hodnoty podle danych souradnic */
int g_line_coordinate;
int h_line_coordinate;
int g_column_coordinate;
int h_column_coordinate;
int iter_line;
int iter_column;
	
int global;
for (global = 1; global <= strlen(orig_line); global++)
{
	int g;
	for (g = 0; g < a; g++)
	{
		int h;
		for (h = 0; h < b; h++)
		{
			if (matrix [g] [h] == orig_line[global])
			{
				g_line_coordinate = g;
				h_line_coordinate = h;
				iter_line = global;
			}
			if (matrix [g] [h] == orig_column[global])
			{
				g_column_coordinate = g;
				h_column_coordinate = h;
				iter_column = global;
			}
		}
		
	}
	if (iter_line == iter_column)
	{
		int g_result = g_line_coordinate + g_column_coordinate;
		int h_result = h_line_coordinate + h_column_coordinate;
		matrix [g_result] [h_result] = iter_line;
	}
}

#7 Sprinter
V podstate ti staci daco taketo:

#include <stdio.h>
#include <assert.h>
#include <string.h>

unsigned get_index(const char* str, char c){
	for(unsigned i = 0; str[i] != '\0'; ++i)if(str[i] == c)return i;
	assert(0 && "chyba v get_index");
}

void create_table (const char* orig_line, const char* orig_column, const char* line, const char* column){
	char matrix [strlen(line)][strlen(column)];	//radsej to prerob na malloc/calloc/...

	//vynulovanie matice
	for(unsigned i = 0; line[i] != '\0'; ++i)
		for(unsigned j = 0; column[j] != '\0'; ++j)
			matrix[i][j] = 0;
	

	for(unsigned i = 0; orig_line[i] != '\0' && orig_column[i] != '\0'; ++i)
		matrix[get_index(line, orig_line[i])][get_index(column, orig_column[i])] = (i + 1);
	
	//vypisanie matice:
	for(unsigned i = 0; line[i] != '\0'; ++i){
		for(unsigned j = 0; column[j] != '\0'; ++j)
			printf("%d\t", matrix[i][j]);
		printf("\n");
	}

}

int main(){
    char* orig_line = "SSAA";
    char* orig_column = "abba";
    char* line = "SA";
    char* column ="ab";

    create_table(orig_line, orig_column, line, column);
    return 0;
}

Zkusil jsem to přepsat do mého zdrojáku a fungovalo to pouze, když jsem tam neměl plnění pro nadpisový řádek a sloupec (v podstatě je tam teď o jeden řád větší matice).. Nemůžu přijít co v tom vašem kodu upravit, aby fungoval respektoval tu zvětšenou matici... nevěděl byste?

void create_table (char* orig_line, char* orig_column, char* line, char* column)
{
	int a = strlen(line);
	int b = strlen(column);
	char matrix [a+1] [b+1];
	
	/* Inicializace matice */
	int n;
	for (n = 0; n <= a; n++)
	{
		int m;
		for (m = 0; m <= b; m++)
		{
			matrix [n] [m] = ' ';
		}
	}
	matrix [0] [0] = 'M';
	
	/* Naplneni matice znaky pro nadpisovy sloupec v tabulce */
	int e;
	for (e = 0; e < a; e++)
	{
		matrix [e+1] [0] = line[e];
	}
	
	/* Naplneni matice znaky pro nadpisovy radek v tabulce */
	int f;
	for (f = 0; f < b; f++)
	{
		matrix [0] [f+1] = column[f];
	}
	
	/* Naplneni matice ciselnymi hodnotami dle danych souradnic */
	int iter;
	for (iter = 0; orig_line[iter] != '\0' && orig_column[iter] != '\0'; iter++)
	{
		matrix [get_index(line, orig_line[iter])] [get_index(column, orig_column[iter])] = (iter + 1);
	}
	
	/* Vypsani rozkladove tabulky (matice) */
	printf("Tabulka:\n");
	int x;
	for (x = 0; x <= a; x++)
	{
		int y;
		for (y = 0; y <= b; y++)
		{
			printf("%c   ", matrix [x] [y]);
		}
		printf("\n");
	}
}


unsigned get_index (const char* str, char c)
{
	for (unsigned i = 0; str[i] != '\0'; i++)
	{
		if (str[i] == c)
		{
			return i;
		}
	}
	assert(0 && "Chyba v get_index");
}

Ak by si to chcel vlozit do tej matice tak musis prerobit vsetky cykly. Musel by si ich indexovat od 1, nemozes pouzit na ukoncenie cyklu porovnavanie xxx != '\0', ....

Jednoduhsie je len upravyt vypis:

	//vypisanie matice:
	printf("M");
	for(unsigned j = 0; column[j] != '\0'; ++j)
		printf("\t%c", column[j]);
	printf("\n");
		
	for(unsigned i = 0; line[i] != '\0'; ++i){
		printf("%c\t", line[i]);
		for(unsigned j = 0; column[j] != '\0'; ++j)
			printf("%d\t", matrix[i][j]);
		printf("\n");
	}

Jasný, upravil jsem výpis a už to dělá to co má, děkuji :-) Měl bych ještě poslední dotaz. Může se stát, že na vstupu budou následující znaky:

S:dSA S:bAc A:dA A:c

pole orig_line pak bude obsahovat {S, S, A, A} a pole orig_column {d, b, d, c}

Když nechám vypsat tabulku, vypadá následovně:

Ovšem to je chybné - čísla 98 a 32 tam nemají co dělat, správně by tabulka měla vypadat takto:

Je mi jasné, že se tam bude muset přidat podmínka, ale nevim jaká (napadá mě jen projet matici a pokud narazí na dvouciferné číslo, tak ho nebude vypisovat... ale to není moc dobré, navíc nevim jistě zda ty čísla, které tam nepatří budou vždy dvouciferné)

Přikládám ještě můj současný zdroják.

/*
*	Funkce vytvori matici prvku ze ktere posleze vypise rozkladovou tabulku
*/
void create_table (char* orig_line, char* orig_column, char* line, char* column)
{
	int a = strlen(line);
	int b = strlen(column);
	char matrix [a+1] [b+1];
	
	/* Inicializace matice */
	int n;
	for (n = 0; n <= a; n++)
	{
		int m;
		for (m = 0; m <= b; m++)
		{
			matrix [n] [m] = ' ';
		}
	}
	matrix [0] [0] = 'M';
	
	/* Naplneni matice znaky pro nadpisovy sloupec v tabulce */
	int e;
	for (e = 0; e < a; e++)
	{
		matrix [e+1] [0] = line[e];
	}
	
	/* Naplneni matice znaky pro nadpisovy radek v tabulce */
	int f;
	for (f = 0; f < b; f++)
	{
		matrix [0] [f+1] = column[f];
	}
	
	/* Naplneni matice ciselnymi hodnotami dle danych souradnic */
	int iter;
	for (iter = 0; orig_line[iter] != '\0' && orig_column[iter] != '\0'; iter++)
	{
		matrix [get_index(line, orig_line[iter])] [get_index(column, orig_column[iter])] = (iter + 1);
	}
	
	/* Vypsani rozkladove tabulky (matice) */
	printf("Tabulka:\n");
	printf("M");
	int x;
	for (x = 0; column[x] != '\0'; x++)
	{
		printf("\t%c", column[x]);
	}
	printf("\n");
	int z;
	for (z = 0; line[z] != '\0'; z++)
	{
		printf("%c\t", line[z]);
		int y;
		for (y = 0; column[y] != '\0'; y++)
		{
			printf("%d\t", matrix [z] [y]);
		}
		printf("\n");
	}
}


/*
*	Funkce pro zjisteni indexu pole
*/
unsigned get_index (const char* str, char c)
{
	for (unsigned i = 0; str[i] != '\0'; i++)
	{
		if (str[i] == c)
		{
			return i;
		}
	}
	assert(0 && "Chyba v get_index");
}

Chba je vo vypise:

printf("%d\t", matrix [z] [y]);
//treba nahradit s:
printf("%c\t", matrix [z] [y]);

Potom treba zmenit:

 = (iter + 1);
//na:
 = '0' + (iter + 1);

Tak kód jsem upravil, ale teď vypisuje toto:

Nechápu, proč zrovna znak b to vypsalo takhle do tabulky...

/*
*	Funkce vytvori matici prvku ze ktere posleze vypise rozkladovou tabulku
*/
void create_table (char* orig_line, char* orig_column, char* line, char* column)
{
	int a = strlen(line);
	int b = strlen(column);
	char matrix [a+1] [b+1];
	
	/* Inicializace matice */
	int n;
	for (n = 0; n <= a; n++)
	{
		int m;
		for (m = 0; m <= b; m++)
		{
			matrix [n] [m] = ' ';
		}
	}
	matrix [0] [0] = 'M';
	
	/* Naplneni matice znaky pro nadpisovy sloupec v tabulce */
	int e;
	for (e = 0; e < a; e++)
	{
		matrix [e+1] [0] = line[e];
	}
	
	/* Naplneni matice znaky pro nadpisovy radek v tabulce */
	int f;
	for (f = 0; f < b; f++)
	{
		matrix [0] [f+1] = column[f];
	}
	
	/* Naplneni matice ciselnymi hodnotami dle danych souradnic */
	int iter;
	for (iter = 0; orig_line[iter] != '\0' && orig_column[iter] != '\0'; iter++)
	{
		matrix [get_index(line, orig_line[iter])] [get_index(column, orig_column[iter])] = '0' + (iter + 1);
	}
	
	/* Vypsani rozkladove tabulky (matice) */
	printf("Tabulka:\n");
	printf("M");
	int x;
	for (x = 0; column[x] != '\0'; x++)
	{
		printf("\t%c", column[x]);
	}
	printf("\n");
	int z;
	for (z = 0; line[z] != '\0'; z++)
	{
		printf("%c\t", line[z]);
		int y;
		for (y = 0; column[y] != '\0'; y++)
		{
			printf("%c\t", matrix [z] [y]);
		}
		printf("\n");
	}
}

/*
*	Funkce pro zjisteni indexu pole
*/
unsigned get_index (const char* str, char c)
{
	for (unsigned i = 0; str[i] != '\0'; i++)
	{
		if (str[i] == c)
		{
			return i;
		}
	}
	assert(0 && "Chyba v get_index");
}

Odstran z tej funkcie nepotrebny kod a zistis preco :)

Joo, já já si neuvědomil, že ten nadpisový řádek a sloupec už mam vlastně ve výpisu :-) Už funguje. Ještě dotaz - nikdy jsem se nesetkal s funkcí assert(). Jak vlastně funguje?

#16 Sprinter
to je macro: http://en.cppreference.com/w/c/error/assert

V podstate ak sa podmienka v asserte vyhodnoti ako false, tak sa vypise riadok na ktorom nastala chyba.

Vsetky asserty sa daju "vypnut" nastavenim macra NDEBUG

#17 vitamin
Ok, děkuji.

Tak budu mít ještě jeden dotaz do tohoto vlákna. :-)

Úsek kódu, kde vytvářím mám furt stejný (kromě přidaného výpisu do souboru). Ovšem mám pár nových funkcí, které mi v určitých případech mohou výrazně změnit vstupní parametry funkce create_table(). Jde o to, že proměnné mohou vypadat například takto:

Je jasné, že originální pole mají navíc znak ":" a nejsou v něm uplicitní znaky. Pole line a column pak používám pro nadpisový řádek a slopec v tabulce (beze změny). Ovšem problém je u pole orig_line a orig_column. Tato pole totiž používám pro tvoření čísel, které pak vkládám do tabulky. Já bych ale potřeboval, aby když algoritmus narazí na znak ":", tak aby pozastavil počítání - respektive přičítal nulu. Takto:

Výsledná tabulka by se pak měla vygenerovat jako:

Nevíte, jak by měla vypadat podmínka, která by toto řešila?

/*
*	Funkce vytvori matici prvku ze ktere posleze vypise rozkladovou tabulku
*/
void create_table (char* orig_line, char* orig_column, char* line, char* column)
{
	int a = strlen(line);
	int b = strlen(column);
	char matrix [a] [b];
	
	/* Inicializace matice */
	int n;
	for (n = 0; n <= a; n++)
	{
		int m;
		for (m = 0; m <= b; m++)
		{
			matrix [n] [m] = '-';
		}
	}
	
	/* Naplneni matice ciselnymi hodnotami dle danych souradnic */
	int iter;
	for (iter = 0; orig_line[iter] != '\0' && orig_column[iter] != '\0'; iter++)
	{
		matrix [get_index(line, orig_line[iter])] [get_index(column, orig_column[iter])] = '0' + (iter + 1);
	}
	
	/* */
	FILE *fw;
	fw = fopen("temp.txt", "w");
	
	/* Vypsani rozkladove tabulky (matice)  a ulozeni do textoveho souboru*/
	printf("Tabulka:\n");
	fprintf(fw, "M");
	printf("M");
	int x;
	for (x = 0; column[x] != '\0'; x++)
	{
		printf("\t%c", column[x]);
		fprintf(fw, "\t%c", column[x]);
	}
	printf("\n");
	fprintf(fw, "\n");
	int z;
	for (z = 0; line[z] != '\0'; z++)
	{
		printf("%c\t", line[z]);
		fprintf(fw, "%c\t", line[z]);
		int y;
		for (y = 0; column[y] != '\0'; y++)
		{
			printf("%c\t", matrix [z] [y]);
			fprintf(fw, "%c\t", matrix [z] [y]);
		}
		printf("\n");
		fprintf(fw, "\n");
	}
	fclose(fw);
}


/*
*	Funkce pro zjisteni indexu pole
*/
unsigned get_index (const char* str, char c)
{
	for (unsigned i = 0; str[i] != '\0'; i++)
	{
		if (str[i] == c)
		{
			return i;
		}
	}
	assert(0 && "!!! Chyba ve funkci get_index() !!!");
}

Napadlo mě akorát použít continue, pro to "stopnutí", ale to taky nefunguje..