Problém s indexem pole – C / C++ – Fórum – Programujte.com

Ahoj, nevím si rady s implementací následujícího problému do jazyka C.

Mám dvě pole - line_buffer a column_buffer. Tyto pole jsou vždy stejně velké a mohou být naplněny například takto:

Po vytvoření tohoto pole přijde na řadu funkce, která když najde znak "@" řekne, že by kombinace {S, @} měla být přepsána například na {S, @}, {S, a}, {S, b}. Tyto kombinace ukládám do pole transfer_form tímto způsobem:

transfer_form = {S@ab A@b B@ab}

První znak znamená o jaké písmeno z pole line_buffer se jedná, zbytek znaků jsou pak prvky z pole column_buffer.

A teď s čím mám problém - potřebuji vytvořit nové dvě pole, zástupné za line_buffer a column_buffer, které by vypadalo takto:

Mám totiž problém s tím, že pokud proběhne podmínka, která vytvoří řetězec ":SSS:" a "ab@", tak pak už nevím, jak říct, aby se znak "A" a "a" ukládal až na index 7 v poli (a zajistit aby se mi nerozhodil zase začátek). Takže kód níže mi funguje pouze do prvního průchodu podmínkou...

char *follow;
char pom_1 [100];
char pom_2 [100];
follow = strtok(transfer_form, " ");
char help [strlen(transfer_form)];
while (follow != NULL)
{
	strcpy(help, follow);
	int o;
	for (o = 0; o < strlen(column_buffer); o++)
	{
		if (column_buffer[o] == '@' && line_buffer[o] == help[0])
		{
			pom_1[o] = ':';
			pom_2[o] = ':';
			int p;
			for (p = 0; help[p] != '\0'; p++)
			{				
				pom_1[o+p + 1] = help[0];
				pom_2[o+p + 1] = help[p + 1];
			}
			pom_1[strlen(pom_1)-1] = ':';
			pom_2[strlen(pom_2)-1] = ':';
		}
		else
		{
			pom_1[o] = line_buffer[o];
			pom_2[o] = column_buffer[o];
		}
	}
	follow = strtok(NULL, " ");
}

to se dela tak, ze mas dve pocitadla (nebo jedno pocitadlo a offset vuci nemu v druhem poli..)

Ahoj, tvůj kód jsem si sám neopravoval, takže nemám nějaký ukázkový kód, ale myslím, že myšlenka tvého algoritmu jde správným směrem a nahodím tu pár myšlenek, které by mohly způsobovat chybu.

1) 

všimni si rozdílu mezi help[0] a help[p+1]

for (p = 0; help[p] != '\0'; p++){				
	pom_1[o+p + 1] = help[0];
	pom_2[o+p + 1] = help[p + 1];
}
pom_1[strlen(pom_1)-1] = ':';  //pom_1 ma jinou delku nez pom_2
pom_2[strlen(pom_2)-1] = ':';  //viz cyklus vyse

2)

Ty, když najdeš @, tak začneš transformovat nějakou dvojici (S, @) na něco většího. V algoritmu používáš proměnné O a P. Šikovně uděláš O + P, ale pak když dodeláš tu transformaci, tak zase pokračuješ v O ...tím chci říct, že si tu novou transformaci přepíšeš na nějaký původní řetězec z line/column_buffer

Tak už jsem bezradnej.. vypotil jsem ze sebe toto, ale opět nefunkční...

char *follow;
char pom_1 [100];
char pom_2 [100];
follow = strtok(transfer_form, " ");
char temp [strlen(transfer_form)];
int count = 0;
while (follow != NULL)
{
	strcpy(temp, follow);
	int m;
	for (m = 0; m < strlen(column_buffer); m++)
	{
		if (column_buffer[m] == '@' && line_buffer[m] == temp[0])
		{
			pom_1[m] = ':';
			pom_2[m] = ':';
			int n;
			for (n = 1; temp[n] != '\0'; n++)
			{
				pom_1[m + n] = temp[0];
				pom_2[m + n] = temp[n];
			}
			pom_1[m + n] = ':';
			pom_1[m + n + 1] = '\0';
			
			pom_2[m + n] = ':';
			pom_2[m + n + 1] = '\0';
			
			count = m + n + 1;
		}
		else
		{
			pom_1[count] = line_buffer[m];
			pom_2[count] = column_buffer[m];
			count++;
		}
	}
	follow = strtok(NULL, " ");
}

Dobře...posunul ses dál, ale vznikly ti další chyby: (teda zatím vidím jednu velikou   )

