ich versuch mich grad an wpc115. Für alle, die den Link nicht haben, hier ist er noch mal. Auf wie viel Tokens kommt ihr? Kann ich meins noch verbessern?

#include <iostream>
using namespace std;

int wpc115(char *master, char *pattern)
{
	int counter=0, i=0;						//  9 ->  9

	while(master[i]!='\0')					//  9 -> 18
	{										//  1 -> 19
		int j=0;							//  5 -> 24
		while(master[i+j]==pattern[j])		// 14 -> 38
		{									//  1 -> 39
			++j;							//  3 -> 42
			if(pattern[j]=='\0')			//  9 -> 51
			{								//  1 -> 52
				++counter;					//  3 -> 55
				break;						//  2 -> 57
			}								//  1 -> 58
			if(master[i+j]=='\0')			// 11 -> 69
				return counter;				//  3 -> 72
		}									//  1 -> 73
		++i+=j;								//  5 -> 78
	}										//  1 -> 79

	return counter;							//  3 -> 82
}

int main()
{
	cout << wpc115("Ich bin hmmkljachsödflcfj", "c");
	return 0;
}

int wpc115(char* master,char* pattern){ 
int rv=0;
char *q,*r; 
    while(*master++){ 
        for(r=pattern,q=master;*r&&*q;++r,++q) 
            if(*r-*q)break; 
        if(!*r)++rv; 
    } 
return rv; 
}

int wpc115(char* master,char* pattern){ 
int rv=0;
char *q,*r; 
    while(*master++){ 
        for(r=pattern,q=master;*r&&*q;++r,++q) 
            if(*r-*q)break; 
        if(!*r)++rv; 
    } 
return rv; 
}

Das ist aber nicht richtig. das while(*master++) bricht dir das genick. denn dann damit übergehst du master[0] bei den vergleichen...

von den anderen kritikpunkten lasse ich mal ab

PS: IIRC habe ich 54. in #cpp gibts glaub ich leute mit 48 oder 46

kleiner tipp:
if(master[i+j]=='\0') // 11 -> 69
return counter;
das sind _enorm_ viele token.
if(!master[i+j]) kürzt es schon enorm.
das [i+j] ist auch noch verdammt viel. also nehmen wir laufende zeiger oder versuchen das +j wegzubekommen oder sonstwas...

int wpc115(char* master,char* pattern){ 
int rv=0;
char *p,*q; 
    for(;*master;++master){ 
        for(p=pattern,q=master;*p&&*q&&*p==*q;++p,++q); 
        if(!*p&&++rv)master=q-1;
    } 
return rv; 
}

ps mit der whileschleife fand ich den code optisch ansprechender... mal gucken ob mir noch was einfällt um die geschweiften klammern der äusseren forschleife wegzubekommen

ach so kannst du mir mal erklären was eigentlich genau ziel bei der aufgabe ist.. hab ich irgendwie noch nicht ganz gepeilt... Also die funktion müsste jetzt machen was sie soll aber wie genau ist ein token definiert? und von den teilen soll man ja wenige haben oder?

int wpc115(char* master,char* pattern){ 
int rv=0;
char *p,*q; 
for(;*master;!*p&&++rv?master=q:++master) //das dumme dabei ist das man p eigentlich auf was zeigen lassen muss was ungleich 0 ist...
    for(p=pattern,q=master;*p&&*q&&*p==*q;++p,++q); 

return rv; 
}

ach so kannst du mir mal erklären was eigentlich genau ziel bei der aufgabe ist..

strstr zu implementieren. nur statt einem zeiger auf das erste vorkommen, gibst du die anzahl der vorkommen zurück. pattern dürfen sich dabei nicht überschneiden.
dh
"babab" und "bab" liefert 1 und nicht 2

wie genau ist ein token definiert?

Ein token ist einfach ein token, wie es C++ definiert.

int aba;
sind 3 token.
int | aba | ;

a++ - 13;
ist
a | ++ | - | 13 | ;

if(ab == cd) { continue; }
if | ( | ab | == | cd | ) | { | continue | ; | }

sowas ist viel besser als ascii zeichen zählen. so kann man nämlich wenigstens ein bisschen lesbarkeit bieten

btw: kommentare sind gratis. dh sie zählen als 0 token

und von den teilen soll man ja wenige haben oder?

exakt. AFAIK gilt es 46Token zu unterbieten

int wpc115(char* master,char* pattern){ 
int rv=0;  //<-5
char *p,*q; //<-5+7
for(;*master;!*p&&++rv?master=q:++master) //<-12+19 
    for(p=pattern,q=master;*p&&*q&&*p==*q;++p,++q); //<-31+29

return rv; <-60+3 =63 das sind ja belastend viele...
}

Tip: Einfach immer alles brav auseinander schreiben:

