Algoritmusok

Klaszterezés után az előálló klaszterek "minőségét" szeretném jellemezni mérőszámmal. A klaszterekben mondjuk betűk gyűlnek: AAA BBBBBCCE EEEEEF stb.

Ideális esetben a klaszterekben homogén lenne a tartalom, de az eset nem ideális, így alakulhat ki a fenti elrendezés.

Mivel többféle módszerrel történik ugyanazon adathalmaz klaszterezése, a létrejövő dendrogramokon pedig esetenként látszanak jobb elrendeződések (nagyobbak a homogén klaszterek, több homogén klaszter jön létre, mint más esetben), így valahogyan számszerűsíteni kéne ezeket a jobb elrendezéseket. Az nem elég, hogy "látszik". :-)

Ti hogyan oldanátok ezt meg?

Sziasztok!

Adott a következő probléma, amire algoritmust keresek. (Hobbi projekt, nem munkához kell.)

Adott egy téglalap oldalméretekkel meghatározva, ezen a téglalapon kell elhelyezni n darab kisebb téglalapot, a következő szabályok szerint:

• 2 <= n <= 50
• Az elhelyezendő téglalapoknak egybevágóaknak kell lenni 
  • Közülük pontosan 1 téglalap a referencia, ennek az oldalarányát tartani kell
  • Az összess többi téglalap (n -1 darab) egyforma méretű kell legyen
  • A referencia téglalapnak ugyanakkorának (n=2 esetén) vagy nagyobbnak (n>2 esetén) kell lennie mint a többinek
• Az elrendezésnek "mátrix jellegűnek" kell lennie, azaz pl
  • n = 2 esetén egy 1 x 2 es mátrixban lenne két egyforma téglalap
  • n = 3 esetén egy 2 x 3 as mátrixban a referencia téglalap lefoglalná az első két oszlopot teljesen, és a két kis téglalap lenne a 3. oszlop két sorában
  • n = 6 esetén egy 4 x 3 as mátrixban a referencia téglalap a bal felxő 2x2 cellát foglalná le, az 5 kis téglalap pedig a jobb oldali oszlopban, illetve a referencia téglalap alatt lennének
• A téglalapok között kimaradt területet (értsd. üres cellák számát) kell minimalizálni
• Eredményként a megoldásmátrix dimenziót kell kiadni, és hogy a referencia téglalap 1x1, 2x2, 3x3 stb cellát foglal e le az eredménymátrixból

Ha jól értelmezem, a probléma a 2D packing egy speciális alesete. Ezeket itt nézegettem, de szerintem minden ottani megoldás túl általános az én esetemre.

Use case: Fotózás, referencia fotóra szeretnék különféle effekteket (jelen esetben LUT-okat) applikálni, és szeretném egy képernyőn/képen nézegetni a variációkat.

Az algoritmust alighanem Rben vagy Pythonban fogom lekódolni, így ha valaki onnan tud libet vagy csomagot ajánlani, akkor extra megköszönöm.

(Nem kész szoftvert, hanem algoritmust keresek.)

Köszi előre is a tippeket,

Csaba

Disztichon Alfa - Első magyar versgenerátor

"Az első magyar automatikus versgenerátor program, a Disztichon Alfa bármelyik Apple Macintosh számítógépen automatikusan magyar verseket, nevezetesen disztichonokat ír ki a számítógép képernyőjére. A generált versek 1) nyelvileg hibátlanok; 2) értelmesek, 3) tökéletesen kielégítik a disztichon formai ismérveit."

Könyv + melléklet elérhető innen:
https://mek.oszk.hu/11700/11744/

Disztichon Alfa 2.0
A Disztichon Alfa, Papp Tibor 1994-ben megjelent műve az első magyar digitális versgenerátor volt, amely eredeti technikai keretrendszere miatt néhány éven belül gyakorlatilag hozzáférhetetlenné vált. A közelmúltban elkészült az eredetivel megjelenésében azonos, de platformfüggetlen változat, amelyet az Irodalomtudományi Intézet honlapján, digitális szolgáltatásaink között fogunk közzétenni. A művet bemutató előadások a játékos hagyománykezelésről, a digitális megőrzés technikai paradoxonairól szólnak.

https://abtk.hu/esemenynaptar/esem%C3%A9ny%20r%C3%A9szletei/353/-/mtu-2…

Sziasztok!

Volt valamikor egy Ericsson T28 nevű telefon. Ennek a nagy durranása az volt, hogy egy gomb lenyomásával képes volt élőszóban elmondott névjegyet felhívni.  Minden névjegyhez hozzá lehetett fűzni egy hangmintát, amivel ha nagyjából egyezett az élő szó, akkor tárcsázta. Röviden egy ilyet szeretnék csinálni, de minimum megérteni. Létező szolgáltatás volt ez, csak elment mindenki inkább a szövegértésre.

Általánosítva lennének hangmintáim, és egy sorszámot kellene visszaadni, hogy melyik hangzott el összességében mondjuk 10-20 szó felismerésére számítok. A végső cél hogy ez egy mikrovezérlős céleszközbe kerülhessen, szóval távlatok bizony vannak.

