hatékonyság - címke - it-tanfolyam.hu

Doktori értekezések védése a Miskolci Egyetemen

2020. október 17.2020. július 2. Szerző: Kiss Balázs

A Miskolci Egyetem Hatvany József Informatikai Tudományok Doktori Iskolájában 2020. július 1-jén két doktori értekezés nyilvános védésére került sor, amelyeket Szentmiklósi István Sándor és Veres Péter nyújtottak be.

Mindkét munka a logisztikai szakterülethez kapcsolódott. A cél azonos: optimalizálás. Eltérő a megközelítés: az egyik inkább hardverhez, a másik inkább szoftverhez kötődött. Mindkét védés színvonalas és igényes volt. Tartalmas és érdemi hozzászólások, javaslatok hangzottak el. A nyilvános védés méltó alkalom egy többéves kutató tevékenység lezárásához, egyben alkalmat nyújt a további folytatás irányainak meghatározására. Gratulálok a kollégáknak!

8:30-tól Szentmiklósi István Sándor kezdte, aki Raktári folyamatok optimálhatóságának vizsgálata Ipar 4.0 eszközök alkalmazásával című disszertációját védte.

A jelölt a szakirodalmi áttekintést követően ismertette, hogy megalkotott egy eszközt, amely anyagáramlási folyamatokban a szállítandó árura negatívan ható hatásokat az áru közvetlen környezetében folyamatosan méri, a mért értékeket kiértékeli és minőségromlás megállapítására is képes. Ez az eszköz az okos egységrakomány képző eszköz (OERK), amely egy mobil kiberfizikai eszköz. Az okos egységrakomány képző eszköz legfontosabb összetevői: egységrakomány képző eszköz, ami lehet egy tároló rekesz, műanyag raklap stb., ami az áru befogadására alkalmas, energia átalakító, energiamenedzsment, mikrokontroller, kiskapacitású memória, szenzoregységeket, a fizikai, kémiai és biológiai paraméterek mérésére, dátum, óra funkció és RF-ID antenna.

Kutatómunkájának eredményeit öt tézisben foglalta össze:

„I. tézis: Elkészítettem egy logisztikai eszköz lehetséges modelljét, amely anyagáramlási folyamatok során az adott áru minőségét befolyásoló paramétereket valós időben folyamatosan méri. A mért paraméterek alapján minőségkiértékelés végezhető. A megalkotott modell alapján elkészítettem annak makettjét.
II. tézis: Kidolgoztam az új eszköz egy matematikai modelljét, amely alkalmas adott logisztikai folyamat idő és költség értékeinek meghatározására adott sorbanállási modell esetén.
III. tézis: Kísérleti vizsgálataim alapján megállapítottam, hogy különböző anyagáramlási rendszereknél nagy számban keletkeznek rövid időtartalmú, de nagy energiájú tranziens jelenségek. Feltártam, hogy ezek energiája villamos energiává alakítható.
IV. tézis: Kidolgoztam és megvalósítottam a III. tézis eredményeire alapozva az eddigiektől eltérő elven működő, a rendszertelen, tranziens rezgéseket is kihasználó áramfejlesztő és energiakicsatoló eszközt.
V. tézis: Kidolgoztam egy matematikai modellt, amely modern technikai eszközök felhasználásával alkalmas a járműbeérkezések pontos meghatározására. Ennek alapján kidolgoztam egy dinamikus hozzárendelési algoritmust, amely a járműveket az időkapukhoz rendeli.”

12:00-tól Veres Péter folytatta, aki Heurisztikus módszerek alkalmazása logisztikai rendszerek tervezésében és irányításában című disszertációját védte.

A jelölt két célt fogalmazott meg a hálózatszerűen működő nagy kiterjedésű, komplex ellátási láncokhoz kötődően. Ezek: vállalaton belüli és vállalaton kívüli nagyméretű logisztikai hálózatok leírása és kezelését segítő modellek megalkotása, valamint ezen hálózatokban keletkező logisztikai feladatok megoldására olyan új módszerek, modellek és alkalmazások kidolgozása, melyek révén azok működésének hatékonysága javítható. Három modellt mutatott be: belső milkrun útvonal és raktártervezés, külső raktár pozíciójának meghatározása hozzárendeléssel és installációs költségekkel, automatikus járatmódosítás lehetőségei.