1) 
u proměnné count je pár chybiček. Zaprvé dobře ji používáš v if-else větvi, ale úplně si zapomněl, že je potřeba i v if-then větvi. Co když budeš mít 2 transformace zasebou?  
Zadruhé výpočet count je špatně! Přesněji řečeno špatně funguje pro více transformací. Ty jsi uložíš m + n , ale při druhé transformaci se přepíše na jiné m + n  (hodnota předešlého posunu (n) se ti úplně ztratí).

poznámka na závěr: zkus si testnout algoritmus jen s jednou transformací + dávej si bacha na hranice pole (ono vkládat do pole nějaký řetězec délky víc jak 1, je docela nepříjemná záležitost - a to hlavně v Céčku   )

#5 Furynka
No v tom for cyklu to proběhne buď v IF, nebo v ELSE.. jiná možnost není (jestli si tedy rozumíme).

Spíš zvažuju, jestli mám celou tu konstrukci dobře.. Nejdřív používám while cyklus, který mi v každým průchodu poskytne jedno "slovo" z pole transfer_form. Takže do for cyklu jde například slovo "S@ab". No jo, ale tímto způsobem mi proběhne celý for cyklus jenom s tímto slovem.. a do podmínky se tak druhé slovo dostane až po ukončení for cyklu... Není to chyba? Nebo už v tom mám chaos? :-)

#6 Sprinter
Máš pravdu, ale v tomhle by neměl být problém. Tvůj algoritmus funguje tak, že od začátku to projede s prvním slovem, pak zase od začátku druhým slovem, atd. Ty jsi chtěl asi naznačit, že by ten algoritmus měl pro každou dvojici zkontrolovat jestli to není jedno z těch slov. Ale to tvůj algoritmus dělá, jenom to dělá jiným způsobem. Protože si "už zpracované" ukládáš do nového pole, tak je úplně jedno jaký způsob zvolíš. 

Vrátím se zpátky k těm mým upozorněním. Proměnnou count počítáš špatně, to doufám vidíš. Ta druhá věc je, že count nepoužíváš v if-then. Dám příklad...mějme řetězec AASSAAA... a máme jednu transformaci kdy za S dosadíme BBB (pro zjednodušení nebudu řešit, že máme 2 pole). 
1. V algoritmu narazim na S a začnu přidávat BBB 
2. Dosadil jsem a koncim if-then větev ( m = 2 , count = 2 + 3 + 1)
3. Posunu se na m = 3 a našel další S
4. ale!!! transformaci provádím na m = 3 (kam se mně ztratil minulý posun?!)  
tedy výsledek příkladu je asi takový to: AAB+BBBAAA... (ale správný je AABBB+BBBAAA...)
(příklad jsem zjednodušil, ale doufám, že ta chyba tam je vidět   )

EDIT: 5. dokončil jsem (špatně) transformaci a končím if-then (m = 3,count = 3 + 3 +1 = druhé špatně)

#7 Furynka
No podle všeho mám v tom IF-THEN špatně ukládání do pole. Pokud se mi první znak bude ukládat na pozici m, tak mi to přesně na tom Vašem případě udělá chybu.. Když to ale nahradím count, čímž umožním, aby mi ukládání pokračovalo tam, kde jsem posledně skončil, tak mi to také nefunguje správně...

Zkouším si to rezepsat na papír a najít další chybu, ale zatím to mám takto:

if (column_buffer[m] == '@' && line_buffer[m] == temp[0])
{
	pom_1[count] = ':';
	pom_2[count] = ':';
	int n;
	for (n = 1; temp[n] != '\0'; n++)
	{
		pom_1[count + n] = temp[0];
		pom_2[count + n] = temp[n];
	}	
	pom_1[count + n] = ':';
	pom_1[count + n + 1] = '\0';

	pom_2[count + n] = ':';
	pom_2[count + n + 1] = '\0';

	count = m + n + 1;
	printf("IF %i\n", m);
	printf("IF count %i\n", count);
}

#8 Sprinter
Zase špatně...máš 2 proměnné, které používáš k zjištění indexu pole
int n  // použij pro indexaci v column/line_buffer
int count // použij pro uložení posunutí

tedy count počítej nějak takhle : count = count + n (vždy když se přidá nějaký posun)
a pak jakýkoliv zápis do pom_1/2 s indexem [n+count]

Nastává, ale problém, který mě předtím nenapadl (omlouvám se   ). Jedná se o ten způsob prohledávání. Musíš to udělat druhým způsobem, tedy podívat se na index a zkontrolovat s každým slovem. S původním způsobem je problém u toho posunutí. Doufám, že už zbytek vidíš.  

