A Fájlkezelés 5. feladat megoldása Java nyelven

A feladat aminek a megoldását itt közzéteszem, itt található. A feladatot csak forráskódként teszem közzé, a project-nek itt nem látnám értelmét.

Természetesen számtalan más módon is meg lehetne oldani a feladatot, én a tanult eszközök és alap algoritmusok segítségével mutatom be a megoldásokat.

package webotlet_fajlkezeles5;

import java.io.*;

public class Webotlet_Fajlkezeles5
{
  
  public static void main( String[] args )
  {
    RandomAccessFile raf;
    
    int[] tomb1 = null;
    int[] tomb2 = null;

// adatok beolvasása két tömbbe    
    try
    {
      String sor;
      raf = new RandomAccessFile( "szamok2oszlop.txt", "r" );
      int db = 0;
      for( sor = raf.readLine(); sor != null; sor = raf.readLine() )
      {
        db++;
      }
      
      raf.seek( 0 );
      tomb1 = new int[db];
      tomb2 = new int[db];
      
      String[] tmp = new String[2];
      int idx = 0;
      for( sor = raf.readLine(); sor != null; sor = raf.readLine() )
      {
        tmp = sor.split( ";" );
        tomb1[idx] = Integer.parseInt( tmp[0] );
        tomb2[idx] = Integer.parseInt( tmp[1] );
        idx++;
      }
      raf.close();
    }
    catch( IOException e )
    {
      System.out.println( "HIBA" );
    }

//    Melyik tömbben nagyobb az elemek összege?
    int osszeg1 = 0;
    int osszeg2 = 0;
    for( int i = 0; i < tomb1.length; i++ )
    {
      osszeg1 += tomb1[i];
      osszeg2 += tomb2[i];
    }
    
    if( osszeg1 > osszeg2 )
    {
      System.out.println( "Az elso tomb elemeinek osszege nagyobb." );
    }
    else if( osszeg1 < osszeg2 )
    {
      System.out.println( "A masodik tomb elemeinek osszege nagyobb." );
    }
    else
    {
      System.out.println( "A ket tomb elemeinek osszege egyenlo." );
    }

//    Melyik tömb tartalmaz több negatív számot?
    int negDb1 = 0;
    int negDb2 = 0;
    for( int i = 0; i < tomb1.length; i++ )
    {
      if( tomb1[i] < 0 )
      {
        negDb1++;
      }
      if( tomb2[i] < 0 )
      {
        negDb2++;
      }
    }
    
    if( negDb1 > negDb2 )
    {
      System.out.println( "Az elso tomb tartalmaz tobb "+
              "negativ szamot." );
    }
    else if( negDb1 < negDb2 )
    {
      System.out.println( "A masodik tomb tartalmaz tobb "+
              "negativ szamot." );
    }
    else
    {
      System.out.println( "A ket tombben ugyanannyi negativ "+
              "szam van." );
    }

// másik megoldás
// egy számlálót növelek, ha az első tömbben negatív szám van
// és csökkentem, ha a másodikban
// a változó kiértékelését lásd a feltételeknél
    int negDb = 0;
    for( int i = 0; i < tomb1.length; i++ )
    {
      if( tomb1[i] < 0 )
      {
        negDb++;
      }
      if( tomb2[i] < 0 )
      {
        negDb--;
      }
    }
    
    if( negDb > 0 )
    {
      System.out.println( "Az elso tomb tartalmaz tobb "+
              "negativ szamot." );
    }
    else if( negDb < 0 )
    {
      System.out.println( "A masodik tomb tartalmaz tobb "+
              "negativ szamot." );
    }
    else
    {
      System.out.println( "A ket tombben ugyanannyi negativ "+
              "szam van." );
    }

//    Van-e olyan szám, ami mindkét tömbben ugyanott található?
    boolean van = false;
    for( int i = 0; i < tomb1.length; i++ )
    {
      if( tomb1[i] == tomb2[i] )
      {
        van = true;
        break;
      }
    }
    
    if( van )
    {
      System.out.println( "Van ilyen szam." );
    }
    else
    {
      System.out.println( "Nincs ilyen szam." );
    }
    
// Hány esetben nagyobb a két tömb azonos helyen lévő elemeiből
// az első tömbben lévő?

    int elsoNagyobb = 0;
    for( int i = 0; i < tomb1.length; i++ )
    {
      if( tomb1[i] > tomb2[i] )
      {
        elsoNagyobb++;
      }
    }
    
    System.out.println( elsoNagyobb+" esetben nagyobb az "+
            "elso tomb azonos helyen levo eleme." );

//    Melyik tömbben található a legnagyobb szám?
    int maxElem1 = tomb1[0];
    int maxElem2 = tomb2[0];
    
    for( int i = 1; i < tomb1.length; i++ )
    {
      if( tomb1[i] > maxElem1 )
      {
        maxElem1 = tomb1[i];
      }
      if( tomb2[i] > maxElem2 )
      {
        maxElem2 = tomb2[i];
      }
    }
    
    if( maxElem1 > maxElem2 )
    {
      System.out.println( "Az elso tombben talalhato a "+
              "legnagyobb szam." );
    }
    else if( maxElem1 < maxElem2 )
    {
      System.out.println( "A masodik tombben talalhato a "+
              "legnagyobb szam." );
    }
    else
    {
      System.out.println( "A ket tombben a legnagyobb "+
              "elem ugyanaz a szam." );
    }
    
// Helyezd el egy harmadik tömbben a két tömb elemeit úgy,
// hogy a fájlban azonos sorban lévő elemek egymás után
// legyenek! Első tömb 1. eleme, második tömb 1. eleme,
// első tömb 2. eleme, stb. Írd ki az új tömböt a képernyőre!
    int[] tomb3 = new int[tomb1.length+tomb2.length];
    
    int idx = 0;
    for( int i = 0; i < tomb1.length; i++ )
    {
      tomb3[idx] = tomb1[i];
      idx++;
      tomb3[idx] = tomb2[i];
      idx++;
    }
    
    System.out.println("A ket tomb elemei osszefesulve:");
    for (int i = 0; i < tomb3.length; i++)
    {
      System.out.print(tomb3[i]+" ");
    }
    System.out.println();
    
// Melyik tömbben található az a két szomszédos szám,
// amelyeknek legnagyobb az összege?
    int max1 = tomb1[1] - tomb1[0];
    int max2 = tomb2[1] - tomb2[0];
    for( int i = 0; i < tomb1.length-1; i++ )
    {
      if( tomb1[i+1] - tomb1[i] > max1 )
      {
        max1 = tomb1[i+1] - tomb1[i];
      }
      
      if( tomb2[i+1] - tomb2[i] > max1 )
      {
        max2 = tomb2[i+1] - tomb2[i];
      }
    }
    
    if( max1 > max2 )
    {
      System.out.println( "Az elso tombben talalhato a ket "+
              "legnagyobb osszegu szomszedos szam." );
    }
    else if( max1 < max2 )
    {
      System.out.println( "A masodik tombben talalhato  a "+
              "ket legnagyobb osszegu szomszedos szam." );
    }
    else
    {
      System.out.println( "A ket tombben ugyanakkora a ket "+
              "legnagyobb osszegu szomszedos szam." );
    }
    
// Melyik az a legkisebb intervallum, amelyben a
// két tömb elemei benne vannak?


    int minElem = tomb1[0];
    int maxElem = tomb1[0];
    for( int i = 0; i < tomb1.length; i++ )
    {
      if( tomb1[i] > maxElem )
      {
        maxElem = tomb1[i];
      }

      if( tomb2[i] > maxElem )
      {
        maxElem = tomb2[i];
      }

      if( tomb1[i] < minElem )
      {
        minElem = tomb1[i];
      }

      if( tomb2[i] < minElem )
      {
        minElem = tomb2[i];
      }
    }
    
    System.out.println( "A legkisebb intervallum, amiben "+
            "elfernek a ket tomb elemei: ["+
            minElem+";"+maxElem+"]" );
    
// Válogasd ki egy negyedik tömbbe a két tömbben lévő
// számokat úgy, hogy mindegyik szám csak egyszer szerepeljen!

// olyan kivalogatas, ahol az uj vizsgalando elemet
// mindig meg kell nezni, hogy benne van-e mar az eredmenytombben
// mivel elore nem tudjuk, hogy hany elemet tudunk majd
// kivalogatni, ezert abbol kell kiindulni, hogy az uj tomb
// merete legrosszabb esetben minden elemet at kell rakni
// (minden elem egyedi a ket tombre nezve) az eredmenytombben
// mindig az idx4 jelenti a valodi elemek darabszamat,
// nem a tomb4.length

    int[] tomb4 = new int[tomb1.length+tomb2.length];
    
    int idx4 = 0;
    tomb4[idx4] = tomb1[0];
    idx4++;
    for( int i = 0; i < tomb1.length; i++ )
    {
      int j = 0;
      while( j < idx4 && tomb4[j] != tomb1[i] )
      {
        j++;
      }
      
      if( j == idx4 )
      {
        tomb4[idx4] = tomb1[i];
        idx4++;
      }

      j = 0;
      while( j < idx4 && tomb4[j] != tomb2[i] )
      {
        j++;
      }
      
      if( j == idx4 )
      {
        tomb4[idx4] = tomb2[i];
        idx4++;
      }
    }
    
    System.out.print( "A 2 tomb kulonbozo elemei: " );
    for( int i = 0; i < idx4; i++ )
    {
      System.out.print( tomb4[i]+" ");
    }
    System.out.println(  );

//    Melyik tömbben található több egyedi érték?
// kivalogatom a ket tombot kulon-kulon egyedi
// ertekeket tartalmazo tombokbe amelyikbe tobbet tudtam
// kivalogatni, abban van tobb egyedi ertek

    int[] tomb1Egyedi = new int[tomb1.length];
    
    int idxTomb1 = 0;
    tomb1Egyedi[idxTomb1] = tomb1[0];
    idxTomb1++;
    for( int i = 1; i < tomb1.length; i++ )
    {
      int j = 0;
      while( j < idxTomb1 && tomb1Egyedi[j] != tomb1[i] )
      {
        j++;
      }
      
      if( j == idxTomb1 )
      {
        tomb1Egyedi[idxTomb1] = tomb1[i];
        idxTomb1++;
      }
    }

    int[] tomb2Egyedi = new int[tomb2.length];
    
    int idxTomb2 = 0;
    tomb2Egyedi[idxTomb2] = tomb1[0];
    idxTomb2++;
    for( int i = 1; i < tomb2.length; i++ )
    {
      int j = 0;
      while( j < idxTomb2 && tomb2Egyedi[j] != tomb2[i] )
      {
        j++;
      }
      
      if( j == idxTomb2 )
      {
        tomb2Egyedi[idxTomb2] = tomb2[i];
        idxTomb2++;
      }
    }
    
    if( idxTomb1 > idxTomb2 )
    {
      System.out.println( "Az elso tombben van tobb "+
              "egyedi ertek." );
    }
    else if( idxTomb1 < idxTomb2 )
    {
      System.out.println( "A masodik tombben van tobb "+
              "egyedi ertek." );
    }
    else
    {
      System.out.println( "A ket tombben ugyanannyi "+
              "egyedi ertek van." );
    }
  }
}