Kutatómunkájának eredményeit négy tézisben foglalta össze:

„I. tézis: Kidolgoztam egy új, szekvenciák közötti távolságok mérésére alkalmas módszert, bizonyítottam annak alkalmasságát különböző hosszúságú és felépítésű szekvenciák közötti távolságok mérésére vonatkozóan az egyezőség, a szimmetria és a távolság nem-negativitás szempontjából. A kidolgozott módszer alkalmas különböző járattervezési feladatokban az egyes megoldásváltozatokat reprezentáló permutációs egyedek közötti távolságok meghatározására.
II. tézis: Kidolgoztam egy olyan új paramétergenerálási módszert a hagyományos black hole heurisztikára, melynek révén annak konvergenciasebessége – különösen a keresési fázis elején – szignifikáns mértékben javítható. Kifejlesztettem a black hole heurisztikák egy olyan változatát, mely alkalmas szekvencia-problémák, például járattervezési feladatok megoldására.
III. tézis: Bevezettem a randomizált életciklus és az elhalálozási ráta fogalmát új egyedek generálására a Firefly algoritmus robusztusságnak növelése érdekében. Emellett bevezettem a legfényesebb memória alkalmazását Firefly algoritmusok hatékonyságának növelése céljából. Az elvégzett benchmark tesztek igazolták, hogy az általam kifejlesztett bővítmények révén az eredeti Firefly algoritmus hatékonysága növelhető.
IV. tézis: Megalkottam egy olyan általános keretrendszert, mely alkalmas speciális logisztikai modellek leszármaztatására. Ezen keretrendszer alapján megalkottam az integrált járattervezés, az elosztás és a milkrun anyagellátás egy-egy speciális modelljét. Ezen modellek által definiált NP-nehéz optimalizálási feladatok megoldására megoldásokat kerestem és egyedi módon átalakítottam. A problémák megoldására egyedi alkalmazásokat készítettem, melyekkel a kidolgozott modellek és módszerek hatékonyságát validáltam. Mindegyik probléma megoldható volt lágyszámítási módszerekkel.”

A tézisfüzetek, disszertációk végleges és korábbi műhelyvitára beadott változatai elérhetők a doktori iskola weboldalán: most még a Hírek, később a Disszertációk oldalon.

Multimédia az oktatásban 2020

2020. október 12.2020. június 13. Szerző: Kaczur Sándor

A Neumann János Számítógép-tudományi Társaság (NJSZT) „Multimédia az oktatásban” Szakosztály által – évente – szervezett XXVI. Multimédia az oktatásban című online nemzetközi konferencia került megrendezésre 2020. június 11-12-én. Az online platformot a Pexip webkonferencia szolgáltatás biztosította.

A konferencia célja

A szakmai rendezvény célja, hogy elősegítse az oktatás, valamint a kutatás és fejlesztés különböző területein dolgozó, oktató hazai és külföldi szakemberek, PhD és felsőoktatási hallgatók kapcsolatfelvételét, tapasztalatok és jó gyakorlatok cseréjét, egyes képzési szakterületekhez kapcsolódó kreditek gyűjtését.

24 témakörben hirdették meg az előadóknak a jelentkezési lehetőséget, köztük néhány hozzánk kötődő

élethelyzethez igazított tanulás,
a multimédia alkalmazása a felsőoktatásban és a felnőttképzésben,
mLearning, eLearning és környezete,
a tanulási környezet technikai, technológiai változása,
felhőalapú szolgáltatások,
multimédia és a tudományos kutatás összefonódása,
multimédia-fejlesztések, eredmények, alkalmazások bemutatása.

Letölthető a konferencia absztrakt kötete, benne a konferencia programjával.

Már többször is részt vettem előadóként ezen a konferencián szakmai előadással, magyar és/vagy angol nyelvű cikkel, poszterrel az oktatói csapat tagjaival együtt. Ezek a publikációs listámban megtalálhatók. Legutóbb tavaly is, lásd Multimédia az oktatásban 2019.

