Hello!

Tudom, hogy mar multkor (2-3honapja) megkerdeztem, de sajna azota
meghalt a gepem es vele sok minden. Igy ujbol megkerdeznem valakitol:
Hogy lehet egy paradox tablanak futasi idoben a jelszot megadni
Delphivel? Koszonom: Peter
(a multkori html -ert)

> Felado :  [International]
> Temakor: Delphi file kezeles ( 25 sor )
> Idopont: Wed Feb 20 15:03:22 CET 2002 CODER #1442
> - - - - - - - - - - - - - - - - - - - - - - - - - - - -
> Egy eleg blo"d kerdessel fordulok hozzatok. Az alap tema: Delphi,
> file handling.
> Amit csinalni szeretnek az az hogy megnyitok egy adott file-t (ez
> idaig ment is), majd utanna kiolvasom a tartalmat. Igen am de ez
> karaktereket ad vissza nekem pedig a hex ertekre van szuksegem. Na
> ezt hogyan csinalom!
> Pelda:
> Filebol kiolvasot string: ABCDEF
> Amit el szeretnek erni: 0x41,0x42,0x43,0x44,0x45,0x46

#1: nem stringet, hanem byteokat olvasol ki a filebol.
#2: dec -> hex konverzio.

Ez utobbi:
 ...
i := 12345; s := '';
while i>0 do begin
  s := s + a[i mod 16];
  i := i div 16;
end;

Ahol a=('0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f')

Minden jot:
Gaby
________________________________________________________________________
  +  http://www.sch.bme.hu/~gyoreg  +  ICQ:19934854

Sziasztok!

Nem tudtok vhol ertheto, egyszeru, lehetoleg magyar XML doksit?

Merszi:
Gaby
________________________________________________________________________
  +  http://www.sch.bme.hu/~gyoreg  +  ICQ:19934854

Szevasz!

> Felado :  [International]
> Temakor: Delphi file kezeles ( 25 sor )
> Idopont: Wed Feb 20 15:03:22 CET 2002 CODER #1442
> - - - - - - - - - - - - - - - - - - - - - - - - - - - -
> Amit csinalni szeretnek az az hogy megnyitok egy adott file-t (ez
> idaig ment is), majd utanna kiolvasom a tartalmat. Igen am de ez
> karaktereket ad vissza nekem pedig a hex ertekre van szuksegem. Na
> ezt hogyan csinalom!
Az ASCII kodot ugy is tekinthetjuk, mint egy 256-os szamrendszerbeli
szamjegyet. Ezt atszamolod 16-osra (hexadecimalis). Ecceru, mert egy
ASCII kodot 8 biten, mig egy hex-et 4 biten tarolsz (16*16=256).

Jo atszamolast!
Sipi

udv mindenkinek!
ha van egy n elemu tombom, aminek az elemeit szeretnem novekvo
sorrendbe tenni, milyen algoritmust erdemes hasznalnom? egyszeru
binaris fat, vagy 'domb fat' ( heap tree) (grafok) vagy van valami
gyorsabb megoldas is? a valaszokat maganba kernem, mert nem vagyok a
listan es elore is koszonom oket !
    --zsepi

(webes bekuldes, a bekuldo gepe: 62.92.156.17)

On 18 Feb 02, at 23:03,  wrote:

> helyezkednek el, de nem mukodik jol, amikor a helysegek egy uton
> helyezkednek el, egymas utan. Semmikeppen nem tudom megtalalni a
> hibat. Leirom a forraskodot, hatha valaki meg tudna talalni a hibat.
> Nagyon megkoszonnem.

Szia Jancsi!

<flame>
Eloszor is erezd leszurva magad, hogy ilyen forrasban levo hiba
keresesere kered masok segitseget, amiben nincs egyetlen komment sem,
es a valtozonevek is mind teljesen erdektelen egybetus nevek. Nem
csodalhatod, ha nem vettek sokan a batorsagot, hogy elmelyedjenek a
problemaban.
</flame>

En megprobaltam, de csak nagyjabol jutottam odaig, hogy ugy ahogy
kiigazodtam benne. Nem valami programhibarol van szo, valoszinu elvi
problema van az algoritmussal. A haromszor egymasba agyazott ciklusod
nem biztositja azt, hogy az osszes lehetseges ut kozul a legrovidebbik
alakuljon ki az egyes varosokban. A beteszhalmaz() szerepet egyaltalan
nem ertettem meg egyebkent. Hogy az adott kerdesedre mi lehet a
valasz, azt mar foleg nem volt kedvem bogaraszni, inkabb irtam egy
masik programot, ami hasonlo dolgot csinal, mint amit a tied is akar.
Ez is kiszamolja minden egyes varos tavolsagat a kezdotol (legalabbis
addig, amig a cel varost el nem erem), de kiirni nem irom ki oket,
csak a cel varos tavolsagat, viszont kiirom az oda vezeto teljes utat
is!

Itt a program: Remelem, ertheto lesz a mukodese a kommentek alapjan.


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

#define UNK     -1
#define N       30      // max varosok szama
#define NEV     20      // max varosnevhossz

int n;                          // a varosok szama
char varos[N][NEV];     // neve
int kezdo;              // elso varos indexe
int cel;                // vegcel indexe
int ut[N][N];   // ahol nem 0, ott van kozvetlen ut a ket varos kozott
int tav[N];             // ahol nem UNK, ott annyi a tavolsaga a kezdotol
bool kesz[N];   // ahol true, ott mar jartunk, kesz a tav[]
int vissza[N];  // ebbol a varosbol jottunk ide a legrovidebbik uton

