Algoritmusok

Sziasztok!

Belebotlottam a 8 királynő problémába. Írtam is valamit, az eredmény korrekt, ugyanakkor
nem tudom, hogy futásidőben mennyire jó vagy nem. Van valakinek tapasztalata arról,
hogy milyen hardveren milyen futásidőt illik elérni? Én egyetlen szálon tesztelem most.

A válaszokat előre is köszönöm, üdv mindenkinek.

Na már csak ezzel kéne valamit kezdeni azt kész vagyok
//Form betöltésénél fúson le ez valahogy

Private Sub Form_Load()

hogy ha nem szám van a Csoport_Gruppe mezőben akkor a nyomógombok pirosok és tiltva vannak
ha szám van ami 1-12 ig. szokott lenni akkor zöld és használható a nyomógomb

Acces Gombok
Tábla

Légyszíves aki használ ilyet és van benne tapasztalta ossza meg velem.
Köszönöm!

Adott egy oldObject es egy newObject (mindketto instanceof MyClass. oldObjectnek ha van egy property-je, elvesszuk tole, es atadjuk newObjectnek (tehat vagy mindkettobe write-olunk vagy egyikbe sem)

Melyik a helyes velemenyetek szerint?

// oldObject methodjakent
$oldObject->givePropToNewObject($newObject);

es/vagy

// newObject methodjakent
$newObject->takePropFromOldObject($oldObject);

es/vagy

// static methodkent
MyClass::movePropFromObjectToObject($oldObject, $newObject);

?

Sziasztok!

Ha "Tükör" szó hexában 5420 6b7e 727c, akkor az milyen karakterkódolás? Az SMS érkezik így.

Base64-ben: IFR+a3xy

Sziasztok,

Periodiszitast kell tesztelnem kulombozo fuggvenyeken. Irtam, egy megoldast (Python-ban) ami ugy nez ki mukodik:


""" Visulation """
import matplotlib.pyplot as plt


""" szamitas """
from numpy import median, mean, greater, less, array as narray, append as nappend
from scipy.signal import argrelextrema

f, sp = plt.subplots(2, sharex=True)
X = [ i for i in range(0,len(fuggveny))]
sp[0].plot( X, fuggveny, c='red' )

def periodic(threshold):
""" fuggveny eltolasa es az eredetihez kepesti kulombbsegenek szamitasa """
diff = []
for i in range(0,len(threshold)):
diff.append( sum(map(lambda x,y: abs(x-y), threshold,threshold[-i:] + threshold[0:-i])))

"""
" A fuggveny szelsoertekeinek szamitasa
"""
localmax = argrelextrema(narray(diff), greater)
localmin = argrelextrema(narray(diff), less)
if len(localmax) > len(localmin) :
periodlen = [ localmax[0][i+1]-localmax[0][i] for i in range(0,len(localmax[0])-1) ]
else:
periodlen = [ localmin[0][i+1]-localmin[0][i] for i in range(0,len(localmin[0])-1) ]

"""
" Eredmeny tesztelese:
" ha tobb mint 4 lehetseges periodosunk van
" elfogadjuk a periodicitast ha a fuggveny szelsoertekek kozotti tavolsag szimetrikusak
"""
if len(periodlen) > 4 :
medianp = median(periodlen)
if ( mean(periodlen) > 0.95*medianp) and (mean(periodlen) < 1.05*medianp):
print "There is periodicity! Length of period: " + str(int(medianp))
""" eredmeny abrazolasa """
sp[1].plot( [ i for i in range(0,len(diff)) ], diff)
return int(medianp)
else:
return periodic(diff)
else:
return 0

periodic(fuggveny)
plt.show()

A kovetkezo kerdeseim lennenek:
* helyese-e? Ugy ertem van-e olyan bemenet ami vegtelen ciklusba kuldi?
* tudtok-e gyorsabb megoldast, az eddigi teszteken elegedet voltam az eredmennyel, de ugy erzem eleg eroforras igenyes, mivel n* kell eltolnunk minden egyes tesztelesnel, igy ha jol lattom n^2 matrix-al dolgozun. Biztos, vagyok benne, hogy van valami gyorsabb algoritmus erre. Statisztikai elemzeshez kell, muszaly rubusztnak lennie.

Van egy olyan problémám, hogy adott n elem, amit m csoportba kell rendezni. Az alappélda egyszerű, adott 6 elem, amit két egyforma elemszámú csoportba kell rendezni. A kérdés, hányféleképpen tudom ezt megtenni? Emlékeim szerint ez a kérdéskör a kombinatorika témakörbe tartozik. Utoljára pont húsz éve tanultam kombinatorikát, szóval megkoptak az emlékeim.

Kérdésem, mi a pontos témakör, van erre valami ismert algoritmus amit használni lehet kevésbé egyszerű esetben (pl 10 elem, két nem feltétlen egyenlő elemszámú csoportba, de a csoportok elemszáma minimum 3; 100 elem, egyenlő elemszámú, de akárhány csoportba, stb)?

Szóval pointereket kérnék, merre olvasgassak utána (wikipédia is jöhet, abban is elvesztem).

Köszönöm,

Csaba

Arra lennék kíváncsi, hogy ki miként gondolja jónak az if-else szerkezet használatát.
Az if-else szerkezet használatára rengeteg ajánlás született az évek során.
Ezeket megpróbálom összeszedni, ha valakinek még jut az eszébe, akkor azokat is örömmel várom:

1. Ha csak lehet else-t ne használjunk, mert nehezen érthető lesz a kód! Ez főként hosszú if-es részeknél lehet, illetve egymásba ágyazottaknál.
   pl.

   
   if (cond1) {
     if (cond2) {
       if (cond3) {
       } else {
       }
     } else {
     }
   } else {
   }
   

2. Az előző pont egyik megoldásaként szokták ajánlani, hogy az összes ágára külön if készüljön.
   pl.

   
   if (cond1 && cond2 && cond3) {
   }
   if (cond1 && cond2 && !cond3) {
   }
   if (cond1 && !cond2) {
   }
   if (!cond1) {
   }
   

3. Ha használunk is else-t, akkor se használjunk egymásba ágyazott if-es szerkezetet!
4. Funkcionális programozást kedvelők szerint if-et egyáltalán ne használjunk, mert az side effect-et okoz, hanem csak az if-else-es ternary operátort (vagy ? : más nyelvekben)
5. if-ekben return-nel térjünk vissza a függvényből, így laposan (flat) tartható a struktúra. Ez szembe megy az egy függvény egy kilépési pont elvnek.
   pl.

   
   if (cond1) {
     return;
   }
   ...
   

6. if-else-ek helyett hacsak tudunk használjunk switch-et vagy pattern matching-et.
7. Többszörös típus vizsgálat helyett használjuk az OO polimorfizmusát.
8. Minden if után szerepeljen else ág is, akár üresen is, hogy lehessen látni, hogy nem felejtődött el.

Ha valaki kedvet érez, akkor refaktorálhatja a kedvenc nyelvén a Gilded Rose Kata-t, amiben rengeteg egymásba ágyazott if-else szerkezet van.
A feladat röviden:

1. Tesztek írása minden estre.
2. Kód refaktorálása, hogy könnyen érthető és módosítható legyen.
3. Új funkció hozzáadása: "Conjured" elemek kezelése

Nemrég gondolkodtam, hogy nekiállok csak úgy programozgatni szabadidőmben, egy felülről 2d mászkálós (egy kicsit klasszikus rougelike) játék lenne a cél, egy elég nagy térképen... itt jön kérdés, amire nem találtam választ: hogy lehetne leglogikusabban megoldani, hogy egy bolygó (kisbolygó :) ) gömbfelszinén a klasszkus 2D megjelenítéssel mozogjon valaki? Ugyanis ha elindul észak felé (felfelé), előbb utóbb eljut az Északi-sarkra, ahonnán tovább menve felfele, valójában már fejjel lefele megy dél felé, meg a többi problémás dolog, ami ebből a furcsa vetületből fakad...
Elsőre ilyen halva született ötletnek tűnik, de hátha valakinek lenne ötlete... :)

