Leogict

Witam, mam taki problem: od jakiegoś czasu otwiera mi linki z gg w IE, a kiedyś w FF, jak przywrócić żeby otwierało znowu w FF? W ustawieniach gg nic na ten temat, FF ustawiony jako domyślna przeglądarka. GG 7.7.0 FF 3.0.11 IE 6.0 Win XP SP2

Mylisz się. Ja nie wpadłem na pomysł, wpadłem w pułapkę pod tytułem "poprawa egzaminu" :angry: A źródeł mam hohoho... :D

Zawsze, ale jak nie ma przepełnienia, to dokleja string źródłowy z NULL-em przecież, więc jest wszystko si. Edit: chociaż jak tak teraz patrzę pod debuggerem, to dokleja string źródłowy bez nulla, ale że tablica docelowa była wstępnie zainicjalizowana, to wszystko jest ok. Drainer dzięki, miałeś rację, zwracam honor. Teraz powinno kończyć zerem w każdym przypadku: zmienna licznik_zro poprostu zliczała znaki w tablicy źródłowej bez uwzględnienia nulla, stąd to niedopatrzenie. :) #include <iostream>using namespace std;void dolacz(char docelowa[], int rozmiar_docelowej, char zrodlowa[]);int main(){ const int rozmiar=30; // rozmiar tablicy docelowej char tablica_docelowa[rozmiar]={"Czym sie rozni kaczka"}; char tablica_zrodlowa[]={" od labedzia?"}; cout << tablica_docelowa; dolacz(tablica_docelowa, rozmiar, tablica_zrodlowa); // here we go Wink cout << endl << tablica_docelowa << endl; return 0;}//***********************************************************************//funkcja do dolaczania stringu z tablicy zrodlowej do tablicy docelowej://***********************************************************************void dolacz(char docelowa[], int rozmiar_docelowej, char zrodlowa[]){ int i=0,j=0,licznik_doc=0,licznik_zro=0; while(docelowa[i++]) ++licznik_doc; //ilosc liter w tablicy docelowej, od tego indeksu zaczynamy doklejanie while(zrodlowa[j++]) ++licznik_zro; //ilosc liter w tablicy zrodlowej for(int i=licznik_doc; i<licznik_doc+licznik_zro+1; i++) { if(i>=rozmiar_docelowej) { docelowa[i-1]=0; // terminowanie zerem w przypadku przedwczesnego zapełnienia tablicy break; // zapelniona cala tablica, przerywamy dzialanie funkcji } docelowa[i]=zrodlowa[i-licznik_doc]; // wlasciwe doklejanie }}

To if się nie wykona. Twoje rozwiązanie wygląda ok, tylko to terminowanie zerem jak mamy przepełnienie, dzięki. Piszcie dalej.

Nie ma odpowiedzi, bo nie ma jednego pasującego rozwiązania, można to zrobić na wiele sposobów. Twój kod wygląda ok, ale nie masz terminowania zerem w przypadku przepełnienia tablicy. Mój kod poprawiony: #include <iostream>using namespace std;void dolacz(char docelowa[], int rozmiar_docelowej, char zrodlowa[]);int main(){ const int rozmiar=30; // rozmiar tablicy docelowej char tablica_docelowa[rozmiar]={"Czym sie rozni kaczka"}; char tablica_zrodlowa[]={" od labedzia?"}; dolacz(tablica_docelowa, rozmiar, tablica_zrodlowa); // here we go Wink return 0;}//***********************************************************************//funkcja do dolaczania stringu z tablicy zrodlowej do tablicy docelowej://***********************************************************************void dolacz(char docelowa[], int rozmiar_docelowej, char zrodlowa[]){ int i=0,j=0,licznik_doc=0,licznik_zro=0; while(docelowa[i++]) ++licznik_doc; //ilosc liter w tablicy docelowej, od tego indeksu zaczynamy doklejanie while(zrodlowa[j++]) ++licznik_zro; //ilosc liter w tablicy zrodlowej for(int i=licznik_doc; i<licznik_doc+licznik_zro; i++) { if(i>=rozmiar_docelowej) { docelowa[i-1]=0; // terminowanie zerem w przypadku przedwczesnego zapełnienia tablicy break; // zapelniona cala tablica, przerywamy dzialanie funkcji } docelowa[i]=zrodlowa[i-licznik_doc]; // wlasciwe doklejanie }}