Namost. Általában nem vagyok analfabéta, de ez a terület maximálisan idegen számomra, és nem is tervezem hogy a szükségesnél jobban elmerüljek benne, csak amennyire ehhez az eszközhöz feltétlenül szükséges. Természetesen látom hogy nem lesz gyaloggalopp, és ingyen ebédre sem számítok.

Első gondolatom az lenne, hogy mint a hallásunk is, szűrés után (300Hz-3kHz) felbontanám frekvenciaösszetevőkre, és ebből valahogy gyártanék egy egyedi jellemzőt, mint egy ujjlenyomatot amit aztán eltárolva össze lehetne hasonlítani a mintával. Feltételezem hogy a frekvencia komponens időtartamát belekódolva megfelelő változatosságot lehet adni a mintáknak.

Ez csak az amit eddig agyaltam, de fogalmam sincs hogy egyáltalán az irány megfelelő-e.

Van valakinek bármilyen építő jellegű észrevétele, forrása, bármi? Lehetőleg minimális matekkal!

Sziasztok!

Egész számoknak keresem a logaritmusát és mivel kernelben működne a program ezért nem használhatok lebegőpontos számokat. Van pl. egy 1 és 100e9 közötti tartomány, ezt szeretném logaritmussal leképezni egy kettő hatvány méretű területre. Teszem azt 10 bitem van, legnagyobb értékem az 1024, ez lenne a 100e9 és a hozzá közel eső számok. Az ehhez tartozó logaritmus a 1.025 alapú, mert ha x^1024 = 100e9 akkor x ~ 1.025. Mivel x bármilyen értéket felvehet 1 és 100e9 között én az ehhez legközelebbi logaritmus értéket keresem.

A jelenlegi megoldásom úgy néz ki, hogy előre kigenerálom az értékeket egy táblázatba, az első ezer számra ez így néz ki:
x : log_1.025(x)
1   : 0
2   : 28
3   : 44
4   : 56
....
912-934: 276
935-957: 277
958-981: 278
982-1000: 279

És ebben a táblázatban max 10 lépésben csinálok bináris keresést x-re és a kapott index lesz a logaritmus.

A kérdésem: lehetne-e ezt elegánsabban? Tudnátok-e mondani valami olyan módszert, amivel esetleg megspórolom a táblázatot meg a bináris keresést és képes lennék "egy lépésben" mondani x-hez egy log_1.025(x)-et? Szerencsére minden ismert fordítási időben x-et leszámítva, tehát megvan mi a legkisebb és legnagyobb x, megvan hogy hány bitre kell leképezni és milyen alapú logaritmussal.

Előre is köszönöm az ötleteket.

Sziasztok,

Azzal a kihívással találkoztam, hogy EOVX és EOVY koordinátákat kellene átszámolnom GPS lon és lat formátumokra.

Találtam online átszámítókat, de maga a képlet nincs meg. Szeretnék írni egy kis programot, ami egy csv fájlt alakít át lokálisan.

Nézegettem pár szakdolgozatban, ami elérhető online, de sajnos nem találtam meg a képletet.

Köszi a segítséget előre is.

Itt tartok:

using System;


namespace GPS_transformer
{
    class Position
    {
        public DateTime timeStamp { get; private set; }
        public string address { get; private set; }
        public int eovx { get; private set; }
        public int eovy { get; private set; }

        public double longitude { get; private set; }

        public double latitude { get; private set; }

        public Position(DateTime timeStamp, string address, int eovx, int eovy)
        {
            this.timeStamp = timeStamp;
            this.address = address;
            this.eovx = eovx;
            this.eovy = eovy;
            this.EOV_to_GPS84();
        }

        private void EOV_to_GPS84()
        {
            //longitude = 47;
            //latitude = 19;
        }
    }
}

Üdv,

Zoli

(Valószínűleg borzalmasan fogalmazok, terminológia szempontjából kövezzetek meg :) . )

Adott x db szám, és szeretnék egy átlagot (számtani közepet), anélkül, hogy tárolnom kellene az adatgyűjtés végéig az összes számot. Kevés matematikai tudásom alapján megoldhatónak tűnt, rosszul megfogalmazva: csak az átlagot tárolom, és az új adattal annak számolom ki az átlagát, és azt tárolom tovább. Így mindig csak egy számot kell tárolnom.

Próbáltam gyorsan egy egyszerű tesztet csinálni, lehet az jobban érthető egyeseknek, összehasonlítottam a két algoritmust, nem ugyan az az eredmény jön ki, de egymáshoz "nagyjából" közeli.

Kérdések: van-e ilyen algoritmus, és jó irányba próbálkoztam?

- - - - -

$nums = array();

for ($i = 0; $i < 100; $i++){
    $nums[] = rand(0,1000);
}

$sum = 0;
foreach ($nums as $num){
    $sum += $num;
}
$avg = $sum / count($nums);
unset($sum);
var_dump($avg);
unset($avg);

