-
Sziasztok.
Ezt a kódot körülbelül 5 perce írtam, Zinthos egy másik programnyelvben ugyanezt megalkotta (python), és én is megpróbáltam pawn-ban. Nem kellett nagy tehetség hozzá, de azért ki teszem ide is ezt a kódot, mert hátha szüksége lesz rá valakinek egyszer..
A kód
stock findindex(const str1[], const character[])
{
new
value = -1,
len,
karakter[1]
;
len = strlen(str1);
for(new c; c < len; c++)
{
strmid(karakter, str1, c, c+1);
if(!strcmp(karakter, character))
{
value = c;
break;
}
}
return value;
}
Teszt:
main()
{
print(\"findindex(\'asd\', \'s\')\");
findindex(\"asd\", \"s\");
print(\"findindex(\'vakáció\', \'s\')\");
findindex(\"vakáció\", \"s\");
print(\"findindex(\'kecske\', \'e\')\");
findindex(\"kecske\", \"e\");
print(\"findindex(\'kettõ kecske\', \'e\')\");
findindex(\"kettõ kecske\", \"e\");
print(\"findindex(\'magas\', \'s\')\");
findindex(\"magas\", \"s\");
}
Eredmény:
[22:45:31] findindex(\'asd\', \'s\')
[22:45:31] asd szóban a s karakter indexe: 1
[22:45:31] findindex(\'vakáció\', \'s\')
[22:45:31] Nincs index találat a vakáció szóban a s karakterre!
[22:45:31] findindex(\'kecske\', \'e\')
[22:45:31] kecske szóban a e karakter indexe: 1
[22:45:31] findindex(\'kettõ kecske\', \'e\')
[22:45:31] kettõ kecske szóban a e karakter indexe: 1
[22:45:31] findindex(\'magas\', \'s\')
[22:45:31] magas szóban a s karakter indexe: 4
( A tesztnél még tartalmazott a függvény print függvényeket, innen jöttek az információk (: )
Mielõtt valaki belekötne, az index sorszámot jelent ez esetben, és a sorszám 0-nál kezdõdik. (:
-
Jó lett. :D
-
Futtasd le:
printf(\"%d\", strfind(\"asd\", \"s\"));
printf(\"%d\", strfind(\"vakáció\", \"s\"));
printf(\"%d\", strfind(\"kecske\", \"e\"));
printf(\"%d\", strfind(\"kettõ kecske\", \"e\"));
printf(\"%d\", strfind(\"magas\", \"s\"));
Eredmények:
[23:08:57] 1
[23:08:57] -1
[23:08:57] 1
[23:08:57] 1
[23:08:57] 4
-
Futtasd le:
printf(\"%d\", strfind(\"asd\", \"s\"));
printf(\"%d\", strfind(\"vakáció\", \"s\"));
printf(\"%d\", strfind(\"kecske\", \"e\"));
printf(\"%d\", strfind(\"kettõ kecske\", \"e\"));
printf(\"%d\", strfind(\"magas\", \"s\"));
Eredmények:
[23:08:57] 1
[23:08:57] -1
[23:08:57] 1
[23:08:57] 1
[23:08:57] 4
igen, és?
milyen értéket kapjon, ha ne -1 et, mikor nincs találat?: D:D:D:D
-
Jó lett Grat
-
Futtasd le:
printf(\"%d\", strfind(\"asd\", \"s\"));
printf(\"%d\", strfind(\"vakáció\", \"s\"));
printf(\"%d\", strfind(\"kecske\", \"e\"));
printf(\"%d\", strfind(\"kettõ kecske\", \"e\"));
printf(\"%d\", strfind(\"magas\", \"s\"));
Eredmények:
[23:08:57] 1
[23:08:57] -1
[23:08:57] 1
[23:08:57] 1
[23:08:57] 4
igen, és?
milyen értéket kapjon, ha ne -1 et, mikor nincs találat?: D:D:D:D
[/quote]
Na most már lehet, hogy nem vetted észre, de az én kódomban nem findindex szerepel.
-
DrAkE sztem arra céloz, hogy pont ugyanez létezik alapból a string.inc-ben.
-
asd, tényleg nem vettem észre.
hát már azért nem fogom eltüntetni, hamár 5 percet szenvedtem vele. (:
-
Na akkor hogy valami biztatót is mondjak, gyorsabb mint az strfind. Mondjuk ez nem meglepõ, jellemzõ, hogy minden saját kézzel írt sztring kezelõ függvény gyorsabb, mint a string.inc-ben lévõ eredetik.. :)
-
Lehet, de azt is vedd figyelembe, hogy ezzel csak egy karaktert lehet, míg strfinddal tetszõlegesen beírt szövegrészt is lehet keresni!
-
szép
-
Ez igaz, épp ezért nem is használok én külön függvényt erre, nekem nem számít az a kis különbség.
-
A kód neve lehetne findcharacter is talán.
Na mindegy írtam egy változatot én is:
stock
findcharacter(const string[], const sub[])
{
new
ch = -1;
while(string[++ch] && string[ch] != sub[0]) {}
return (string[ch])?(ch):(-1);
}
printf(\"%d\", findcharacter(\"asd\", \"s\"));
printf(\"%d\", findcharacter(\"vakáció\", \"s\"));
printf(\"%d\", findcharacter(\"kecske\", \"e\"));
printf(\"%d\", findcharacter(\"kettõ kecske\", \"e\"));
printf(\"%d\", findcharacter(\"magas\", \"s\"));
[/quote]
Edit:
Javítva egy apró hiba.
-
Grat. :shifty:
-
A kód neve lehetne findcharacter is talán.
Na mindegy írtam egy változatot én is:
stock
findcharacter(const string[], const sub[])
{
new
ch;
while(string[++ch] && string[ch] != sub[0]) {}
return (string[ch])?(ch):(-1);
}
printf(\"%d\", findcharacter(\"asd\", \"s\"));
printf(\"%d\", findcharacter(\"vakáció\", \"s\"));
printf(\"%d\", findcharacter(\"kecske\", \"e\"));
printf(\"%d\", findcharacter(\"kettõ kecske\", \"e\"));
printf(\"%d\", findcharacter(\"magas\", \"s\"));
[/quote]
Hármas operátornál gyorsabb az if-else, bár akkor már 1 sorral hosszabb a kód :D
-
A kód neve lehetne findcharacter is talán.
Na mindegy írtam egy változatot én is:
stock
findcharacter(const string[], const sub[])
{
new
ch;
while(string[++ch] && string[ch] != sub[0]) {}
return (string[ch])?(ch):(-1);
}
printf(\"%d\", findcharacter(\"asd\", \"s\"));
printf(\"%d\", findcharacter(\"vakáció\", \"s\"));
printf(\"%d\", findcharacter(\"kecske\", \"e\"));
printf(\"%d\", findcharacter(\"kettõ kecske\", \"e\"));
printf(\"%d\", findcharacter(\"magas\", \"s\"));
[/quote]
Hármas operátornál gyorsabb az if-else, bár akkor már 1 sorral hosszabb a kód :D
[/quote]
Javítanék rajta, ha nem gond:
stock
findcharacter(const string[], const sub[])
{
new
ch = -1;
while(string[++ch] && string[ch] != sub[0]) {}
return (string[ch])?(ch):(-1);
}
Ugyanis, ha az adott karakter amit találni akarunk a nulladik karakter, akkor -1el térne vissza.
-
@Anthony
Mi a harmadik operátor ebben?
Ha ez \":\"
Akkor az \"if else\" alkalmazásánál is a \"harmadik operator\" (<- ki indulva a megnevezésbõl) az \"else\".
Szerintem ez a felállás
(feltétel)?(true):(false) // nem olyan feltét mint a pizzákra :d
ugyanaz mint egy if else
if(feltétel) // ?
{
//true
} else { // :
//false
)
Teljesítményt nem mértem melyik gyorsabb de return után egy if-et lehet nem is fogad el a fordító. pl.: return if(bla)
@DrAkE
Kösz, javítva. Sok tesztet nem végeztem el csak összedobtam, az utolsó karakterre se teszteltem le lehet ott is rossz. ;)
-
Utolsó karakterre is tökéletes.
-
@Anthony
Mi a harmadik operátor ebben?
Ha ez \":\"
Akkor az \"if else\" alkalmazásánál is a \"harmadik operator\" (<- ki indulva a megnevezésbõl) az \"else\".
Szerintem ez a felállás
(feltétel)?(true):(false) // nem olyan feltét mint a pizzákra :d
ugyanaz mint egy if else
if(feltétel) // ?
{
//true
} else { // :
//false
)
Teljesítményt nem mértem melyik gyorsabb de return után egy if-et lehet nem is fogad el a fordító. pl.: return if(bla)
Az a \"?:\" operátor neve, hogy hármas operátor :) [eredeti nevén triadic operator]
if(akármi)
{
return...;
}
else
{
return...;
}
Biztos hogy gyorsabb, mert a WRP-be írtam egy-két függvényt régen if-else \"elágazásokkal\", majd most átírtam \"?:\"-ra, és sokkal lassabb :( [bár így 1 sorba belefér az egész, és nem kell 8 formatot használni, elég egyet xD] No persze a \"lassabb\" az még így is csak nanosecben mérhetõ.
new string[256], T1, T2;
new a[32] = \"Magyar Állami Operaház\";
new b[32] = \"Budapest, Andrássy út 22.\";
new c[32] = \"operákra, balettekre\";
new a2[32] = \"Csóró Kocsma\";
new b2[32] = \"Bucsaröcsöge, Sosevolt út 666.\";
new c2[32] = \"vikingmetálra és goth metálra\";
T1 = GetTickCount();
for(new i=0; i< 100000; i++)
{
new r = random(2);
format(string, sizeof(string), \"A %s (%s) Magyarország egyetlen nagy létszámú társulattal rendelkezõ és kimondottan %s szakosodott színháza.\", (r)?(a):(a2), (r)?(b):(b2), (r)?(c):(c2));
//printf(string);
}
T2 = GetTickCount();
printf(\"\\\"?:\\\" - 100000x: %d ms\", T2-T1);
T1 = GetTickCount();
for(new i=0; i< 100000; i++)
{
new r = random(2);
if(r)
{
format(string, sizeof(string), \"A %s (%s) Magyarország egyetlen nagy létszámú társulattal rendelkezõ és kimondottan %s szakosodott színháza.\", a, b, c);
}
else
{
format(string, sizeof(string), \"A %s (%s) Magyarország egyetlen nagy létszámú társulattal rendelkezõ és kimondottan %s szakosodott színháza.\", a2, b2, c2);
}
//printf(string);
}
T2 = GetTickCount();
printf(\"if-else - 100000x: %d ms\", T2-T1);
T1 = GetTickCount();
for(new i=0; i< 100000; i++)
{
new r = random(2);
switch(r)
{
case 0: format(string, sizeof(string), \"A %s (%s) Magyarország egyetlen nagy létszámú társulattal rendelkezõ és kimondottan %s szakosodott színháza.\", a, b, c);
case 1: format(string, sizeof(string), \"A %s (%s) Magyarország egyetlen nagy létszámú társulattal rendelkezõ és kimondottan %s szakosodott színháza.\", a2, b2, c2);
}
//printf(string);
}
T2 = GetTickCount();
printf(\"switch - 100000x: %d ms\", T2-T1);
Ezt a tesztet lefuttatva az eredmény:
[11:54:09][11:59:10] \"?:\" - 100000x: 148 ms
[11:59:10] if-else - 100000x: 138 ms
[11:59:10] switch - 100000x: 142 ms
Csak ha sok-sok \"?:\" van egymásba ágyazva az sokkal lassabb, mint ha sok else-if van egymásban =/
-
Érdekes teszt, az egészben a hiba a random, nem mindegyik teszt zajlik le ugyanúgy. A következõ tesztben nem biztos hogy ugyanannyi 1 vagy 0 értéket kapunk mint az elõzõben vagy a következõben.
Na végzek egy ilyen tesztet én is kíváncsiságból. :D
EDIT:
Elkészült a teszt nagy nehezen, ennyiszer nem kellett abbahagynom egy ilyen tesztet mint most. :D
stock
ifteszt()
{
// #define DEBUGMODE // <- Ellenõrzés
#define LOOP 10000000 // < -Ismétlõdések száma 10 millió
#if defined DEBUGMODE
#undef LOOP
#define LOOP 10
#endif
new
i = 0,
starttime,
changevariable;
// - ()?():() >
i = 0; starttime = GetTickCount();
for( ; i < LOOP; i++)
{
changevariable = (i % 2)?(123):(321);
#if defined DEBUGMODE
printf(\"%s\", (i % 2)?(\"egy\"):(\"null\"));
#endif
}
printf(\"()?():() -> %dms -- changevariable: %d\\n\", GetTickCount() - starttime, changevariable);
// <-
// - if else >
i = 0; starttime = GetTickCount();
for( ; i < LOOP; i++)
{
if(i % 2)
{
changevariable = 123;
#if defined DEBUGMODE
print(\"egy\");
#endif
} else {
changevariable = 321;
#if defined DEBUGMODE
print(\"null\");
#endif
}
}
printf(\"ifelse -> %dms -- changevariable: %d\\n\", GetTickCount() - starttime, changevariable);
// <-
// - switch >
i = 0; starttime = GetTickCount();
for( ; i < LOOP; i++)
{
switch(i % 2)
{
case 1:
{
changevariable = 123;
#if defined DEBUGMODE
print(\"egy\");
#endif
}
case 0:
{
changevariable = 321;
#if defined DEBUGMODE
print(\"null\");
#endif
}
}
}
printf(\"switch -> %dms -- changevariable: %d\\n\", GetTickCount() - starttime, changevariable);
// <-
}
És az eredmény:
[2012.07.25 18:08:13] ()?():() -> 837ms -- changevariable: 123
[2012.07.25 18:08:14] ifelse -> 758ms -- changevariable: 123
[2012.07.25 18:08:14] switch -> 624ms -- changevariable: 123
[2012.07.25 18:08:15] ()?():() -> 810ms -- changevariable: 123
[2012.07.25 18:08:16] ifelse -> 766ms -- changevariable: 123
[2012.07.25 18:08:16] switch -> 638ms -- changevariable: 123
Ezek szerint gyorsabb az if else mint ahogy nevezik \"hármas operátor\"-nál, de a switch ezeknél is gyorsabb.