2020-ban előadást tartottam “Analysis of the Sorting with distribution and counting algorithm; is it worth or not?” (Szétosztva leszámoló rendezési algoritmus hatékonyságának vizsgálata, jobb vagy sem?) címmel 20 percben, amely a konferencia “Multimédia-fejlesztések, eredmények, alkalmazások bemutatása/ Az űrkutatás és űrtevékenység a modern oktatásban” című szekciójába került. Előadásom rövid, angol nyelvű összefoglalója az absztrakt kötet 19-20. oldalán olvasható. Előadásom prezentációját ILIAS e-learning tananyagban tesszük elérhetővé tanfolyamaink résztvevői számára.

Előadásom témája a Java SE szoftverfejlesztő tanfolyam 5-8. óra: Vezérlési szerkezetek, 9-12. óra: Metódusok, rekurzió, 13-16. óra: Tömbök alkalmaihoz kapcsolódik.

A teljes konferencia élő közvetítésben zajlott. 2 nap alatt 51 előadás hangzott el. 5 országból 300 fő követte. Egy-egy szekciót átlagosan 50 fő látogatott. A plenáris előadások a mesterséges intelligencia témakörhöz kapcsolódtak. Külön kiemelném Gulyás István kiváló összefoglalóját a 4 ipari forradalomról. A program szerteágazó, színvonalas és izgalmas volt. Az aktuális digitális oktatás technológiai és módszertani kihívásaival több előadás is foglalkozott. Számomra hasznosnak bizonyult az ezekhez kötődő többféle nézőpontból való megközelítés. A szakmai társalgás virtuális konferenciaszobákban folyt, és a szervezők még további 3 beszélgetős sarkot is létrehoztak a kötetlen kommunikáció biztosítására. A szervezés abszolút profi volt, a korábbi évek offline eseményeihez hasonlóan. Jövőre is szívesen csatlakozom a rendezvényhez. 2021-ben a Multimédia az oktatásban konferencia helyszíne a Dunaújvárosi Egyetem lesz.

Barátságos számpárok

2020. július 23.2018. július 19. Szerző: Balogh Péter

Azokat a számpárokat, amelyekre igaz, hogy az egyik szám önmagánál kisebb osztóinak összege megegyezik a másik számmal és fordítva, külön-külön barátságos számoknak, együtt barátságos számpárnak hívjuk.

Másképpen: legyen d(n) az n természetes szám önmagánál kisebb osztóinak összege. Ha d(a)=b és d(b)=a, ahol a≠b, akkor a és b barátságos számpár.

Például: (220; 284), hiszen a 220 önmagánál kisebb osztói: 1, 2, 4, 5, 10, 11, 20, 22, 44, 55, 110 és ezek összege 284, illetve 284 önmagánál kisebb osztói: 1, 2, 4, 71, 142 és ezek összege 220.

Írjunk Java programot, amely kiírja az 1-10000 zárt intervallumban található barátságos számpárokat!

1. megoldás

A baratsagosSzamparok1() eljárás ciklusai a brute force módszer szerint behelyesítik az összes lehetséges számot. Minimális lépésszám csökkentésre adódik lehetőség, hiszen a belső ciklus j változója i+1-ről indítható (így a megtalált számpárok nem íródnak ki fordítva is, mert teljesül, hogy i<j).

Az osztokOsszege1(n) függvény is minden lehetséges osztót figyelembe vesz 1-től n-1-ig.

private static int osztokOsszege1(int n) {
  int s=0;
  for(int i=1; i<n; i+=1)
    if(n%i==0)
      s+=i;
  return s;
}

private static void baratsagosSzamparok1() {
  System.out.println("Barátságos számpárok 1-től 10000-ig:");
  for(int i=1; i<=10000; i++)
    for(int j=i+1; j<=10000; j++)
      if(i==osztokOsszege1(j) && j==osztokOsszege1(i))
        System.out.println("("+i+"; "+j+")");
}

private static int osztokOsszege1(int n) {

int s=0;

for(int i=1; i<n; i+=1)

if(n%i==0)

s+=i;

return s;

}

private static void baratsagosSzamparok1() {

System.out.println("Barátságos számpárok 1-től 10000-ig:");

for(int i=1; i<=10000; i++)

for(int j=i+1; j<=10000; j++)

if(i==osztokOsszege1(j) && j==osztokOsszege1(i))

System.out.println("("+i+"; "+j+")");

}

2. megoldás