Üdv!

A cím nem biztos, hogy a legjobb, mert a szinkronizálás sok mindent jelenthet.

A következőt szeretném elérni: actorokat ütemezni, velük diszkrét esemény szimulációt csinálni.

A jelenlegi megvalósítás: egy actor a rendszer minden elemének küld egy "tick" üzenetet. Ennek hatására az actorok egymásnak küldenek mindenfélét, majd visszaküldenek egy "tock"-ot.

Az akka annyit garantál, hogy az egy actor által egy actornak küldött üzenetek sorban érkeznek meg. Ha ugyanannak az actornak többen küldenek üzenetet, azok valahogy összefésülődnek.

Nekem azt kellene biztosítanom, hogy a két "tick" közt küldött üzenetek a "tick"-ek közt fel is dolgozódjanak. Megoldható-e ez?

(Mobilról írtam, próbálok majd pontosítani)

Sziasztok.

Adott néhány ezer tizedes tört. Kerekíteni szeretném őket oly módon, hogy ez legyen a követendő példa az 5-re végződőeknél:

0.5 --> 0
1.5 --> 2
2.5 --> 2
3.5 --> 4
4.5 --> 4
5.5 --> 6

és ne ez:

0.5 --> 1
1.5 --> 2
2.5 --> 3
3.5 --> 4
4.5 --> 5
5.5 --> 6

Kérésem az, hogy míg utóbbinál, a felfelé kerekítés elve megy, az első verziónál valóban egyenlő valószínűséggel tudom felfelé és lefelé kerekíteni a számokat? Cél az, hogy a kerekített számok összegzésekor minél közelebbi érték legyen az eredetihez.

Másképp megfogalmazva:

a számhalmazból random módon kiválasztok 5000-et, majd kerekítés nélkül összeadom, ez legyen A.

Ezután a kerekített értékeket is összeadom, ez legyen B.

A és B különbségének abszolút értéke legyen minél közelebb a nullához, ez lenne a cél. Kérdés: Melyik kerekítés a hatásosabb, a felfelé kerekítés, vagy a másik?

Megjegyzés:
A nem 5-re végződő számok esetében a felfelé- és lefelé kerekítés hagyományos módszerei volnának.