Programozás feladatok – tömbök alapjai megoldásokkal

  1. Tölts fel egy 10 elemű tömböt a [0;100] intervallumból. Írd ki a tömb első 5 elemét!
    Megoldás
    /**
     *
     * @author https://webotlet.hu
     */
    package webotlet_tombok01;
    
    public class Webotlet_tombok01
    {
    
      public static void main(String[] args)
      {
        int[] tomb = new int[10];
        
        for( int i = 0; i < tomb.length; i++ )
        {
          tomb[i] = (int)(Math.random() * 101);
        }
        
        for( int i = 0; i < 5; i++ )
        {
          System.out.print(tomb[i] + " ");
        }
        System.out.println();
      }
      
    }
    
  2. Tölts fel egy 10 elemű tömböt a [0;100] intervallumból. Írd ki a tömb utolsó 5 elemét!
    Megoldás
    /**
     *
     * @author https://webotlet.hu
     */
    package webotlet_tombok02;
    
    public class Webotlet_tombok02
    {
    
      public static void main(String[] args)
      {
        int[] tomb = new int[10];
        
        for( int i = 0; i < tomb.length; i++ )
        {
          tomb[i] = (int)(Math.random() * 101);
        }
        
        for( int i = 5; i < tomb.length; i++ )
        {
          System.out.print(tomb[i] + " ");
        }
        System.out.println();
      }
      
    }
    
  3. Tölts fel egy 10 elemű tömböt a [0;100] intervallumból. Írd ki a tömb az első és utolsó elem összegét!
    Megoldás
    /**
     *
     * @author https://webotlet.hu
     */
    package webotlet_tombok03;
    
    public class Webotlet_tombok03
    {
    
      public static void main(String[] args)
      {
        int[] tomb = new int[10];
        
        for( int i = 0; i < tomb.length; i++ )
        {
          tomb[i] = (int)(Math.random() * 101);
        }
        
        System.out.println(tomb[0] + tomb[tomb.length - 1]);
      }
      
    }
    
  4. Tölts fel egy 10 elemű tömböt a [0;100] intervallumból. Írd ki a tömb elemeit fordított sorrendben!
    Megoldás
    /**
     *
     * @author https://webotlet.hu
     */
    package webotlet_tombok04;
    
    public class Webotlet_tombok04
    {
    
      public static void main(String[] args)
      {
        int[] tomb = new int[10];
        
        for( int i = 0; i < tomb.length; i++ )
        {
          tomb[i] = (int)(Math.random() * 101);
        }
        
        for( int i = tomb.length - 1; i >= 0; i-- )
        {
          System.out.print(tomb[i] + " ");
        }
        System.out.println();
      }
      
    }
    
  5. Tölts fel egy 10 elemű tömböt a [0;100] intervallumból. Írd ki, hány olyan szám van a tömbben, melyet egy tőle nagyobb szám követ!
    Megoldás
    /**
     *
     * @author https://webotlet.hu
     */
    package webotlet_tombok05;
    
    public class Webotlet_tombok05
    {
    
      public static void main(String[] args)
      {
        int[] tomb = new int[10];
        
        for( int i = 0; i < tomb.length; i++ )
        {
          tomb[i] = (int)(Math.random() * 101);
        }
        
        for( int i = 0; i < tomb.length; i++ )
        {
          System.out.print(tomb[i] + " ");
        }
        System.out.println();
    
        int db = 0;
        for( int i = 0; i < tomb.length - 1; i++ )
        {
          if( tomb[i] < tomb[i + 1] )
          {
            db++;
          }
        }
        System.out.println(db);
      }
      
    }
    
  6. Tölts fel egy 10 elemű tömböt a [0;20] intervallumból. Írd ki, van-e a tömbben egymás mellett két egyforma szám!
    Megoldás
    /**
     *
     * @author https://webotlet.hu
     */
    package webotlet_tombok06;
    
    public class Webotlet_tombok06
    {
    
      public static void main(String[] args)
      {
        int[] tomb = new int[10];
        
        for( int i = 0; i < tomb.length; i++ )
        {
          tomb[i] = (int)(Math.random() * 21);
        }
        
        for( int i = 0; i < tomb.length; i++ )
        {
          System.out.print(tomb[i] + " ");
        }
        System.out.println();
    
        boolean van = false;
        for( int i = 0; i < tomb.length - 1; i++ )
        {
          if( tomb[i] == tomb[i + 1] )
          {
            van = true;
            break;
          }
        }
        
        if( van )
        {
          System.out.println("Van egymas mellett egyforma szam.");
        }
        else
        {
          System.out.println("Nincs egymas mellett egyforma szam.");
        }
      }
      
    }
    
  7. Tölts fel egy 20 elemű tömböt a [0;10] intervallumból. Írd ki, van-e a tömbben egymás mellett három egyforma szám!
    Megoldás
    /**
     *
     * @author https://webotlet.hu
     */
    package webotlet_tombok07;
    
    public class Webotlet_tombok07
    {
    
      public static void main(String[] args)
      {
        int[] tomb = new int[10];
        
        for( int i = 0; i < tomb.length; i++ )
        {
          tomb[i] = (int)(Math.random() * 11);
        }
        
        for( int i = 0; i < tomb.length; i++ )
        {
          System.out.print(tomb[i] + " ");
        }
        System.out.println();
    
        boolean van = false;
        for( int i = 0; i < tomb.length - 2; i++ )
        {
          if( tomb[i] == tomb[i + 1] && tomb[i] == tomb[i + 2] )
          {
            van = true;
            break;
          }
        }
        
        if( van )
        {
          System.out.println("Van egymas mellett 3 egyforma szam.");
        }
        else
        {
          System.out.println("Nincs egymas mellett 3 egyforma szam.");
        }
      }
      
    }
    
  8. Tölts fel egy 10 elemű tömböt a [0;20] intervallumból. Írd ki, van-e olyan szám, mely az előtte lévő szám kétszerese!
    Megoldás
    /**
     *
     * @author https://webotlet.hu
     */
    package webotlet_tombok08;
    
    public class Webotlet_tombok08
    {
    
      public static void main(String[] args)
      {
        int[] tomb = new int[10];
        
        for( int i = 0; i < tomb.length; i++ )
        {
          tomb[i] = (int)(Math.random() * 21);
        }
        
        for( int i = 0; i < tomb.length; i++ )
        {
          System.out.print(tomb[i] + " ");
        }
        System.out.println();
    
        boolean van = false;
        for( int i = 0; i < tomb.length - 1; i++ )
        {
          if( tomb[i] * 2 == tomb[i + 1] )
          {
            van = true;
            break;
          }
        }
        
        if( van )
        {
          System.out.println("Van olyan szam, ami az elotte "
            + "levo ketszerese.");
        }
        else
        {
          System.out.println("Nincs olyan szam, ami az elotte "
            + "levo ketszerese.");
        }
      }
      
    }
    
  9. Tölts fel egy 5 elemű tömböt a [0;1000] intervallumból. Vizsgáld meg, hogy a tömb elemei növekvő sorrendben állnak-e, és írd ki az eredményt!
    Megoldás
    /**
     *
     * @author https://webotlet.hu
     */
    package webotlet_tombok09;
    
    public class Webotlet_tombok09
    {
    
      public static void main(String[] args)
      {
        int[] tomb = new int[5];
        
        for( int i = 0; i < tomb.length; i++ )
        {
          tomb[i] = (int)(Math.random() * 1001);
        }
        
        for( int i = 0; i < tomb.length; i++ )
        {
          System.out.print(tomb[i] + " ");
        }
        System.out.println();
    
        boolean novekvo = true;
        for( int i = 0; i < tomb.length - 1; i++ )
        {
          if( tomb[i] >= tomb[i + 1] )
          {
            novekvo = false;
            break;
          }
        }
        
        if( novekvo )
        {
          System.out.println("Novekvo sorrendben allnak.");
        }
        else
        {
          System.out.println("Nem allnak novekvo sorrendben.");
        }
      }
      
    }
    
  10. Tölts fel egy 10 elemű tömböt a [0;20] intervallumból. Írd ki azokat a számokat, mely a két szomszédjának az összege!
    Megoldás
    /**
     *
     * @author https://webotlet.hu
     */
    package webotlet_tombok10;
    
    public class Webotlet_tombok10
    {
      public static void main(String[] args)
      {
        int[] tomb = new int[10];
        
        for( int i = 0; i < tomb.length; i++ )
        {
          tomb[i] = (int)(Math.random() * 21);
        }
        
        for( int i = 0; i < tomb.length; i++ )
        {
          System.out.print(tomb[i] + " ");
        }
        System.out.println();
    
        for( int i = 1; i < tomb.length - 1; i++ )
        {
          if( tomb[i] == tomb[i - 1] + tomb[i + 1])
          {
            System.out.print(tomb[i]);
          }
        }
        System.out.println();
      }
      
    }
    
  11. Tölts fel egy 5 elemű tömböt a [0;5] intervallumból. Vizsgáld meg, hogy a tömböt elölről és hátulról olvasva ugyanazt a számsort kapjuk-e!
    Megoldás
    /**
     *
     * @author https://webotlet.hu
     */
    package webotlet_tombok11;
    
    public class Webotlet_tombok11
    {
    
      public static void main(String[] args)
      {
        int[] tomb = new int[5];
        
        for( int i = 0; i < tomb.length; i++ )
        {
          tomb[i] = (int)(Math.random() * 6);
        }
        
        //teszteleshez
    //    tomb = new int[]{1,2,3,2,1};
        
        for( int i = 0; i < tomb.length; i++ )
        {
          System.out.print(tomb[i] + " ");
        }
        System.out.println();
    
        boolean ugyanaz = true;
        for( int i = 0; i < tomb.length; i++ )
        {
          if( tomb[i] != tomb[tomb.length - 1 - i] )
          {
            ugyanaz = false;
            break;
          }
        }
        
        if( ugyanaz )
        {
          System.out.println("A tomb ugyanaz az elejerol es "
            + "a vegerol olvasva.");
        }
        else
        {
          System.out.println("A tomb nem ugyanaz az elejerol "
            + "es a vegerol olvasva.");
        }
      }
      
    }
    
  12. Tölts fel egy 10 elemű tömböt a [0;20] intervallumból. Sorsolj ki egy N számot az [1;5] intervallumból. Írd ki a tömb elején és végén lévő N elemet egymás mellé! Példák:
    { 0,3,2,1,2,2,4,8,3,6 }, 3 -> { 0,3,2,8,3,6 }
    { 0,3,2,1,2,2,4,8,3,6 }, 2 -> { 0,3,3,6 }
    1. megoldás
    /**
     *
     * @author https://webotlet.hu
     */
    package webotlet_tombok12;
    
    public class Webotlet_tombok12
    {
    
      public static void main(String[] args)
      {
        int[] tomb = new int[10];
        
        for( int i = 0; i < tomb.length; i++ )
        {
          tomb[i] = (int)(Math.random() * 21);
        }
        
        for( int i = 0; i < tomb.length; i++ )
        {
          System.out.print(tomb[i] + " ");
        }
        System.out.println();
        
        int limit = (int)(Math.random() * 5) + 1;
        System.out.println("limit: " + limit);
        
        for( int i = 0; i < limit; i++ )
        {
          System.out.print(tomb[i] + " ");
        }
        
        for( int i = tomb.length-limit; i < tomb.length; i++ )
        {
          System.out.print(tomb[i] + " ");
        }
        System.out.println();
      }
      
    }
    
    2. megoldás
    /**
     *
     * @author https://webotlet.hu
     */
    package webotlet_tombok12v2;
    
    public class Webotlet_tombok12v2
    {
    
      public static void main(String[] args)
      {
        int[] tomb = new int[10];
        
        for( int i = 0; i < tomb.length; i++ )
        {
          tomb[i] = (int)(Math.random() * 21);
        }
        
        for( int i = 0; i < tomb.length; i++ )
        {
          System.out.print(tomb[i] + " ");
        }
        System.out.println();
        
        int limit = (int)(Math.random() * 5) + 1;
        System.out.println("limit: " + limit);
        
        for( int i = 0; i < limit; i++ )
        {
          System.out.print(tomb[i] + " ");
        }
         
        for( int i = 0; i < limit; i++ )
        {
          System.out.print(tomb[tomb.length - limit + i] + " ");
        }
      }
      
    }
    
    3. megoldás
    /**
     *
     * @author https://webotlet.hu
     */
    package webotlet_tombok12v3;
    
    public class Webotlet_tombok12v3
    {
    
      public static void main(String[] args)
      {
        int[] tomb = new int[10];
        
        for( int i = 0; i < tomb.length; i++ )
        {
          tomb[i] = (int)(Math.random() * 21);
        }
        
        for( int i = 0; i < tomb.length; i++ )
        {
          System.out.print(tomb[i] + " ");
        }
        System.out.println();
        
        int limit = (int)(Math.random() * 5) + 1;
        System.out.println("limit: " + limit);
        
        for( int i = 0; i < limit * 2; i++ )
        {
          if( i < limit )
          {
            System.out.print(tomb[i] + " ");
          }
          else
          {
            System.out.print(tomb[tomb.length - limit * 2 + i] + " ");
          }
          
        }
      }
      
    }
    
  13. Tölts fel egy 10 elemű tömböt a [0;20] intervallumból. Sorsolj ki egy N számot az [1;5] intervallumból. Írd ki a tömb elején és végén lévő N elemet egymás mellé úgy, hogy a kiíratást mindig a tömb szélétől kezded! Példák:
    { 0,3,2,1,2,2,4,8,3,6 }, 3 -> { 0,3,2,6,3,8 }
    { 0,3,2,1,2,2,4,8,3,6 }, 4 -> { 0,3,2,1,6,3,8,4 }1. megoldás
    /**
     *
     * @author https://webotlet.hu
     */
    package webotlet_tombok13;
    
    public class Webotlet_tombok13
    {
    
      public static void main(String[] args)
      {
        int[] tomb = new int[10];
        
        for( int i = 0; i < tomb.length; i++ )
        {
          tomb[i] = (int)(Math.random() * 21);
        }
        
        for( int i = 0; i < tomb.length; i++ )
        {
          System.out.print(tomb[i] + " ");
        }
        System.out.println();
        
        int limit = (int)(Math.random() * 5) + 1;
        System.out.println("limit: " + limit);
        
        for( int i = 0; i < limit; i++ )
        {
          System.out.print(tomb[i] + " ");
        }
        
        for( int i = tomb.length - 1; i >= tomb.length - limit; i-- )
        {
          System.out.print(tomb[i] + " ");
        }
        System.out.println();
      }
      
    }
    
    2. megoldás
    /**
     *
     * @author https://webotlet.hu
     */
    package webotlet_tombok13v2;
    
    public class Webotlet_tombok13v2
    {
    
      public static void main(String[] args)
      {
        int[] tomb = new int[10];
        
        for( int i = 0; i < tomb.length; i++ )
        {
          tomb[i] = (int)(Math.random() * 21);
        }
        
        for( int i = 0; i < tomb.length; i++ )
        {
          System.out.print(tomb[i] + " ");
        }
        System.out.println();
        
        int limit = (int)(Math.random() * 5) + 1;
        System.out.println("limit: " + limit);
        
        for( int i = 0; i < limit; i++ )
        {
          System.out.print(tomb[i] + " ");
        }
        
        for( int i = 0; i < limit; i++ )
        {
          System.out.print(tomb[tomb.length - 1 - i]+" ");
        }
        System.out.println();
      }
      
    }
    
    3. megoldás
    /**
     *
     * @author https://webotlet.hu
     */
    package webotlet_tombok13v3;
    
    public class Webotlet_tombok13v3
    {
    
      public static void main(String[] args)
      {
        int[] tomb = new int[10];
        
        for( int i = 0; i < tomb.length; i++ )
        {
          tomb[i] = (int)(Math.random() * 21);
        }
        
        for( int i = 0; i < tomb.length; i++ )
        {
          System.out.print(tomb[i] + " ");
        }
        System.out.println();
        
        int limit = (int)(Math.random() * 5) + 1;
        System.out.println("limit: " + limit);
        
        for( int i = 0; i < limit * 2; i++ )
        {
          if( i < limit )
          {
            System.out.print(tomb[i] + " ");
          }
          else
          {
            System.out.print(tomb[tomb.length - 1 + limit - i]+" ");
          }
        }
        System.out.println();
      }
      
    }
    
  14. Tölts fel egy 10 elemű tömböt a [0;20] intervallumból. Sorsolj ki egy pozitív páros számot, ami legfeljebb a tömbméret lehet. Írd ki a tömb középső N elemét.
    Példák:
    { 7,1,20,1,17,3,9,4,19,9 }, N: 2 -> {17,3}
    { 7,1,20,1,17,3,9,4,19,9 }, N: 6 -> {20,1,17,3,9,4}
    { 7,1,20,1,17,3,9,4,19,9 }, N: 4 -> {1,17,3,9}Megoldás
    /**
     *
     * @author https://webotlet.hu
     */
    package webotlet_tombok14;
    
    public class Webotlet_tombok14
    {
    
      public static void main(String[] args)
      {
        int[] tomb = new int[10];
        
        for( int i = 0; i < tomb.length; i++ )
        {
          tomb[i] = (int)(Math.random() * 21);
        }
        
        for( int i = 0; i < tomb.length; i++ )
        {
          System.out.print(tomb[i] + " ");
        }
        System.out.println();
        
        int n;
        do
        {
          n = (int)(Math.random() * 8) + 2;
        }
        while( n % 2 != 0 );
        
        System.out.println("N: " + n);
    
        int push = 5 - (n / 2);
        for( int i = 0; i < n; i++ )
        {
          System.out.print(tomb[i + push] + " ");
        }
        System.out.println();
      }
      
    }
    
  15. Tölts fel egy tömböt a [0;20] intervallumból. Két részre vágható-e a tömb valahol úgy, hogy a két részben lévő számok összege egyenlő? Példák:
    { 0,3,2,1,4 } -> igen {0,3,2} {1,4}
    { 2,1,1,0 } -> igen { 2 } { 1,1,0 }
    { 0,3,2,1,5 } -> nem
    Megoldás
    /**
     *
     * @author https://webotlet.hu
     */
    package webotlet_tombok15;
    
    public class Webotlet_tombok15
    {
    
      public static void main(String[] args)
      {
        // véletlen méretű tömb
        int meret = (int)(Math.random() * 9) + 2;
        int[] tomb = new int[meret];
        
        for( int i = 0; i < tomb.length; i++ )
        {
          tomb[i] = (int)(Math.random() * 21);
        }
        
        // tesztelni
        // tomb = new int[] {0,3,2,1,4};
        
        for( int i = 0; i < tomb.length; i++ )
        {
          System.out.print(tomb[i] + " ");
        }
        System.out.println();
        
        int osszeg = 0;
        for( int i = 0; i < tomb.length; i++ )
        {
          osszeg += tomb[i];
        }
        
        double fele = osszeg / 2.0;
        
        int reszOsszeg = 0;
        boolean oszthato = false;
        int limit = 0; // csak a tombok kiirasahoz kell
        for( int i = 0; i < tomb.length; i++ )
        {
          reszOsszeg += tomb[i];
          if( reszOsszeg == fele )
          {
            oszthato = true;
            limit = i;
            break;
          }
        }
        
        if( oszthato )
        {
          System.out.println("igen");
          // kiirom a ket tombot
          // szebben is lehetne, de csak ellenorzeskepp kell :)
          System.out.print("{");
          for( int i = 0; i < tomb.length - 1; i++ )
          {
            if( i < limit )
            {
              System.out.print(tomb[i]+ ",");
            }
            else if( i == limit )
            {
              System.out.print(tomb[i] + "} {");
            }
            else
            {
              System.out.print(tomb[i] + ",");
            }
          }
          System.out.println(tomb[tomb.length - 1] + "}");
        }
        else
        {
          System.out.println("nem");
        }
      }
      
    }
    
  16. Tölts fel egy 10 elemű tömböt a [-30;100] intervallumból sorsolt páratlan számokkal!
    Megoldás
    /**
     *
     * @author https://webotlet.hu
     */
    
    package webotlet_tombok16;
    
    public class Webotlet_Tombok16
    {
    
      public static void main(String[] args)
      {
        int[] tomb = new int[10];
        
        int cel = 0; // ennyi szám van már meg
        int idx = 0; // a következő üres hely a tömbben
        while( cel != 10 )
        {
          int szam = (int)(Math.random()*131)-30;
          if( szam % 2 != 0 )
          {
            tomb[idx] = szam;
            idx++;
            cel++;
          }
        }
        
        for( int i = 0; i < tomb.length; i++ )
        {
          System.out.print(tomb[i]+" ");
        }
        System.out.println();
      }
      
    }
    
  17. Sorsold ki az ötös lottó nyerőszámait! (5 szám a [1;90] intervallumból)
    1. megoldás
    /**
     *
     * @author https://webotlet.hu
     */
    package webotlet_tombok17;
    
    public class Webotlet_Tombok17
    {
    
      public static void main(String[] args)
      {
        int[] sorsolt = new int[5];
        
        int cel = 0; // ennyi szám van már meg
        int idx = 0; // a következő üres hely a tömbben
        
        while( cel != 5 )
        {
          int szam = (int)(Math.random()*90)+1;
          
          boolean benne = false;
          for( int i = 0; i < cel; i++ )
          {
            if( sorsolt[i] == szam )
            {
              benne = true;
              break;
            }
          }
          
          if( !benne )
          {
            sorsolt[idx] = szam;
            idx++;
            cel++;
          }
        }
            
        for( int i = 0; i < sorsolt.length; i++ )
        {
          System.out.print(sorsolt[i]+" ");
        }
        System.out.println();
      }
      
    }
    
    2. megoldás
    /**
     *
     * @author https://webotlet.hu
     */
    package webotlet_tombok17v2;
    
    public class Webotlet_Tombok17v2
    {
        
      public static void main(String[] args)
      {
        int[] szamok = new int[91]; // miket sorsoltunk eddig
        int[] sorsolt = new int[5];
        
        int cel = 0; // ennyi szám van már meg
        int idx = 0; // a következő üres hely a tömbben
        
        while( cel != 5 )
        {
          int szam = (int)(Math.random()*90)+1;
          
          if( szamok[szam] == 0 )
          {
            szamok[szam] = szam;
    
            sorsolt[idx] = szam;
            idx++;
            cel++;
          }
        }
        
        for( int i = 0; i < sorsolt.length; i++ )
        {
          System.out.print(sorsolt[i]+" ");
        }
        System.out.println();
      }
      
    }
    
  18. Vizsgáld meg, hogy egy tömb elején és végén ugyanazok a számok állnak-e azonos sorrendben. Írd ki, hogy melyek ezek a számok! Ha több ilyen van, akkor a leghosszabb ilyen számsort írd ki! Példák:
    { 0,2,5,7,3,0,2,5 } -> igen { 0,2,5 }
    { 2,4,7,4,2,4 } -> igen { 2,4 }
    { 2,4,7,4,2,2 } -> igen { 2 }
    { 0,2,5,7,2,5,2 } -> nem
    Megoldás
    /**
     *
     * @author https://webotlet.hu
     */
    package webotlet_tombok18;
    
    public class Webotlet_tombok18
    {
    
      public static void main(String[] args)
      {
        int[] tomb = new int[] { 0, 2, 5, 7, 3, 0, 2, 5 };
    //    int[] tomb = new int[] { 2,4,7,4,2,4 };
    //    int[] tomb = new int[] { 2,4,7,4,2,2 };
    //    int[] tomb = new int[] { 2,4,7,2,4,7 };
    //    int[] tomb = new int[] { 0,2,5,7,2,5,2 };
    //    int[] tomb = new int[] { 2,2,2,2,2 };
    
        for( int i = 0; i < tomb.length; i++ )
        {
          System.out.print(tomb[i] + " ");
        }
        System.out.println();
    
        int limit = 1;
        int maxDb = 0;
        for( int i = 0; i < tomb.length / 2; i++ )
        {
          int talalat = 0;
    
          for( int j = 0; j < limit; j++ )
          {
            if( tomb[j] == tomb[tomb.length - limit + j] )
            {
              talalat++;
            }
            else
            {
              break;
            }
          }
          if( talalat > maxDb )
          {
            maxDb = talalat;
          }
          limit++;
        }
        
        if( maxDb == 0 )
        {
          System.out.println("Nincsenek egyforma szamok a tomb szelein.");
        }
        else
        {
          for( int i = 0; i < maxDb; i++ )
          {
            System.out.print(tomb[i] + " ");
          }
        }
      }
    
    }
    
  19. Vizsgáld meg, hogy egy tömb elején és végén ugyanazok a számok állnak-e úgy, hogy a számokat a tömb szélétől kezdjük beolvasni. Írd ki, hogy melyek ezek a számok! Példák:
    { 0,2,5,7,3,5,2,0 } -> igen { 5,2,0 }
    { 2,4,7,4,2,2 } -> igen { 2 }
    { 0,2,5,7,2,5,2 } -> nem
    Megoldás
    /**
     *
     * @author https://webotlet.hu
     */
    package webotlet_tombok19;
    
    public class Webotlet_tombok19
    {
    
      public static void main(String[] args)
      {
    //    int[] tomb = new int[] { 0,2,5,7,3,5,2,0 };
    //    int[] tomb = new int[] { 2,4,7,4,2,2 };
        int[] tomb = new int[] { 0,2,5,7,2,5,2 };
    
        for( int i = 0; i < tomb.length; i++ )
        {
          System.out.print(tomb[i] + " ");
        }
        System.out.println();
    
        int limit = 1;
        int maxDb = 0;
        for( int i = 0; i < tomb.length / 2; i++ )
        {
          int talalat = 0;
    
          for( int j = 0; j < limit; j++ )
          {
            if( tomb[j] == tomb[tomb.length -1 - j] )
            {
              talalat++;
            }
            else
            {
              break;
            }
          }
          if( talalat > maxDb )
          {
            maxDb = talalat;
          }
          limit++;
        }
        
        if( maxDb == 0 )
        {
          System.out.println("Nincsenek egyforma szamok a tomb szelein.");
        }
        else
        {
          for( int i = 0; i < maxDb; i++ )
          {
            System.out.print(tomb[i] + " ");
          }
        }
      }
    
    }
    
  20. Tölts fel egy 20 elemű tömböt a [0;5] intervallumból. Írd ki, hogy melyik szám szerepel benne a legtöbbször egymás mellett! Ha több ilyen van, az elsőt írd ki. Példák:
    { 4,0,3,1,5,2,4,4,1,1,2,5,2,1,1,1,1,4,2,1} -> 1
    { 1,2,0,4,4,1,5,0,4,4,4,0,3,4,3,3,3,5,0,4} -> 4
    Megoldás
    /**
     *
     * @author https://webotlet.hu
     */
    package webotlet_tombok20;
    
    public class Webotlet_tombok20
    {
    
      public static void main(String[] args)
      {
        int[] tomb = {4,0,3,1,5,2,4,4,1,1,2,5,2,1,1,1,1,4,2,1};
    //    int[] tomb = { 1,2,0,4,4,1,5,0,4,4,4,0,3,4,3,3,3,2,0,4};
    
        int db = 1;
        int maxdb = db;
        int maxmi = tomb[0];
        for( int i = 1; i < tomb.length; i++ )
        {
          if( tomb[i] == tomb[i - 1] )
          {
            db++;
            if( db > maxdb )
            {
              maxdb = db;
              maxmi = tomb[i];
            }
          }
          else
          {
            db = 1;
          }
        }
        System.out.println(maxmi);
      }
    }
    

13 Replies to “Programozás feladatok – tömbök alapjai megoldásokkal”

  1. Kedves Csaba!
    A 13. 18. és 19. feladattal nem boldogulok.
    El tudná küldeni nekem a megoldást?
    Nagyon hasznos az oldal, sokat lehet itt tanulni.
    Köszönöm előre is

  2. Hello,
    Nem kötekedni akarok, de a 15. feladat megoldása nem helyes.
    Gondoljunk egy tömbre {5,6} 11/2=5 mert ugye int.. Namost 5 a fele meg is vagyunk. De 5 != 6.
    Tehát egy minimális feltétele a feladatnak hogy az összeg páros legyen.

Vélemény, hozzászólás?

Az e-mail címet nem tesszük közzé. A kötelező mezőket * karakterrel jelöltük

*

Ez az oldal az Akismet szolgáltatást használja a spam csökkentésére. Ismerje meg a hozzászólás adatainak feldolgozását .