for ( ; * master ; ! * p && ++ rv ? master = q : ++ master )

MfG SideWinder

int wpc115(char* master,
           char* pattern)
{
    char * patternBackup = pattern ; // backup the original pattern pointer

    while ( * master ) // while the end of the master string is not reached ...
    {
        if ( * pattern ++ != * master ++ ) pattern = patternBackup ;    // compare one character. if mismatch, reset the pattern pointer and proceed.
        if ( ! * pattern ) return 1 + wpc115 ( master , patternBackup ) ; // if end of pattern string is reached, we have found one occurrence. recursively search the rest of the master string.
    }

    return 0 ; // no occurrence found!
}

Aber was machst du wenn du
"abc" in "ababc" suchst?

ich habe keinen compiler hier, aber das scheint dein code nicht zu decken, oder?

hat einer ne iterative lösung mit rund 50 tokens?

54

und ne illegale (wegen strstr und strlen) von wesentlich weniger tokens

@tag:
sicher bin ich mir nicht. aber ich wüsste nicht was ein leerer pattern string bringen sollte. ich nehme deshalb an, dass er nicht leer sein darf. würde nämlich so ziemlich jeden code fehlschlagen lassen.

bei der von Striker könnte man sowas in der art versuchen was nochmal ein wenig zeichen spart...

int wpc115(char* master, char* pattern){

    char * patternBackup = pattern; 

    while(* master && *pattern)
		* pattern ++ != * master ++ && (pattern = patternBackup) ;    
	return * pattern ? 0 : 1 + wpc115 ( master , patternBackup );   
}

Aber ist es wirklich Sinn des Wettbewerbs seine Lösung hier zu posten?
Sollte man das nicht besser erst nach Teilnahmeschluss machen?
Nur so ne Idee..

Wer ist Striker?

ups sorry, wollte dein nick nicht durch den kakao ziehen, war ein kleines Malheur...
jo hab die ganze zeit versucht was brauchbar iteratives hinzubekommen aber gegen die rekusion hat man in diesem falle einfach keine chance...
hatte mir dann halt nochmal deine Lösung angeguckt und festgestellt das bei dem return noch was zu holen ist und man sich die geschweiften klammern sparen kann...

Aber ist es wirklich Sinn des Wettbewerbs seine Lösung hier zu posten

gibts denn was zu gewinnen? glaub eher nicht also was hab ich davon wenn ich die Lösung zurückhalte... Macht doch eher mehr spass mit anderen zusammen die Lösung zu entwickeln...

@TomasRiker
Dein Code findet "alaal" nicht in "alalaal"

Mein Versuch:

int wpc115(char *master, char *pattern)
{
	// remember where we started
	char* oldpattern = pattern, *oldmaster = master;
	// now test against the pattern
	// make sure master always points one after the last checked character
	while(*pattern && *pattern == *master++)
		++pattern;
	// If *pattern is now NUL, we've found our substring.
	return
		// add 1 if we've found our substring
		!*pattern +
		// don't search further if master is empty
		(*master
			// if pattern was found, continue search after the substring
			// else continue one char after the original master string so we don't miss some substrings
			? wpc115(*pattern ? ++oldmaster : master, oldpattern)
			: 0);
}

// a simple test case
#include <cassert>
#define test(a,b,c) assert(wpc115(a, b) == c);
int main(int argc, char* argv[])
{
	test("babab", "bab", 1);
	test("xbababx", "bab", 1);
	test("babbab", "bab", 2);
	test("ababababa", "bab", 2);
	test("hallo welt", "l", 3);
	test("blablala", "blal", 1);
	test("blablalal", "blal", 1);
	test("alalaal", "alaal", 1);
	test("ababc", "abc", 1);
	test("abc", "abc", 1);
	test("abc", "acb", 0);
	test("a", "a", 1);
	test("a", "b", 0);
	return 0;
}

PS: Die Strg-Taste hilft in Visual C++ beim Zählen der Tokens!
Einfach gedrückt halten und mit den Cursortasten zwischen den Tokens navigieren.

[Nachtrag]
Meine Loesung hat 50 Tokens. In die Tests die ich gemacht hab, sind alle
erfolgreich durchgelaufen. Aber ob ichs einschicken werden...mal sehn
[/Nachtrag]

mfg
v R

@ShadeOfMine: Dein erster Tipp bringt nicht ne Menge, sondern ein Token (wenn '\0' nur als ein Token zählt, wie jemand in #cpp meinte).

Sorry, kann nur wenig ins Internet, deshalb antworte ich nicht öfter.

PS: Ich hab noch nicht weiter optimiert, das kommt aber noch.

(wenn '\0' nur als ein Token zählt, wie jemand in #cpp meinte)

Ist nur eins. Schliesslich kannst du nicht \ 0 schreiben.