int varosnev(char *str) // varosnev kerdezes, index viszaadas
{
        char nev[NEV];
        int i;

        for (;;) {
                printf("%s varos neve? ", str);
                scanf("%s", nev);
                for (i=0; i<n; i++) {
                        if (strcmp(nev, varos[i])==0)
                                return i;
                }
                printf("Nem jo, ird be ujra!\n");
        }
}

void beolvas_utak(void)
{
        int i, j, dist;

        printf("Hany varos van? ");
        scanf("%d", &n);
        for (i=0; i<n; i++) {
                printf("%d. varos: ", i+1);
                scanf("%s", varos[i]);
        }
        for (i=0; i<n; i++) {
                ut[i][i] = 0;   // nincs ut sajat magaba
                for(j=i+1; j<n; j++) {
                        printf("%s es %s kozti ut hossza? (vagy 0): ",
                                   varos[i], varos[j]);
                        scanf("%d", &dist);
                        ut[i][j] = ut[j][i] = dist;
                }
        }
        kezdo = varosnev("Kiindulo");
        cel = varosnev("Cel");
}

void kiir_utvonal(int ide)
{
        // kiirjuk a kezdo-tol ide-ig tarto utat rekurzivan
        if (ide == kezdo)
                printf("%s", varos[kezdo]);
        else {
                kiir_utvonal(vissza[ide]);      // honnan jottunk? teljes ut idaig
                printf(" -> %s (%d km)", varos[ide], tav[ide]); // moge a cel
        }
}

int kivesz_min(int *ind)
{       // Visszaadja a kovetkezo varost, aminek ismert tavolsaga a
        // legkisebb.
        // At is rakja azt a varost az elkeszult varosok tombjebe, hogy
        // tobbszor ne vizsgalja meg.
        // Ha elkeszult a cel varos, akkor leall.
        int i;
        int i_min = -1;         // ez van legkozelebb
        int min = INT_MAX;      // meghozza ennyire
        for (i=0; i<n; i++) {
                if (!kesz[i]            // ha meg nincs kesz,
                        && tav[i] >= 0  // de tudjuk a tavolsagat
                        && tav[i] < min // es kozelebb van
                        ) {
                        min = tav[i];
                        i_min = i;              // eddig ez a legjobb
                }
        }
        if (i_min == -1)
                return false;   // az osszes varos keszen van!

        *ind = i_min;           // ez van a maradekbol legkozelebb
        kesz[i_min] = true;     // es ezzel a varossal meg is vagyunk

        if (i_min == cel)
                return false;   // nem kell tovabb mennunk, jo, ami erdekelt
        // Ha minden varos tavolsaga kell, akkor nem kell az elozo if

        return true;
}

int main()
{
        int i, legkozel;

        beolvas_utak();

        // Dijkstra legrovidebb ut algoritmusa:
        for (i=0; i<n; i++) {
                tav[i] = UNK;   // semmi tavolsagot nem tudunk meg,
                kesz[i] = false;// es egyik sincs kesz
        }
        tav[kezdo] = 0;         // csak ezt tudjuk

        // novekvo abszolut tavolsaguk szerint vesszuk elo a varosokat,
        // es minden ujabb elovett varosnal modosit(hat)juk a varos
        // minden szomszedjanak kezdotol valo tavolsagat. Az elovetel
        // sorrendje biztositja, hogy amikorra odaerunk egy varoshoz,
        // hogy azt vesszuk elo, addigra tuti az igazi tavolsaga alakul ki
        // tav[i]-ben.
        while (kivesz_min(&legkozel)) {
                // legkozel a legkozelebbi ismert tavolsagu varos, ami meg
                // eddig nem volt kesz (elsonek legkozel == kezdo lesz.)
                // Minden szomszedjanak kiszamoljuk a tavolsagat:
                for (i=0; i<n; i++) {
                        if (ut[legkozel][i] != 0) {
                                // van ut legkozel-bol i-be, ugyhogy ki tudjuk
                                // szamolni i tavolsagat kezdo-tol:
                                int ujtav = tav[legkozel] + ut[legkozel][i];
                                if (tav[i] == UNK || tav[i] > ujtav) {
                                        // erdemesebb ezen az uton menni:
                                        vissza[i] = legkozel;
                                        // innen erkezve ekkora a tav:
                                        tav[i] = ujtav;
                                }
                        }
                }
        }
        // megvan, amire kivancsiak voltunk, kiirjuk az utat:
        kiir_utvonal(cel);

        return 0;
}

Istvan

Udv,

Olyan ujsagot, havilapot vagy hasonlot keresek, ami nagy reszben
programozassal foglalkozik.
Ha valaki ismer ilyet, az legyen szives irja meg nekem maganba!

Regebben volt valami, amit csak kis peldanyszamban adtak ki havonta,
mert nem volt ra tul nagy kereslet. A cimere mar nem emlekszem.

Elore is koszi,    

Attol tartok, hogy kenytelen leszel a DOM-et (Document Object Model)
hasznalni.

Laci

(webes bekuldes, a bekuldo gepe:
ppp-66-121-240-121.dialup.irvn11.pacbell.net)

Hello!

Mondja mar nekem valaki legyen szives, hogyan lehet excelt olyanra
rabirni, hogy egy cella szerkesztese soran felkinaljon egy megadott
erteklistabol ertekeket s ahogy gepelek ugy szukitse....
Ha valaki tudja kerem ne fogja vissza magat!
A valaszt cc-zetek a cimemre is!
Koszonom!
Peter