Kisebb módosításokkal a lépésszám csökkenthető. A baratsagosSzamparok2() eljárás külső ciklusánál figyelembe vettem, hogy a legkisebb barátságos számpár kisebb tagja nagyobb 200-nál. Mivel a barátságos számpárok tagjainak paritása mindig megegyezik (azaz mindkettő páros vagy mindkettő páratlan), így a belső ciklus j változója indítható i+2-ről és léptethető kettesével ( j+=2), és továbbra is teljesül, hogy i<j.

Az osztokOsszege2(n) függvényt is módosítottam. Mivel az 1 minden számnak osztója, illetve a 2 minden páros számnak osztója, így s lehet 3 vagy 1 és a ciklus indítható 3-ról. A páros számok esetén a számnál kisebb legnagyobb osztó maximum n/2 lehet, illetve ugyanez páratlan számok esetén n/3 lehet. Ezekre figyelve a max változó adja a ciklus léptetésének felső határát. Az i változó léptetésénél figyelembe vettem, hogy páratlan számnak csak páratlan osztói lehetnek ( i=3-mal szinkronban).

private static int osztokOsszege2(int n) {
  int s=(n%2==0?3:1);
  int max=(n%2==0?n/2:n/3);
  int lepes=(n%2==0?1:2);
  for(int i=3; i<=max; i+=lepes)
    if(n%i==0)
      s+=i;
  return s;
}

private static void baratsagosSzamparok2() {
  System.out.println("Barátságos számpárok 1-től 10000-ig:");
  for(int i=200; i<=10000; i++)
    for(int j=i+2; j<=10000; j+=2)
      if(i==osztokOsszege2(j) && j==osztokOsszege2(i))
        System.out.println("("+i+"; "+j+")");  
}

private static int osztokOsszege2(int n) {

int s=(n%2==0?3:1);

int max=(n%2==0?n/2:n/3);

int lepes=(n%2==0?1:2);

for(int i=3; i<=max; i+=lepes)

if(n%i==0)

s+=i;

return s;

}

private static void baratsagosSzamparok2() {

System.out.println("Barátságos számpárok 1-től 10000-ig:");

for(int i=200; i<=10000; i++)

for(int j=i+2; j<=10000; j+=2)

if(i==osztokOsszege2(j) && j==osztokOsszege2(i))

System.out.println("("+i+"; "+j+")");

}

3. megoldás

Az eddigi két egymásba ágyazott ciklus helyett átszervezhető a baratsagosSzamparok3() eljárás. A j>i && osztokOsszege2(j)==i feltétel kiértékelése így sokkal hatékonyabb.

private static void baratsagosSzamparok3() {
  System.out.println("Barátságos számpárok 1-től 10000-ig:");
  for(int i=200; i<=100000; i++) {
    int j=osztokOsszege2(i);
    if(j>i && osztokOsszege2(j)==i)
      System.out.println("("+i+"; "+j+")");  
  }
}