Witam. Napisałem program z Symfonii C++ Standard, wyd. 3 z 2008r, ćwiczenie XXIII/218, w skrócie: mamy napisać funkcję, która do końca stringu będącego w jednej tablicy dołączy string będący w innej tablicy, funkcja powinna przerwać w przypadku zapełnienia całej tablicy. Jak zwykle będę wdzięczny za uwagi, spostrzeżenia, komentarze i wskazówki. Ćwiczenie było po rozdziale o tablicach, więc nie piszcie o żadnych vectorach, klasach itp :) #include <iostream>using namespace std;void dolacz(char docelowa[], int rozmiar_docelowej, char zrodlowa[]);int main(){ const int rozmiar=30; // rozmiar tablicy docelowej char tablica_docelowa[rozmiar]={"Czym sie rozni kaczka"}; char tablica_zrodlowa[]={" od labedzia?"}; dolacz(tablica_docelowa, rozmiar, tablica_zrodlowa); // here we go;) return 0;}//***********************************************************************//funkcja do dolaczania stringu z tablicy zrodlowej do tablicy docelowej://***********************************************************************void dolacz(char docelowa[], int rozmiar_docelowej, char zrodlowa[]){ int i=0,j=0,licznik_doc=0,licznik_zro=0; while(docelowa[i++]) ++licznik_doc; //ilosc liter w tablicy docelowej, od tego indeksu zaczynamy doklejanie while(zrodlowa[j++]) ++licznik_zro; //ilosc liter w tablicy zrodlowej for(int i=licznik_doc; i<licznik_doc+licznik_zro; i++) { if(i>=rozmiar_docelowej) break; // zapelniona cala tablica, przerywamy dzialanie funkcji docelowa[i]=zrodlowa[i-licznik_doc]; // wlasciwe doklejanie }}

Witam. Napisałem program z Symfonii C++ Standard, wyd. 3 z 2008r, ćwiczenie XVIII/217, w skrócie: mamy w tablicy jakiś tekst i mamy napisać funkcję rozdzielającą poszczególne wyrazy do tablicy z nieparzystymi wyrazami i parzystymi, w obu przypadkach oddzielonymi spacją. Jak zwykle będę wdzięczny za uwagi, spostrzeżenia, komentarze i wskazówki. Ćwiczenie było po rozdziale o tablicach, więc nie piszcie o żadnych vectorach, klasach itp ;) #include <iostream>using namespace std;void grupuj(char zrodlo[], char parz[], char nieparz[]);int rozmiar(char zrodlo[]);int main(){ char tablica[]={"Symfonia C++ to najlepsza ksiazka na poczatek przygody z jezykiem C++ moim zdaniem"}; // dany string char nieparzyste[80]={}; // wstepne zerowanie char parzyste[80]={}; // -||- grupuj(tablica, parzyste, nieparzyste); //here we go;) cout << tablica << "\nRozmiar stringu: " << rozmiar(tablica) << "\n\n\nNieparzyste:" << endl; for(int i=0; i<80; i++) // wypisanie wyrazow nieparzystych { cout << nieparzyste[i]; } cout << endl << "Parzyste:" << endl; for(int i=0; i<80; i++) // wypisanie wyrazow parzystych { cout << parzyste[i]; } cout << "\n\n\n"; return 0;}//*********************************************************************// funkcja grupujaca w parzyste i nieparzyste wyrazy oddzielone spacja://*********************************************************************void grupuj(char zrodlo[], char parz[], char nieparz[]) { int licznik_sp=1,indeks_nieparz=0, indeks_parz=0, size=rozmiar(zrodlo); for(int i=0; i<size; i++) // petla po literach stringu { if(licznik_sp%2) // sprawdzamy parzystosc/nieparzystosc liczby dotychczasowych spacji { nieparz[indeks_nieparz++]=zrodlo[i]; } else { parz[indeks_parz++]=zrodlo[i]; } if(zrodlo[i]==32) ++licznik_sp; // spacja! nastepny wyraz! (kod ASCII spacji to 32) }}//*********************************************************************//funkcja zwracajaca rozmiar stringu w tablicy zrodlowej://*********************************************************************int rozmiar(char zrodlo[]) { int rezultat=0,i=0; while(zrodlo[i++]) ++rezultat; //dopoki istnieja jakies litery w danym stringu, zwiekszaj licznik return rezultat;}

Witam. Chcę kupić nowe głośniki komputerowe 2.1 tak do góra 100zł. Możecie jakieś polecić?

