Anonymní profil Furynka – Programujte.com

#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;

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';

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

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;
}

#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];

#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]
 

 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';

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

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.  

#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íš.  

#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ě)

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   )

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

Teď by si měl trochu pořešit "logiku" toho kódu  

Ty jsi vytvořil objektVypocty, který má 2 atributy a 2 metody. Důležité je, že metody (funkce v objektu) mají přístup k atributům toho objektu. Ty jsi částečně dobře definoval metod Soucet,ale cpeš tam ještě nějaké 2 int hodnoty, které tam vůbec nejsou potřeba.

Vypocty pokus;

pokus.NastavHodnoty(2, 3);
pokus.Soucet(100, 200); // = 5       :)

Ahoj, problém máš v kompilaci, není to kódem (ale i v něm je pár chyb   ). Musíš zkompilovat všechny .cpp soubory. 

Např. v unixu příkazem g++ poprve.cpp prf.cpp -o poprve

Co používáš za IDE nebo jak kompiluješ?

Pokud se nepletu tak je tam ještě jedna malá chybička a to jest

pMan->readline(line, &pDat); //pDat je ukazatel...takže &pDat je adresa ukazatele
                             // a to neni presne co chceme
int readline(char *line, Data& dat) //funkci chceme předat adresu na daný objekt

*pDat //objekt
&pDat //adresa ukazatele
pDat //adresa objektu

pMan->readline(line, pDat); //tohle je správně