private static void baratsagosSzamparok3() {

System.out.println("Barátságos számpárok 1-től 10000-ig:");

for(int i=200; i<=100000; i++) {

int j=osztokOsszege2(i);

if(j>i && osztokOsszege2(j)==i)

System.out.println("("+i+"; "+j+")");

}

Vajon milyen nagyságrendű különbségek adódnak, ha összehasonlítjuk a három megoldás futási idejét?

Az 1. megoldás futási ideje 1104156 ms, a 2. megoldásé 257055 ms, a 3. megoldásé 121 ms. A konkrét értékek helyett a nagyságrendet megfigyelve a különbség nagyon látványos.

Mindhárom megoldás helyes és megkapjuk az intervallumban található öt barátságos számpárt: (220; 284), (1184; 1210), (2620; 2924), (5020; 5564), (6232; 6368).

A bejegyzéshez tartozó teljes – időméréssel kiegészített – forráskódot ILIAS e-learning tananyagban tesszük elérhetővé tanfolyamaink résztvevői számára.

Források:

Wikipédia – Barátságos számok
Wikipedia – Amicable numbers
www.mathe.tu-freiberg.de – Vollkommene, befreundete und gesellige Zahlen
gorbem.hu – Barátságok számok
Hasonló feladat: https://projecteuler.net/problem=21 és megoldás: http://code.jasonbhill.com/c/project-euler-problem-21/

A feladat a Java SE szoftverfejlesztő tanfolyam szakmai moduljának 9-12. óra: Metódusok, rekurzió alkalomhoz kötődik.

Nemzetközi Pi nap

2020. november 14.2018. március 14. Szerző: Kaczur Sándor

A Pi-t ( $π$ ) mindenki ismeri. Talán sokaknak kedvenc története is van a $π$ -vel kapcsolatosan, amelyet iskolában vagy utazásai alatt szerzett. A $π$ Euklidesz geometriájában a kör kerületének és átmérőjének arányát jelöli. A $π$ irracionális szám, azaz végtelen, nem szakaszos tizedestört; másképpen számjegyei között nincs ismétlődés. A $π$ értékével a hétköznapokban 3,14-dal szokás számolni, de a tudomány területén ennél sokkal pontosabb közelítést szokás alkalmazni. A $π$ közelítése az informatikának köszönhetően akár több millió tizedesjegyig is lehetséges (például: S. Memphill: Pi to 1,000,000 places).

A nemzetközi Pi nap alkalmából (március 14) megvalósítottunk néhány – végtelen összeggel és szorzattal – $π$ közelítésre való képletet, algoritmust Java nyelven.

1. Viète-féle sor

  private static void megold1() { //Viète-féle sor
    double p=1, pi=1;
    for(int i=11; i>1; i--) {
      p=2;
      for(int j=1; j<i; j++)
        p=2+Math.sqrt(p);
      p=Math.sqrt(p);
      pi=pi*p/2;
    }
    pi*=Math.sqrt(2)/2;
    pi=2/pi;
    System.out.println(pi);
  }

private static void megold1() { //Viète-féle sor

double p=1, pi=1;

for(int i=11; i>1; i--) {

p=2;

for(int j=1; j<i; j++)

p=2+Math.sqrt(p);

p=Math.sqrt(p);

pi=pi*p/2;

}

pi*=Math.sqrt(2)/2;

pi=2/pi;

System.out.println(pi);

}

A módszer néhány eredménye: i=5 esetén 3.140331156954752 (2 tizedesjegyre pontos), i=10 -nél 3.1415914215112 (5 tizedesjegyre pontos), i=11 esetén 3.1415923455701176 (6 tizedesjegyre pontos).

2. Leibniz-féle sor

  public static void megold2() { //Leibniz-féle sor
    double s=0;
    for (int i=0; i<=2500; i++)
      s+=Math.pow(-1, i)/(2*i+1);
    double pi=s*4;
    System.out.println(pi);
  }

public static void megold2() { //Leibniz-féle sor

double s=0;

for (int i=0; i<=2500; i++)

s+=Math.pow(-1, i)/(2*i+1);

double pi=s*4;

System.out.println(pi);

}

A módszer néhány eredménye: a 24. lépéstől stabil 1 tizedesjegyre, a 626. lépéstől stabil 2. tizedesjegyre, a 2453. lépéstől stabil 3 tizedesjegyre (hiszen alternál).

3. Wallis-formula

  public static void megold3() { //Wallis-formula
    double p=1;
    for (int i=2; i<=17000; i+=2)
      p*=(1.0*i/(i-1)*(1.0*i/(i+1)));
    double pi=p*2;
    System.out.println(pi);
  }

public static void megold3() { //Wallis-formula

double p=1;

for (int i=2; i<=17000; i+=2)

p*=(1.0*i/(i-1)*(1.0*i/(i+1)));

double pi=p*2;

System.out.println(pi);

}

A módszer néhány eredménye: A 38. lépéstől 1, a 986. lépéstől 2, a 2650. lépéstől 3, a 16954. lépéstől már 4 tizedesjegyre pontos.

4. Csebisev-sor

  private static void megold8() { //Csebisev-sor, V1
    double s=0;
    for (int k=0; k<=20; k++)
      s+=(Math.pow(-1, k)*Math.pow(Math.sqrt(2)-1, 2*k+1))/(2*k+1);
    double pi=s*8;
    System.out.println(pi);
  }

private static void megold8() { //Csebisev-sor, V1

double s=0;

for (int k=0; k<=20; k++)

s+=(Math.pow(-1, k)*Math.pow(Math.sqrt(2)-1, 2*k+1))/(2*k+1);

double pi=s*8;

System.out.println(pi);

}

A módszer k=10 -re már 8 tizedesjegyig pontos.

A bejegyzéshez tartozó teljes forráskódot – további 8 közelítő módszer implementációjával együtt – ILIAS e-learning tananyagban tesszük elérhetővé tanfolyamaink résztvevői számára.

A feladat a Java SE szoftverfejlesztő tanfolyam szakmai moduljának 5-8. óra: Vezérlési szerkezetek alkalmához kötődik.

Péntek 13

2020. november 14.2017. október 13. Szerző: Kaczur Sándor

Sokan szerencsés vagy balszerencsés napnak tartják a péntek tizenharmadikát. Évente 1-2-3 alkalommal megtörténik, hogy a hónap 13. napja péntekre esik (minden vasárnap kezdődő hónapban). A hónap 13. napja valamivel valószínűbben péntekre esik, mint a hét bármely más napja. Átlagosan 212,35 naponként fordul elő péntek 13. Előfordulhat két egymást követő hónapban is, de akár 14 hónap is eltelhet két péntek 13 között.

A nap említése sok helyen előfordult: regényekben, filmekben, híres emberek születése vagy halála is esett péntek 13-ra. Átlag alatti közlekedési baleset szokott előfordulni ezeken a napokon – talán mert az emberek óvatosabbak. Kimutatható összefüggést/korrelációt, „péntek 13 hatást” figyeltek meg a tőzsdén is.

Hasznos lehet, ha írunk egy Java programot, amely néhány egymást követő év esetén listázza a konzolra azokat a hónapokat, amikor 13-a péntekre esik.

Tervezés

Legyen egy listFriday13(year) eljárás, amely a paraméterként átvett évben kiírja azokat a hónapokat a konzolra, amelyekben 13-a péntekre esett/esik. Például: 2017: január, október. A hónapok nevei magyar nyelven jelenjenek meg. Az adott év hónapjain végighaladó ciklus legyen hatékony. Optimalizáljunk a ciklus lépésszámára! A ciklus álljon le, ha már talált 3 hónapot (mivel nem lehet több).

1. megoldás

A megoldást a tematika Tömbök témakörében az alábbiak szerint készíthetjük el. Előismeretek: változók, operátorok, ciklusok, programozási tételek, metódusok, tömbök, String összehasonlítás. Az ismert öröknaptár algoritmusokból implementáljuk az egyiket, például:

  static boolean isLeapYear(int year) {
    return (year>=1582) &&
           ((year%4==0 && year%100!=0) || (year%400==0));
  }

  public static String dayOfWeek(int year, int month, int day) {
    int centuryCode=2*(3-year/100%4);
    int yearOfCentury=year%100;
    int monthCode=new int[] {-1,
      isLeapYear(year)?6:0, isLeapYear(year)?2:3, 3, 6,
      1, 4, 6, 2,
      5, 0, 3, 5
    }[month];
    int dayCode=(centuryCode+yearOfCentury+
        yearOfCentury/4+monthCode+day)%7;
    return new String[] {
      "Sunday", "Monday", "Tuesday", "Wednesday",
      "Thursday", "Friday", "Saturday"
    }[dayCode];
  }
  
  public static void listFriday13v1(int year) {
    String[] months={"",
      "január", "február", "március", "április",
      "május", "június", "július", "augusztus",
      "szeptember", "október", "november", "december"};
    System.out.print(year+": ");
    for(int month=1, count=1; month<=12 && count<=3; month++) {
      if(dayOfWeek(year, month, 13).equals("Friday")) {
        System.out.print(months[month]+", ");
        count++;
      }
    }
    System.out.println();
  }

static boolean isLeapYear(int year) {

return (year>=1582) &&

((year%4==0 && year%100!=0) || (year%400==0));

}

public static String dayOfWeek(int year, int month, int day) {

int centuryCode=2*(3-year/100%4);

int yearOfCentury=year%100;

int monthCode=new int[] {-1,

isLeapYear(year)?6:0, isLeapYear(year)?2:3, 3, 6,

1, 4, 6, 2,

5, 0, 3, 5

}[month];

int dayCode=(centuryCode+yearOfCentury+

yearOfCentury/4+monthCode+day)%7;

return new String[] {

"Sunday", "Monday", "Tuesday", "Wednesday",

"Thursday", "Friday", "Saturday"

}[dayCode];

}

public static void listFriday13v1(int year) {

String[] months={"",

"január", "február", "március", "április",

"május", "június", "július", "augusztus",

"szeptember", "október", "november", "december"};

System.out.print(year+": ");

for(int month=1, count=1; month<=12 && count<=3; month++) {

if(dayOfWeek(year, month, 13).equals("Friday")) {

System.out.print(months[month]+", ");

count++;

}

System.out.println();

}

A listFriday13v1(year) eljárásban az elemi döntés egyszerű: dayOfWeek(year, month, 13).equals("Friday"). Épít az öröknaptárt megvalósító – saját – szöveget visszaadó függvényre. A függvény az algoritmus szerinti kódok előállításához ( centuryCode, monthCode, dayCode) felhasználja a szökőév ( isLeapYear(year)) függvényt, valamint két – konstansnak is tekinthető – névtelen tömböt ( new int[], new String[]).

2. megoldás

A megoldást a tematikában Objektumorientált programozás témakörében az alábbiak szerint készíthetjük el. Felhasználjuk eddigi ismereteinket és a JDK beépített dátumkezelő (tároló, formázó) funkcióit (osztályok, interfészek, konstansok, felsorolások).

  public static void listFriday13v2(int year) {
    SimpleDateFormat dfMonth=
      new SimpleDateFormat("MMMM", new Locale("hu"));
    ArrayList<String> listMonths=new ArrayList<>();
    for(int month=1, count=1; month<=12 && count<=3; month++) {
      GregorianCalendar date=new GregorianCalendar(year, month-1, 13);
      if(date.get(Calendar.DAY_OF_WEEK)==Calendar.FRIDAY) {
        listMonths.add(dfMonth.format(date.getTime()));
        count++;
      }
    }
    System.out.println(year+": "+String.join(", ", listMonths));
  }

public static void listFriday13v2(int year) {

SimpleDateFormat dfMonth=

new SimpleDateFormat("MMMM", new Locale("hu"));

ArrayList<String> listMonths=new ArrayList<>();

for(int month=1, count=1; month<=12 && count<=3; month++) {

GregorianCalendar date=new GregorianCalendar(year, month-1, 13);

if(date.get(Calendar.DAY_OF_WEEK)==Calendar.FRIDAY) {

listMonths.add(dfMonth.format(date.getTime()));

count++;

}

System.out.println(year+": "+String.join(", ", listMonths));

}

A listFriday13v2(year) eljárás a Calendar absztrakt osztály konstansait használja fel az elemi döntéshez: date.get(Calendar.DAY_OF_WEEK)==Calendar.FRIDAY. A dátumot a GregorianCalendar konstruktora példányosítja és figyelni kell a 0-bázisú hónapkezelésre. A dátum formázása során ( dfMonth) beállítjuk a megfelelően paraméterezett ( "hu") Locale típusú objektumot és a hónap hosszú nevét kérjük ( "MMMM"). A metódus generikus listába gyűjti a kiválasztott hónapok nevét, amiket végül a String.join() függvény fűz össze a megjelenítéshez.

Eredmény

A vezérlésben egy ciklus 2017-től 2036-ig szervezve az alábbi eredményt adja:

Péntek 13 előfordulások
2017: január, október
2018: április, július
2019: szeptember, december
2020: március, november
2021: augusztus
2022: május
2023: január, október
2024: szeptember, december
2025: június
2026: február, március, november
2027: augusztus
2028: október
2029: április, július
2030: szeptember, december
2031: június
2032: február, augusztus
2033: május
2034: január, október
2035: április, július
2036: június

Péntek 13 előfordulások

2017: január, október

2018: április, július

2019: szeptember, december

2020: március, november

2021: augusztus

2022: május

2023: január, október

2024: szeptember, december

2025: június

2026: február, március, november

2027: augusztus

2028: október

2029: április, július

2030: szeptember, december

2031: június

2032: február, augusztus

2033: május

2034: január, október

2035: április, július

2036: június

A bejegyzéshez tartozó teljes forráskódot ILIAS e-learning tananyagban tesszük elérhetővé tanfolyamaink résztvevői számára.

A feladat a Java SE szoftverfejlesztő tanfolyam tematikájához kötődik a fentiek szerint: 13-16. óra: Tömbök alkalom, illetve 17-28. óra: Objektumorientált programozás alkalom.