$first = 1;
foreach ($nums as $num){
    if ($first){
        $avg = $num;
        $first = 0;
    } else {
        $avg = ( $avg + $num ) / 2 ;
    }
}
var_dump($avg);

Van egy probléma, amit régóta próbálok megoldani. Nem létkérdés, a régi ELITE számítógépes játékból ered, abból "absztraháltam".

Szóval: adott egy áru lista kellően sok elemmel. Minden áruról tudjuk a térfogatát és az értékét. Szeretnénk egy rakteret úgy feltölteni, hogy a lehető legnagyobb értékű áru kerüljön a raktérbe.

Kicsit konkretizálva: Adott egy 100 egység méretű raktér. Adott egy 100 elemű áru lista, kb ilyesmi:

Tehát vannak áru típusok, amik egyedül is kitöltik az egész rakteret (pl Áru 5), de ha kisebb árut pakolok be, akkor több dolgot is be tudok rakni (pl Áru 1 + Áru 3).

Olvasgattam a témában, és találtam egy csomó cikket konténer feltöltés optimalizációra, de nekem azok túl bonyolultak, pl én nem szeretnék az egyes áruk alakjával foglalkozni, meg hogy miket lehet egymásra rakni, stb.

Két úttal próbálkoztam: Először arra gondoltam, hogy meghatározom, maximum hány áru fér be a listáról a raktérbe. Erre találtam egy gyors és egyszerű algoritmust. Az volt a tervem, hogy legenerálom ezzel a maximális mérettel az összes lehetséges al-listát, és kiválasztom a legnagyobb értékűt, de rájöttem, hogy 100 elemű kiindulási listával és pl 10-13 maximális áruszámmal a lehetséges listák száma túl nagy, nem végeznék valós időben.

Ezután nagyfiam javaslatára megpróbáltam egy rekurziós megoldást: legeneráltam az áruk fajlagos értékét (érték/térfogat), ez alapján sorba rendeztem az árukat. Vettem az első elemet (a legnagyobb fajlagos értékű árut), ami még befér a raktérbe, és beraktam a listába. Megnéztem, mennyi szabad raktér maradt, és ha az több, mint a legkisebb térfogatú áru, akkor a maradék raktér mérettel loopoltam a rekurziós függvényt. Szemléltetve: Lett egy új oszlop a táblázatomban fajlagos érték néven: érték/térfogat. TFH a legnagyobb fajlagos értékű áru térfogata 70, ezt berakom a listámba. Maradt 30 méretű raktér, az eredeti árulistámon 5 a legkisebb méretű áru, tehát loop. Kidobok mindent , ami nagyobb mint 30 (hiszen úgyse férnének már be), és megint veszem a legnagyobb fajlagos méretű árut, és hozzáadom a listához. Mondjuk a térfogata 25, tehát maradt még ö méretű rakterem, tehát loop.

Ezzel a megoldással az a bajom, hogy nem látom be, hogy valóban a legjobb értékű árulistát generálja nekem. Cserébe elég gyorsan végez, és legalább valamilyen listát generál.

Tudnátok adni fogozókat, hogy jó irányban indultam e el, esetleg hogyan lehetne ellenőrizni, hogy a rekurziós megoldás mennyire jó, vagy van e értelmes alternatíva? Érdekelne heurisztikus megoldás is, de ott megint elakadtam olyanokon, hogy generáljak pl max 3 elemű allistákat, aminek az össztérfogata 100. (Ha tudnék ilyet, akkor esetleg meg tudnám saccolni az értékösszeg eloszlását, hogy lássam, mennyire jó a rekurziós megoldásból kapott lista.)

Bármi kommentet megköszönök.

Nem vágom az értelmes elnevezését a problémának, de:

- van 1 csomó szatyrom, amiben amúgy egyforma színes golyók vannak, változó számban, de 1 zacskóban bármely színből max. 1,

- Legyen mondjuk a 3,

- Melyik az a 3 (vagy valamennyi) szín, ami legtöbbször szerepel együtt a szatyrokban?

Olyasmi, mintha azt kérdezném, melyik az a 2-3-4 lottószám, melyeket legtöbbször sorsoltak ki együtt.

Illetve valami graphDB-vel lehet-e ilyesmi feladatot egyszerűen megoldani

Párszor már beleakadtam ebbe a problémába, de most nagyon jó lenne 1 ilyen tool: Van 1 csomó string-em, amire meg kéne találni azt a regex pattern-t ami a lehető legszigorúbb és minden megadott stringre illeszkedik. Van erre kész megoldás, illetve hogy kéne nekiállni?

Igazából az a feladat, hogy:

• a lista 1 része meccsel regex1-re,
• a lista másik része meccsel regex2-re,
• Kéne egy 3-ik regex, amire a maradék meccsel,
• illetve a maradékból menyi az, amire regex3 mégsem meccsel.

Mondjuk úgy, hogy a nem well-formed stringeket kéne megtalálni és ez tényleg az a 2 legyen a nagyonsokból, amit biztosan javítani kell kézzel.

Ötlet, tipp, bármi?