Search svg
Search svg
More...
More...
svg
svg

Now Reading: 16 próbafeladat junior/medior programozói állásinterjúkra

svg
Loading
    Loading

    16 próbafeladat junior/medior programozói állásinterjúkra

    svg2023.10.20.programozás, programozás és kódolásadmin

    Olvasási idő: 9 perc

    Hoztam nektek egy sor gyakorlófeladatot (“live coding”) junior vagy medior szintű állásinterjúkra: a feladatok között több is előfordult már az állásinterjúimon. Jelen feladatok mellé csatolok egy lehetséges megoldást Java nyelven. Nem állítom, hogy az enyém a legoptimálisabb megoldás, de működik. 

    1. Írj programot, amely 2 egész számot vár paraméterként. A programnak a két szám közötti összes egész számot egy listában kell visszaadnia a kezdő és befejező számokat kihagyva. Ha a kezdőszám nagyobb, mint a befejező szám, a lista tartalmazza a számokat csökkenő sorrendben. Ha a kezdőszám kisebb, mint a befejező szám, a lista tartalmazza a számokat növekvő sorrendben.
    import java.util.List;
    import java.util.ArrayList;
     
    class HelloWorld {
        public static void main(String[] args) {
            System.out.println(“Hello, World!”);
        }
        
        public List<Integer> solution(int a, int b) {
            List<Integer> solutionList = new ArrayList<>();
            if (a > b) {
                for (int i = a-1; i > b; i–) {
                    solutionList.add(i);
                }
            } else {
                for (int i = a+1; i < b; i++) {
                    solutionList.add(i);
                }
            }
        
            return solutionList;
        }
    }
     
    2. Írj egy függvényt, ami meghatározza, hogy egy adott szám tökéletes-e. Egy szám tökéletesnek minősül, ha maradék nélküli osztóinak (kivéve saját magát) összege megegyezik a számmal.
    class HelloWorld {
        public static void main(String[] args) {
            System.out.println(isPerfectNumber(11));
        }
        
    public static boolean isPerfectNumber (int number){
        int maradek = 0;
        for (int i = 1; i < number -1; i++){
        if (number % i == 0){
            maradek+=i;
            }        
        }
    return maradek==number;
       }
    }
     
    3. Készíts egy metódust, amely egy adott sorozatot vesz fel paraméterként, ahol ismétlődő elemek is lehetnek. A metódus adjon vissza egy tömböt, amelyben az elemek egymás mellett nem azonos értékűek, és megőrzi az elemek eredeti sorrendjét.
    import java.util.ArrayList;
    import java.util.List;
     
    public class HelloWorld {
        public static void main(String[] args) {
            List<Integer> testList = List.of(1, 1, 2, 2, 3, 3, 4, 5, 5, 5, 6);
            System.out.println(uniqueArray(testList));
        }
     
        public static List<Integer> uniqueArray(List<Integer> numbers) {
            if (numbers == null || numbers.isEmpty()) {
                return new ArrayList<>();
            }
     
            List<Integer> result = new ArrayList<>();
            result.add(numbers.get(0));
     
            for (int i = 1; i < numbers.size(); i++) {
                if (!numbers.get(i).equals(numbers.get(i – 1))) {
                    result.add(numbers.get(i));
                }
            }
     
            return result;
        }
    }
     
    4. Duplikált Elemek Kiszűrése. Írj egy metódust, amely eltávolít minden ismétlődő elemet egy adott listából és csak az egyedi elemeket adja vissza. A visszaadott lista elemei legyenek a bemeneti lista eredeti sorrendjében.
     
    public static List<Integer> solution(List<Integer> numbers) {
        Set<Integer> uniqueSet = new LinkedHashSet<>(numbers);
        return uniqueSet.stream().collect(Collectors.toList());
    }
     
    5. Intervallum Összeg. Írj egy metódust, amely kiszámolja az összeget két adott szám között (beleértve azokat is).
     
         public static int summarizer (int a, int b){
            int solution = 0;
            if(a>b){
                for (int i= b; i>=a;i++){
                    solution+=i;
                }            
            }else{
                for (int i= a; i<=b;i++){
                    solution+=i;
                }          
            }
     
             return solution;
         }
     
     
    6. Szófordítás. Írj egy metódust, amely megfordítja a szavak sorrendjét egy mondatban, de a szavak karaktereit meghagyja.
     

    public class WordReverser {

    public static void main(String[] args) {
    String sentence = “This is a test sentence”;
    System.out.println(“Original Sentence: ” + sentence);
    System.out.println(“Reversed Sentence: ” + reverseWordsOrder(sentence));
    }

    /**
    * Reverses the order of words in a sentence, but leaves the characters of each word intact.
    * @param sentence The original sentence.
    * @return The sentence with the words reversed.
    */
    public static String reverseWordsOrder(String sentence) {
    String[] words = sentence.split(” “);
    StringBuilder reversedSentence = new StringBuilder();

    for (int i = words.length – 1; i >= 0; i–) {
    reversedSentence.append(words[i]);
    if (i != 0) {
    reversedSentence.append(” “);
    }
    }

    return reversedSentence.toString();
    }
    }

    7. Prím Számok Keresése.Írj egy metódust, amely visszaadja az első n prím számot egy listában.

    import java.util.ArrayList;
    import java.util.List;

    public class PrimeSearcher {

    public static void main(String[] args) {
    int n = 10; // Például az első 10 prím szám kereséséhez
    List<Integer> primes = findFirstNPrimes(n);
    System.out.println(“Az első ” + n + ” prím szám: ” + primes);
    }

    /**
    * Visszaadja az első n prím számot egy listában.
    *
    * @param n A keresendő prím számok száma
    * @return Egy lista az első n prím számmal
    */
    public static List<Integer> findFirstNPrimes(int n) {
    List<Integer> primes = new ArrayList<>();
    int num = 2; // kezdés a legkisebb prím számmal
    while (primes.size() < n) {
    if (isPrime(num)) {
    primes.add(num);
        }
    num++;
        }
    return primes;
      }

    /**
    * Megvizsgálja, hogy egy szám prím-e vagy sem.
    *
    * @param num A vizsgálandó szám
    * @return true, ha a szám prím, egyébként false
    */
    private static boolean isPrime(int num) {
    if (num <= 1) return false;
    for (int i = 2; i <= Math.sqrt(num); i++) {
    if (num % i == 0) {
    return false;
         }
      }
    return true;
      }
    }

     
    8. Palindromkereső. Írj egy metódust, amely eldönti, hogy egy adott sztring palindróma-e (azaz visszafelé is ugyanúgy olvasható).
     
    public class HelloWorld {
     
        public static void main(String[] args) {
            System.out.println(isItPalindrome(“Indul a pap aludni”));
        }
     
        public static boolean isItPalindrome(String word) {
            String cleanedWord = word.replaceAll(“\\s+”, “”).toLowerCase();  // szóközök eltávolítása és kisbetűssé alakítás
            StringBuilder stringBuilder = new StringBuilder(cleanedWord);
            String reversed = stringBuilder.reverse().toString();
            return cleanedWord.equals(reversed);
        }
    }
     
    9. Összeg Párok. Írj egy metódust, amely egy listából és egy célösszegből keres két számot, amelyek összege megegyezik a célösszeggel.

    import java.util.Arrays;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;

    public class SumPairs {

    public static void main(String[] args) {
    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
    int targetSum = 15;
    int[] pair = findPairWithSum(numbers, targetSum);

    if (pair != null) {
    System.out.println(“Two numbers with a sum of ” + targetSum + ” are: ” + pair[0] + ” and ” + pair[1]);
    } else {
    System.out.println(“No two numbers found with a sum of ” + targetSum);
    }
    }

    /**
    * Searches for a pair of numbers in the given list that adds up to the given target sum.
    *
    * @param numbers The list of numbers
    * @param targetSum The target sum
    * @return An array of size 2 containing the pair of numbers or null if no pair found.
    */
    public static int[] findPairWithSum(List<Integer> numbers, int targetSum) {
    Map<Integer, Integer> complementMap = new HashMap<>();

    for (int number : numbers) {
    int complement = targetSum – number;
    if (complementMap.containsKey(complement)) {
    return new int[]{complement, number};
       }
    complementMap.put(number, complement);
    }

    return null;
       }
    }

     
    10. Legkisebb és Legnagyobb Elem.Írj egy metódust, amely visszaadja a legkisebb és a legnagyobb számot egy adott számlistából.
     

    import java.util.Arrays;
    import java.util.List;

    public class MinMaxFinder {

    public static void main(String[] args) {
    List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5);
    int[] result = findMinMax(numbers);
    System.out.println(“The smallest number is: ” + result[0]);
    System.out.println(“The largest number is: ” + result[1]);
    }

    /**
    * Determines the smallest and the largest number in a list.
    *
    * @param numbers The list of numbers
    * @return An array where the first element is the smallest number and the second element is the largest number.
    */
    public static int[] findMinMax(List<Integer> numbers) {
    if (numbers == null || numbers.isEmpty()) {
    throw new IllegalArgumentException(“List cannot be null or empty”);
    }

    int min = Integer.MAX_VALUE;
    int max = Integer.MIN_VALUE;

    for (int number : numbers) {
    if (number < min) {
    min = number;
       }
    if (number > max) {
    max = number;
      }
    }

    return new int[]{min, max};
      }
    }

     
    11. Anagramma Vizsgálat. Írj egy metódust, amely eldönti, hogy két sztring anagramma-e (azaz ugyanazokból a karakterekből állnak, csak esetleg más sorrendben).
    import java.util.*;
     
    public class HelloWorld {
     
        public static void main(String[] args) {
            System.out.println(areAnagrammas(“indula”, “aludni”));
        }
     
        public static boolean areAnagrammas(String first, String second) {
            List<Character> firstWordCharacters = new ArrayList<>();
            List<Character> secondWordCharacters = new ArrayList<>();
     
            for (int i = 0; i < first.length(); i++) {
                if (first.charAt(i) != ‘ ‘) {
                    firstWordCharacters.add(first.charAt(i));
                }
            }
     
            for (int j = 0; j < second.length(); j++) {
                if (second.charAt(j) != ‘ ‘) {
                    secondWordCharacters.add(second.charAt(j));
                }
            }
     
            Collections.sort(firstWordCharacters);
            Collections.sort(secondWordCharacters);
     
            return firstWordCharacters.equals(secondWordCharacters);
        }
    }
    12. Melyik Hiányzik? Adott egy lista, ami tartalmazza az 1-től n-ig a természetes számokat, de egy szám hiányzik belőle. Írj egy metódust, amely megtalálja ezt a hiányzó számot.
    import java.util.List;
     
    public class FindMissingNumber {
     
        public static int summarizerToN(List<Integer> numbers) {
            int reference = 0;
            int sum = 0;
            
            for (int j = 1; j <= numbers.size() + 1; j++) {
                reference += j;
            }
            
            for (int i = 0; i < numbers.size(); i++) { 
                sum += numbers.get(i);
            }
     
            return reference – sum;
        }
    }
    13. Leggyakrabban Ismétlődő Elem. Írj egy metódust, amely meghatározza a legtöbbször előforduló elemet egy listában. Ha több ilyen elem is van, akkor adja vissza azokat a legelső előfordulásuk sorrendjében egy listában.
     

    import java.util.*;

    public class MostFrequentElement {

    public static void main(String[] args) {
    List<Integer> numbers = Arrays.asList(1, 2, 3, 2, 5, 3, 3, 5, 5, 4);
    List<Integer> mostFrequent = findMostFrequentElements(numbers);
    System.out.println(“The most frequently occurring elements are: ” + mostFrequent);
    }

    /**
    * Determines the most frequently occurring elements in a list.
    *
    * @param list The list of elements
    * @return A list containing the most frequently occurring elements in the order of their first occurrence.
    */
    public static List<Integer> findMostFrequentElements(List<Integer> list) {
    Map<Integer, Integer> frequencyMap = new HashMap<>();
    int maxFrequency = 0;

    // Calculate the frequency of each element
    for (int number : list) {
    frequencyMap.put(number, frequencyMap.getOrDefault(number, 0) + 1);
    maxFrequency = Math.max(maxFrequency, frequencyMap.get(number));
       }

    // Find elements with the max frequency
    Set<Integer> resultSet = new LinkedHashSet<>();
    for (int number : list) {
    if (frequencyMap.get(number) == maxFrequency) {
    resultSet.add(number);
       }
    }

    return new ArrayList<>(resultSet);
       }
    }

    14. Páratlan Számok Megszámolása. Írj egy metódust, amely megszámolja a páratlan számokat egy adott számsorozatban és visszaadja ezt az értéket.
     
    import java.util.*;
     
    public class HelloWorld {
     
        public static void main(String[] args) {
            List<Integer> testList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
            System.out.println(numberOfOdds(testList));
        }
     
        public static int numberOfOdds(List<Integer> numberList) {
        int numberOfOdds = 0;
        for (int i = 0; i < numberList.size(); i++){
     
        if (numberList.get(i) % 2 == 1){
        numberOfOdds++;    
                }
            }
        return numberOfOdds;
        }
     
    }
    15. Legnagyobb Közös Osztró (GCD). Írj egy metódust, amely kiszámolja két szám legnagyobb közös osztóját (GCD).
    public class HelloWorld {
     
        public static void main(String[] args) {
            System.out.println(gcd(56, 98)); // Eredmény: 14
            System.out.println(gcd(98, 56)); // Eredmény: 14
        }
     
        public static int gcd(int a, int b) {
            while (b != 0) {
                int temp = b;
                b = a % b;
                a = temp;
            }
            return Math.abs(a); // Abszolút érték, hogy a negatív számok esetén is pozitív eredményt kapjunk
        }
    }
     
    16. Fibonacci Sorozat. Írj egy metódust, amely visszaadja az első n Fibonacci számot egy listában. Az n az átadott paraméter. A Fibonacci sorozat az az összegzési sorozat, ahol az aktuális szám az előző két szám összege (pl.: 0, 1, 1, 2, 3, 5, 8, …).
    import java.util.ArrayList;
    import java.util.List;
     
    public class HelloWorld {
     
        public static void main(String[] args) {
            System.out.println(fibonacci(10)); // [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
        }
     
        public static List<Integer> fibonacci(int n) {
            List<Integer> list = new ArrayList<>();
            if (n <= 0) {
                return list;
            }
            list.add(0);
            if (n == 1) {
                return list;
            }
            list.add(1);
            for (int i = 2; i < n; i++) {
                int nextNumber = list.get(i – 1) + list.get(i – 2);
                list.add(nextNumber);
            }
            return list;
        }
    }
    0In Love0Happy0Not Sure0OMG0Angry0Sad0LOL0Cry0Silly0Crazy

    admin

    svg

    What do you think?

    Show comments / Leave a comment

    Leave a reply

    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 .

    Loading

    © 2024 Admin, Végtelen Ciklus, All Rights Reserved. A blogról származó idézet vagy írás átvétele csak a szerző előzetes írásbeli engedélyével lehetséges.

    svg
    Quick Navigation
    • 01

      16 próbafeladat junior/medior programozói állásinterjúkra