#9 Furynka
Jestli to tedy chápu správně, musím nejdříve udělat for cyklus a do něj vnořenej while cyklus (co se toho vyhledávání týče)?

Ano, musíš to udělat tak, že pojedeš písmenko po písmenku a zkontrolovat ho, zdali neexistuje nějaká transformace na něj. Takže jak už jsi zmínil, procpi ten while cyklus, který ti dělá ty transformace, dovnitř. Dále využij proměnné k indexaci, tak jak jsem zmínil výše.

Já doufám, že aspoň vidíš jak ten algoritmus má fungovat. Chtěl jsem tě jenom upozornit na chyby, ale jestli chceš, tak klidně zítra ráno sem hodím funkční kód.  

#11 Furynka
No popravdě se s tím patlám skoro celý den a už asi nic nevymyslím. Pěkně se v tom motám a to už sem měl řešit něco uplně jinýho, tak pokud by se ti chtělo, tak za funkční kód budu rád..

Momentálně mám toto (ovšem, když jsem to prohnal kompilátorem, tak mi to vyhodilo na všechny pole s indexem count chybu - subscripted value is neither array nor pointer nor vector)

char pom_1;
char pom_2;
char *follow;
follow = strtok(transfer_form, " ");
char temp [strlen(transfer_form)];
int count = 0;
int j;
for (j = 0; j < strlen(column_buffer); j++)
{
	while (follow != NULL)
	{
		strcpy(temp, follow);
		if (column_buffer[j] == '@' && line_buffer[j] == temp[0])
		{
			pom_1[count] = ':';
			pom_2[count] = ':';
			int n;
			for (n = 1; temp[n] != '\0'; n++)
			{
				pom_1[count + n] = temp[0];
				pom_2[count + n] = temp[n];
			}
			pom_1[count + n] = ':';
			pom_1[count + n + 1] = '\0';
		
			pom_2[count + n] = ':';
			pom_2[count + n + 1] = '\0';
		
			count = count + n + 1;
		}
		else
		{
			pom_1[count] = line_buffer[j];
			pom_2[count] = column_buffer[j];
			count++;
		}
		follow = strtok(NULL, " ");
	}
}

Jo tak ten error to házelo, protože jsem špatně deklaroval ty pole (závorky)

char *follow;
follow = strtok(transfer_form, " "); 
char temp [strlen(transfer_form)]; //(vlož do for cyklu, přímo nad while)

#14 Furynka
Jasně, opraveno.

 dobře, trochu jsem zasáhl do kódu, ale není to ozkoušené...
 

EDIT: zapomněl jsem na char temp[strlen...]

char pom_1[100];
char pom_2[100];
int count = 0;
int j;
for (j = 0; j < strlen(column_buffer); j++)
{
  char *follow;
  follow = strtok(transfer_form, " ");
  char temp [strlen(transfer_form)];

  while (follow != NULL)
  {
    strcpy(temp, follow);
    if (column_buffer[j] == '@' && line_buffer[j] == temp[0])
    {
      pom_1[count + j] = ':';
      pom_2[count + j] = ':';
      int n;
      for (n = 1; temp[n] != '\0'; n++)
        {
        pom_1[count + n + j] = temp[0];
        pom_2[count + n + j] = temp[n];
      }
      pom_1[count + n + j] = ':';
      pom_1[count + n + 1 + j] = '\0'; //(strlen funkce zmizela, 
      //pro zjednoduseni napisem '\0' az na konci algoritmu)
  
      pom_2[count + n + j] = ':';
      //pom_2[count + n + 1 + j] = '\0';
 
      count = count + n; // tady si nejsem jistý původní +1
    }
    else
    {
     pom_1[count + j] = line_buffer[j];
     pom_2[count + j] = column_buffer[j];

     //count++; ( j++ mně značí posun o 1)
    }
    follow = strtok(NULL, " ");
  }
}
pom_1[count + j] = '\0';
pom_2[count + j] = '\0';

#16 Furynka
Tak jsem to odzkoušel a ještě je tam nějaká chyba, takhle to furt vypisuje špatně. Jinak co se týče toho

count = count + n

Tak ta jednička tam byla kvůli tomu, aby posunula count na další prvek v poli (aby nedošlo k přepsání). Proč zde taky není přičteno i j?

jen par poznamek:

1. konstrukce:  char temp [strlen(transfer_form)]; jeste par verzi prekladace zpet neprosla nebo se to vzalo jako prazdny...

2. az v transfer_point bude retezec bez mezery, strcpy zapise taky konec retezce \0 se kterym se uz proste nepocita