Będę wdzięczny za wszelkie uwagi, spostrzeżenia i komentarze. #include <iostream>#include <math.h> // do potegusing namespace std;void binary(int liczba);int main(){ int n,biezacy=0,nastepny,grey; long int licznik=0; cout << "Podaj n: "; // liczba bitow cin >> n; cout << n << "-bitowy Kod Graya: " << "\n\n0"; for(int i=0; i<pow(2.,n); i++) // wlasciwa petla, od 0 do 2^n { ++licznik; biezacy=i; nastepny=biezacy>>1; grey=biezacy^nastepny; // wyznaczanie i-tego wyrazu kodu Graya binary(grey); // zamiana na postac binarna i wyswietlenie cout << " Przeliczonych kombinacji: " << licznik << "\n"; } return 0;}//******************************************void binary(int liczba) // zamiana liczby dziesietnej na dwojkowa{ int tablica[100]={0},i=0; while(liczba) { tablica[i++]=liczba%2; liczba=liczba/2; } for(int j=i-1; j>=0; j--) { cout << tablica[j]; }}

Zadzwoniłem na infolinię TP i na szczęście trafiłem na ogarniętego konsultanta, wytłumaczyłem mu sprawę i przełączył mnie z powrotem na tryb kodowania Fast Path, bo rzeczywiście miałem włączony tryb interleaved (z przeplotem). Teraz pingi są w normie. Wielkie dzięki za pomoc, wasze rady bardzo mi się przydały.

Witam, uznałem, że dość teorii i czas zacząć coś samemu dłubać (od wakacji). Planuję porobić jakieś proste układy (mrugająca dioda itp). Chciałbym zrobić wstępny kosztorys i listę rzeczy do kupienia, na myśl nasuwa mi się: - lutownica; - zasilacz; - multimetr; - płytka stykowa; - elementy; Czy wg Was to dobry zestaw na początek? Mam bardzo ograniczone fundusze, jaki byłby koszt takiego zestawu na początek? Co o nim myślicie? Co byście dodali? Proszę o rady i opiszcie, jak wy zaczynaliście, od czego, jakich układów, jakich narzędzi, przydadzą mi się wasze porady. I proszę o podsunięcie jakichś prostych układów na początek typu mrugająca dioda, niedrogich i łatwych do zrobienia. Pozdrawiam.

Da się włączyć z powrotem tryb Fast?

Czym się różnią te tryby interleaved i fast? Gdzie sprawdzić, jaki mam tryb? Ponadto zauważyłem, ze modem potrzebuje większej ilości czasu na synchronizację, niż kiedyś.

Witam, mierzę ping do www.onet.pl programem WinMTR i po wykonaniu przez kilka sekund kilku próbek pomiaru patrzę na średnią - jest rzędu 50-50ms. Pamiętam, że kilka miesięcy temu było to 20-30ms. Czy wszystko jest ok? Czy to normalny ping? Jaki wy macie? ISP: T.P. S.A., Neostrada 1Mbit/s

piętro 444, combo około 150, punkty: około 20 000 , co sądzicie o wersji 1.4 ?

Wiesz, w TQ masz opcję cofania rozwoju skilli za kasę z którą nie ma co robić... Czy matematyka... hmmm... są strategie różne... matematyka to jakbyś szedł w obrażenia albo szybkość ataku, matematyka nie pomoże w doborze skilli tak aby były ze sobą zgrane... Wiadomo, że są skille bardziej przydatne i "zapychacze", ale to chyba wychodzi w praniu. W TQ jest o tyle dobrze, że zawsze można cofnąć wybór skilla i zainwestować punkty w inne. A i spotkał mnie ciekawy bug (a może feature), jak zacząłem rozwijać skilla będącego w drzewku poniżej rozwiniętego na maxa skilla (w tej samej linii), to 1 punkt w niego włożony podniósł mi tego skilla od razu na 3 lvl. To bug czy zamierzone działanie? Jeżeli bug, to można by co lvl tak dawać, potem iść do maga w mieście cofnąć punkty (oddałby 3) i tak na każdym lvl-upie mielibyśmy 2 skillpoint gratis...

Gra ktoś po necie w F2 w trybie Derby ? ;)

Wg mnie sugerowanie się czyimś buildem to strata przyjemności i satysfakcji ze stworzenia dobrej postaci, takie cheatowanie. Nie popieram takiego zachowania.