3. for ( ....;  ... strlen(column_buffer); .... )    jo proc nevyrobit kvadrat slozitosti ... uz megabajtovej retezec by trval a trval a trval.... a to se jeste poradne nic neudelalo

#17 Sprinter

Takhle, ty count používáš pouze pro uložení "bonusového" posunu. Představ si příklad AASAAA..a S se ti přepíše na :B : 
Tedy výsledek by měl být: AA : B : AAA... ( 2 nové znaky + původní S přepsáno na : )
Áčka jsou jednoduchá, pom[0] = buffer[0], pom[1] = buffer[1]
Pak narazíme na první S (buffer[2]) a spustí se vnitřní cyklus, který udělá, že najednou index J, který ukazuje na buffer je tak trochu "opožděný" , protože se stane tohle: pom[2] = ' : '    A   pom[3] = 'B'    A   pom[4] = ' : ' 
A tedy délka pole pom je větší než zpracovaná část bufferu. Proto v dalším kroku, kdy se díváš na znak A (buffer[3]), nemůžeš zapisovat na pom[3], ale na pom[5] , tedy na pom[3 + 2] == pom[3 + nové znaky] == pom[ j + count]
 

#18 KIIV
No ten bod 1 moc nechápu.. transfer_form má mnohem větší délku, než token (jestli jde o ukončovací znak). Co se týče bodu 3, tak tam šlo o to, že je lepší místo strlen použí např. toto?

column_buffer[j] != '\0'

#19 Furynka
Jojo, chápu. No teď se snažím zjistit, kde je chyba.. mám zadáno toto:

line_buffer[0] = 'S';
	line_buffer[1] = 'S';
	line_buffer[2] = 'A';
	line_buffer[3] = 'A';
	line_buffer[4] = 'B';
	line_buffer[5] = 'B';
	line_buffer[6] = '\0';
	
	column_buffer[0] = 'a';
	column_buffer[1] = 'A';
	column_buffer[2] = '@';
	column_buffer[3] = 'a';
	column_buffer[4] = 'b';
	column_buffer[5] = '@';
	column_buffer[6] = '\0';
	
	transfer_form[0] = 'A';
	transfer_form[1] = '@';
	transfer_form[2] = 'b';
	transfer_form[3] = ' ';
	transfer_form[4] = 'B';
	transfer_form[5] = '@';
	transfer_form[6] = 'b';
	transfer_form[7] = 'a';
	transfer_form[8] = '\0';

A ve výpisu mám jako výsledek:

Pom_1: {SS:AA:ABB}

Pom_2: {aA:@b:ab@}

#21 Sprinter
zkus :)

for (n = 2; temp[n] != '\0'; n++)
        {
        pom_1[count + n - 1 + j] = temp[0];
        pom_2[count + n - 1 + j] = temp[n];

#20 Sprinter
Ak mas v podmienke strlen, znamena to ze vzdy ked sa vyhodnocuje podmienka musisa znova prepocitat velkost retazca a to je dost pomale. Preto je lepsie pouzit strlen() pred cyklom alebo idealne pouzit na ukoncenie cyklu kontrolu na ukoncovaci znak '\0'. 

Samozrejme kompilator moze optimalizovat tvoj kod, kedze funkcia strlen prebera const parameter, tak prekladac vie ze premenna sa vo funkcii nemeni a ak v cykle nezmenis ziadnu hodnotu retazca a nezavolas ziadnu funkciu ktora ma ako parameter nekonstantny pointer na ten retazec tak to prekladac MOZE optimalizovat, ale nespoliehal by som sa na to  

#22 Furynka

Tak teď to háže tyto výsledky:

Pom_1: {SS:A :ABB}

Pom_2: {aA:B         }

Pro jistotu radši přikládám i současný kód:

char pom_1 [200];
char pom_2 [200];
int count = 0;
int j;
int size = strlen(column_buffer);
for (j = 0; j < size; j++)
{
	char *follow;
	follow = strtok(transfer_form, " ");
	char temp [strlen(transfer_form)];
	while (follow != NULL)
	{
		strcpy(temp, follow);
		if (column_buffer[j] == '@' && line_buffer[j] == temp[0])
		{
			pom_1[count + j] = ':';
			pom_2[count + j] = ':';
			int n;
			for (n = 2; temp[n] != '\0'; n++)
			{
				pom_1[count + n - 1 + j] = temp[0];
				pom_2[count + n - 1 + j] = temp[n];
			}
			pom_1[count + n + j] = ':';
			//pom_1[count + n + 1] = '\0';
		
			pom_2[count + n + j] = ':';
			//pom_2[count + n + 1] = '\0';
		
			count = count + n;
		}
		else
		{
			pom_1[count + j] = line_buffer[j];
			pom_2[count + j] = column_buffer[j];
		}
		follow = strtok(NULL, " ");
	}
}

#23 vitamin
zoptimalizovat se neco muze ale strlen to jeste v zivote nebyl...

strlen muze prebirat const parametr, ale to neznamena ze ten predavanej parametr je tez const (tim spis ze se nezmeni za behu)

#20 Sprinter
2. krajni pripad, kdy bude cely retezec bez jedineho delimiteru ->  mas misto presne na cely retezec akorat ne na ten ukoncovaci znak

#25 KIIV
Jojo, místo na ukončovací nuly si hlídám. Proto tomu poli také dávám místo mnohem větší, než potřebuje (oříznout ho mohu vždycky).

tak takhle 

{
int n;
for (n = 2; temp[n] != '\0'; n++)
{
	pom_1[count + n - 1 + j] = temp[0];
	pom_2[count + n - 1 + j] = temp[n];
}
n = n - 3; //odectu -3, protoze prvni dva + \0 znaky ,nejsou "nove", napr. "S@aba\0"
pom_1[count + n + j] = ':';
pom_2[count + n + j] = ':';
	
count = count + n;
}

#27 Furynka
Tak teď se výpis zkrátil jen na toto:

Pom_1: {ABB}

Pom_2: {ab@}

#28 Sprinter
no nic, únava dělá svoje...ráno jsem postnu funkční kód  

#29 Furynka
:-) Děkuju

Tak je to tu...ráno == čístá mysl 
Použil jsem tvoji poslední verzi kódu a upravil pár chyb:
1) funkce strtok si poupraví daný string (pro první písmeno fungoval dobře, ale pro další kontroloval pouze první transformaci), tedy vytvořil jsem mu vždy nového obětního beránka
2) když si narazil na transformaci, tak jsi ji udělal, ale pak si dále testoval na další transformace (což vedlo k if-else větvi, která tam přepisovala původní transformaci)
3) menší úprava výpočtu N a COUNT

Pěkný úkol na páteční večer 
 

char pom_1[100];
char pom_2[100];
int count = 0;
int j;
int k;
k = strlen(column_buffer);
for (j = 0; j < k; j++){
  short int transformed = 0;
  char temp [strlen(transfer_form)];
  char dummy[strlen(transfer_form)];
  strcpy(dummy, transfer_form);
  char *follow;
  follow = strtok(dummy, " ");

  while (follow != NULL && transformed == 0){
     strcpy(temp, follow);
     if (column_buffer[j] == '@' && line_buffer[j] == temp[0]){
       pom_1[count + j] = ':';
       pom_2[count + j] = ':';
       int n;
       for (n = 2; temp[n] != '\0'; n++){
         pom_1[count + n - 1 + j] = temp[0];
         pom_2[count + n - 1 + j] = temp[n];

       }
       pom_1[count + n - 1 + j] = ':';     
       pom_2[count + n - 1 + j] = ':';
	
       n = n - 2;
       count = count + n + 1; 
       transformed = 1;
     }
     else{
       pom_1[count + j] = line_buffer[j];
       pom_2[count + j] = column_buffer[j];
     }

     follow = strtok(NULL, " ");
   }
}
pom_1[count + j] = '\0';
pom_2[count + j] = '\0';

#31 Furynka

Super, děkuji. Akorát ještě jedna věc - teď mi to vypisuje bez toho znaku "@" a mělo by to vypsat i s ním.. např:

poleA: SSAABB

poleB: aA@ab@

transf: A@b B@ba

současný výpis:

SS:A:AB:BB:

aA:b:ab:ba:

a mělo by to být takto:

SS:AA:AB:BBB:

aA:@b:ab:@ba:

#32 Sprinter
Jo takhle..to už si mohl nějak domyslet  

if (column_buffer[j] == '@' && line_buffer[j] == temp[0]){
       pom_1[count + j] = ':';
       pom_2[count + j] = ':';
       int n;
       for (n = 1; temp[n] != '\0'; n++){
         pom_1[count + n + j] = temp[0];
         pom_2[count + n + j] = temp[n];

       }
       pom_1[count + n + j] = ':';     
       pom_2[count + n + j] = ':';
	
       //n = n - 1;
       count = count + n; 
       transformed = 1;

#33 Furynka
To je fakt no :-) Děkuji, už je to funkční přesně tak, jak jsem chtěl