Ja połączyłem Wojnę i Łotrostwo i jestem w połowie poziomu Epickiego (39lvl) i idzie jak po maśle. Idę w szybkość ataku, walkę dwoma szybkimi mieczami naraz, sztandar bitewny, i rozwinięte pasywy. Atak podstawowy to: http://www.gamebanshee.com/titanquest/skills/onslaught.php, jak jest bossik to stawiam sztandar i parę sekund trwa walka z nim ;)

Wiesz w TQ, podobnie jak w Diablo 2, nie ma sposobów na idealną postać. Właśnie na tym polega magia gry, że postać tworzysz Ty i każda postać jest inna. ;)

Pochwalcie się swoimi postaciami. Ja mam skrytobójcę na 39 lvl, walczę 2 szybkimi mieczami naraz, rozwinięte umiejętności bojowe, idę w szybkość ataku. Stawiam sztandar i nawet najwięksi bossowie to kwestia kilkunastu sekund ;)

Najpierw musisz się dowiedzieć co robią poszczególne elementy, jak są zbudowane itp a dopiero potem możesz czytać schematy.

Płynne czytanie schematów elektronicznych to długie lata żmudnej nauki, niestety.

Witam! Napisałem 4 programy na hashowanie (mieszanie): 1. Sondowanie liniowe 2. Podwójne hashowanie 3. Sondowanie kwadratowe 4. Sondowanie kwadratowe z równomiernym wypełnieniem tablicy. Co myślicie o moich programach? Będę wdzięczny za wszelkie uwagi, spostrzeżenia, porady i wskazówki. 1. Sondowanie liniowe Rozmiar tablicy: 103 (liczba pierwsza-lepszy rezultat) // Sondowanie liniowe#include <iostream>using namespace std;void sondowanie(int tablica[], int klucz);int main(){ int tablica[103]={0},n,klucz; cout << "Podaj n: "; cin >> n; for(int i=0; i<n; i++) { cout << "Podaj element nr: " << i+1 << ": "; cin >> klucz; sondowanie(tablica, klucz); // umieszczamy klucz w wyhaszowanym indeksie tablicy } for(int j=0; j<103; j++) // po hashowaniu, wypisujemy tablice { cout << tablica[j] << ", "; } return 0;}void sondowanie(int tablica[], int klucz){ int indeks,sukces=0; indeks=klucz%103; // wyliczenie indeksu while(!sukces) // dopoki nie sukces { if(!tablica[indeks]) // jezeli nie ma kolizji, tzn tablica[indeks]=0 { tablica[indeks]=klucz; // wpisanie do tablicy sukces=1; // wolne, dalej sie while nie wykona w tym wywolanie funkcji } else // kolizja! { indeks++; // szukamy nastepnego wolnego miejsca if(indeks>=103) indeks=0; // jak dojedzie do konca tablicy to zerujemy indeks } }} 2. Podwójne hashowanie Rozmiar tablicy: 103, drugie hashowanie po liczbie 101: Zastosowałem wzory: h0=k mod N H(k)=(k mod M)+1 hi=(h0+i*H(k)) mod N , i=1,2,...,N-1 gdzie: h0 - indeks początkowy (bez kolizji), hi=i-ty indeks z kolizją, M - rozmiar tablicy (103), N - dzielnik drugiego hashowania (101), k - klucz //Podwojne haszowanie#include <iostream>using namespace std;void podwojne_hashowanie(int tablica[], int klucz);int main(){ int tablica[103]={0},n,klucz; cout << "Podaj n: "; cin >> n; for(int i=0; i<n; i++) { cout << "Podaj element nr: " << i+1 << ": "; cin >> klucz; podwojne_hashowanie(tablica, klucz); // wywolanie podwojnego haszowania dla kazdego klucza } for(int j=0; j<103; j++) // wyswietlenie tablicy { cout << tablica[j] << ", "; } cout << endl; return 0;}void podwojne_hashowanie(int tablica[], int klucz){ int indeks,sukces=0,licznik_kolizji=0,indeks_bez_kolizji; indeks=klucz%103; // obliczenie indeksu indeks_bez_kolizji=indeks; // zapamietanie pierwszego indeksu, potrzebny do wzoru na drugie haszowanie while(!sukces) // dopoki nie znajdziemy wolnego miejsca w tablicy { if(!tablica[indeks]) // jezeli nie ma kolizji { tablica[indeks]=klucz; // wpisanie klucza pod wyhaszowanym indeksem sukces=1; } else // kolizja! { licznik_kolizji++; indeks=(indeks_bez_kolizji+licznik_kolizji*(klucz%101+1))%103; // haszujemy drugi raz if(indeks>=103) indeks=0; // jak indeks przekracza rozmiary tablicy, to go zerujemy } }} 3. Sondowanie kwadratowe Rozmiar tablicy: M=103 Zastosowałem następujący wzór na sondowanie kwadratowe: hi=(h0+c*i+c*i^2) mod M , c=1/2 //Sondowanie kwadratowe#include <iostream>using namespace std;void sondowanie_kwadratowe(int tablica[], int klucz);int main(){ int tablica[103]={0},n,klucz; cout << "Podaj n: "; cin >> n; for(int i=0; i<n; i++) { cout << "Podaj element nr: " << i+1 << ": "; cin >> klucz; sondowanie_kwadratowe(tablica, klucz); // wywolanie sondowania kwadratowego dla kazdego klucza } for(int j=0; j<103; j++) // wyswietlenie tablicy { cout << tablica[j] << ", "; } cout << endl; return 0;}void sondowanie_kwadratowe(int tablica[], int klucz){ int indeks,sukces=0,licznik_kolizji=0,indeks_bez_kolizji; indeks=klucz%103; // obliczenie indeksu indeks_bez_kolizji=indeks; // zapamietanie pierwszego indeksu, potrzebny do wzoru na sondowanie kwadratowe while(!sukces) // dopoki nie znajdziemy wolnego miejsca w tablicy { if(!tablica[indeks]) // jezeli nie ma kolizji { tablica[indeks]=klucz; // wpisanie klucza pod wyliczonym indeksem sukces=1; } else // kolizja! { licznik_kolizji++; indeks=(int)(indeks_bez_kolizji+licznik_kolizji/2.+(licznik_kolizji*licznik_kolizji)/2.)%103; // sondowanie kwadratowe if(indeks>=103) indeks=0; // jak indeks przekracza rozmiary tablicy, to go zerujemy } }} 4. Sondowanie kwadratowe z równomiernym wypełnieniem tablicy Zastosowałem liczbę złotego podziału dla równomiernego wypełnienia tablicy hasciach!ącej. A=(sqrt(5)-1)/2 Zastosowałem wzór: hi=entier(M*(A*klucz mod 1)) //Sondowanie kwadratowe z rownomiernym wypelnieniem tablicy has[color= red;][ciach!][/color]acej#include <iostream>#include <math.h> // do pierwiastka (sqrt)using namespace std;void sondowanie_kwadratowe_rownomierne(int tablica[], int klucz);int main(){ int tablica[128]={0},n,klucz; // ta metoda dziala najlepiej dla rozmiaru tablicy 2^p, p nalezy do N+ cout << "Podaj n: "; cin >> n; for(int i=0; i<n; i++) { cout << "Podaj element nr: " << i+1 << ": "; cin >> klucz; sondowanie_kwadratowe_rownomierne(tablica, klucz); // wywolanie sondowania kwadratowego dla kazdego klucza } for(int j=0; j<128; j++) // wyswietlenie tablicy { cout << tablica[j] << ", "; } cout << endl; return 0;}void sondowanie_kwadratowe_rownomierne(int tablica[], int klucz){ int indeks,sukces=0,licznik_kolizji=0,indeks_bez_kolizji,B; const double A=(sqrt(5.0)-1)/2; // okolo 0,618 - dla tej wartosci uzyskujemy rownomierne rozmieszczenie kluczy w tablicy B=(int)(A*klucz); // czesc calkowita indeks=(int)(128*(A*klucz-B)); // obliczenie indeksu, wyrazenie w nawiasie - czesc ulamkowa, zamiast A*klucz%1 indeks_bez_kolizji=indeks; // zapamietanie pierwszego indeksu, potrzebny do wzoru na sondowanie kwadratowe while(!sukces) // dopoki nie znajdziemy wolnego miejsca w tablicy { if(!tablica[indeks]) // jezeli nie ma kolizji { tablica[indeks]=klucz; // wpisanie klucza pod wyhaszowanym indeksem sukces=1; } else // kolizja! { licznik_kolizji++; // nastepny (sondowanie liniowe) indeks=(int)(indeks_bez_kolizji+licznik_kolizji/2.+(licznik_kolizji*licznik_kolizji)/2.)%128; // sondowanie kwadratowe if(indeks>=128) indeks=0; // jak indeks przekracza rozmiary tablicy, to go zerujemy } }} Pozdrawiam.

Zgadza się, człowiek dysponuje prawdziwą inteligencją. :)