בעיות Java עם טריק: שלום, ראיונות!

עבור תלמידי JavaRush , אתגרי תכנות, Java והמאמת הם החברים הכי טובים. עם זאת, מגיע זמן לכל מפתח פדאוואן שבו אתה צריך להתחיל לפעמים לצאת מהמסלול, להמציא לעצמך מיני פרויקטים ולהתכונן לראיונות. בראיון נראה שאתה צריך להיתקל בדיוק באותן בעיות ג'אווה מעשיות כמו בקורס. ברוב המקרים זה נכון, אבל חברות מסוימות אוהבות לשאול שאלות טריק או משהו יוצא דופן. כדי להימנע מבלבול במהלך ראיון מלחיץ, כדאי לנסות לפתור בעיות Java כאלה בעצמך, בבית. במאמר זה נסתכל על חצי תריסר מהמשימות המסובכות הללו. אנו ממליצים לך קודם לקרוא את התנאי ולנסות לפתור אותו בעצמך. ועוד משהו: אל תשכח לפתור את בעיות הג'אווה מהקורס כל יום!

• משימה-1: יצירת לולאה אינסופית מאפס
• משימה-2. צור הערה שתתבצע
• משימה-3: צור לולאה עם שם
• משימה-4. בערך כפיל בודד במערך של מספרים שלמים
• משימה-5. על כפיל לא ייחודי במערך של מספרים שלמים

בעיית Java - 1: יצירת לולאה אינסופית מאפס

נתון בלוק קוד. השלם אותו כך שהלולאה תהיה אינסופית.

class ToInfinity {
    public static void main(String[] args) {

//впишите code сюда

        for (int i = start; i <= start + 1; i++) {
             /* тут должен быть бесконечный цикл, менять ничего нельзя*/
        }
    }
}

"שום דבר מסובך," אתה אומר. סביר להניח שמצאת את עצמך במצב זה יותר מפעם אחת: תוך כדי פתרון בעיות ג'אווה, יצרת לולאה אינסופית וחשבת כיצד להיפטר ממנה. זה הפוך. החוכמה היא שלא ניתן לשנות את המחזור עצמו ואת התנאים ליציאה ממנו. יש רק שתי איטרציות. עם זאת, יש מספיק מהם כדי ליצור לולאה אינסופית. זה נראה כאילו זה אמור לעבוד רק עבור שתי איטרציות, אבל זה יכול להיעשות אינסופי באמצעות הצפה. כבר ניחשתם איך?

פִּתָרוֹן

עקב הצפה. Integer.MAX_VALUEהוא הערך המקסימלי שניתן intלאחסן ב-Java. אם אתה מגיע Integer.MAX_VALUEלערך הזה ומגדיל אותו, אתה מטה אל Integer.MIN_VALUE, כלומר, לערך המינימלי Integer. לפיכך, כדי לפתור את בעיית ג'אווה זו, אנחנו רק צריכים להקצות startערך למשתנה שהוא 1 פחות מהערך המקסימלי עבור סוג הנתונים int. קוד משימה ב-Java:

class ToInfinity {
    public static void main(String[] args) {
        int start = Integer.MAX_VALUE - 1;
        for (int i = start; i <= start + 1; i++) {
            //бесконечный цикл
            System.out.println(i); //убеждаемся в бесконечности цикла
        }
    }
}

מה קורה? אנחנו מתחילים עם start=2147483645 (Integer.MAX_VALUE-1), באיטרציה הבאה הערך הופך ל-2147483645, ואז 2147483646, ואז -2147483648, -2147483647... וכן הלאה.

Java task-2. צור הערה שתתבצע

ובכן, הנה אנחנו כאן! כבר בהרצאות הראשונות שמענו שההערות אינן מבוצעות. בגלל זה הן הערות. אנו חושבים שהפתרון לבעיה זו לא תמיד ברור למתכנת ג'אווה, אפילו לא מנוסה. עם זאת, יש דרך מסובכת אחת לאלץ את מכונת ג'אווה להפעיל הערה "באופן חוקי" לביצוע. אתה מרגיש מאיפה נושבת הרוח? נסה לנחש!

פִּתָרוֹן

קוד לפתרון הבעיה ב-Java:

public class ExecutableComment {
    public static void main(String[] args) {
        // комментарий ниже будет выполнен!
        // \u000d System.out.println("выполняемый комментарий");
    }
}

אם נקליד את הקוד עבור משימה זו ב-Java ב-IDE, זה מה שנקבל:

выполняемый комментарий

הסיבה היא שהמהדר של Java קורא את התו Unicod \u000dכשורה חדשה, וקורא את הקוד שלנו באופן הבא: המהדר פיענח קוד לפתרון הבעיה ב-Java:

public class ExecutableComment {
    public static void main(String[] args) {
        // the line below this gives an output
        // \u000d
        System.out.println("comment executed");
    }
}

משימת Java - 3: צור לולאה עם שם

נציג נוסף של הסדרה "בעיות תכנות מעשיות, ג'אווה בוואקום כדורי". במובן שלא ברור למה זה נחוץ, לא סביר שהמחזור מרגיש פגוע מהעובדה שהוא לא אישי. טוב, בסדר, עוד משהו חשוב: השפה מאפשרת לתת למחזור שם.

פִּתָרוֹן

הערה: לחלקם, "שמות" כאלה ידועים כ"תגים", שלא מומלץ להשתמש בהם בפועל. קוד לפתרון הבעיה ב-Java, הדגמה של לולאה בשם

public class NamedLoop {
    public static void main(String[] args) {
        loop1:
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 5; j++) {
                if (i == 3)
                    break loop1;
                System.out.println("i = " + i + " j = " + j);
            }
        }
    }
}

זה מה יהיה הפלט אם תפעיל את התוכנית:

i = 0 j = 0
i = 0 j = 1
i = 0 j = 2
i = 0 j = 3
i = 0 j = 4
i = 1 j = 0
i = 1 j = 1
i = 1 j = 2
i = 1 j = 3
i = 1 j = 4
i = 2 j = 0
i = 2 j = 1
i = 2 j = 2
i = 2 j = 3
i = 2 j = 4

כאן אתה יכול גם להשתמש ב'המשך' כדי לעבור לתחילתה של לולאה בעלת שם. ובמידת הצורך, אתה יכול להשתמש break(או continue) בלולאה מקונן if-elseעם for-לפירוק מספר לולאות באמצעות if-else. זה יעזור להימנע מהגדרת הרבה דגלים ובדיקתם if-elseכדי להבין אם להמשיך או לצאת מהלולאה הפנימית.

בעיית Java - 4. בערך הכפיל היחיד במערך של מספרים שלמים

נתון מערך (או ArrayList, כפי שאתה מעדיף) של מספרים שלמים המכילים אלמנטים Integerמ-1 עד 100. למערך זה יש אלמנט משוכפל אחד ויחיד. איך למצוא את זה? משימות כאלה מוכרות יותר למתכנת ג'אווה משלושת הקודמות. כי לא מדובר בהכרת דקויות השפה, שכמעט אף פעם לא נעשה בהן שימוש, אלא בהיגיון. הדחף הבלתי מרוסן הראשון לפתור בכוח גס נעלם די מהר כשהראש שלך נדלק או שיש גישה "אני מתכנת, אני חכם". הדבר הרע היחיד הוא שבמהלך ראיון, בלחץ, זה עלול לא לקרות. אז תחשוב עכשיו לפני שאתה בוחן את הפתרון!

אלגוריתם הפתרון הוא כדלקמן:

חשב את הסכום של כל המספרים מ-1 עד 100. אנו חושבים שאתה יודע איך לעשות זאת (לדוגמה, בשיטת גאוס המפורסמת) כעת חשב את סכום האלמנטים של המערך שלך או ArrayList’а. ו... להפחית את הסכום הראשון מהשני. בינגו! המספר המתקבל הוא הערך של האלמנט הכפול. קוד פתרון בעיות Java עבור ArrayList.

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class FindDuplicate {
    private static void findDuplicate(List<Integer> elements) {
//находим сумму всех уникальных элементов списка
        int distinctSum = elements.stream().distinct().mapToInt(e -> e).sum();
//находим сумму всех элементов списка
        int totalSum = elements.stream().mapToInt(e -> e).sum();
        System.out.println("Элемент, который повторяется : " + (totalSum - distinctSum));
    }

    public static void main(String[] args) {
//создаем список последовательных элементов на промежутке [1..101).
        List <Integer> elements = IntStream.range(1, 101).boxed().collect(Collectors.toList());
//устанавливаем элементу с индексом 53 meaning 23
        elements.set(53, 23);
        findDuplicate(elements);
    }
}

פתרון אחר

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

public class Duplicate {

    public int findDuplicateNumber(List<Integer> numbers) {

        int highestNumber = numbers.size() - 1;
        int total = getSum(numbers);
        int duplicate = total - (highestNumber * (highestNumber + 1) / 2);
        return duplicate;
    }

    public int getSum(List<Integer> numbers) {

        int sum = 0;
        for (int num : numbers) {
            sum = sum + num;
        }
        return sum;
    }

    public static void main(String a[]) {
        List <Integer> numbers = new ArrayList <Integer>();
        for (int i = 1; i < 100; i++) {
            numbers.add(i);
        }
        //добавляем дубликат в список
        numbers.add(25);
        Duplicate dn = new Duplicate();
        System.out.println("Элемент, который повторяется: " + dn.findDuplicateNumber(numbers));
    }
}

בעיית Java - 5. על כפיל לא ייחודי במערך של מספרים שלמים

אם הבעיה הקודמת נראתה לך קלה מדי, נסה לפתור את הבעיה הבאה: נתון גיליון של מספרים שלמים מ-1 עד 100. הוא מכיל כפילויות (יותר מאחד). איך למצוא אלמנטים שמתרחשים יותר מפעם אחת (מוצאים את האלמנט עצמו ומציינים כמה פעמים הוא מופיע)?

פִּתָרוֹן

הפתרון ההגיוני ביותר כאן הוא להשתמש במבנה כגון HashMap, מכיוון שהוא מאחסן נתונים בצמדי מפתח-ערך. קוד לפתרון בעיית Java:

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class SomeDuplicates {
    private static void findDuplicates(List<Integer> elements) {
        HashMap <Integer, Integer > duplicates = new HashMap < >();
//заполняем Map duplicates значениями по принципу:
// ключ – meaning element, meaning – сколько раз он встречается
        elements.forEach(e -> duplicates.put(e, duplicates.get(e) == null ? 1 : duplicates.get(e) + 1));
//из duplicates убираем все элементы, которые встретorсь не более 1 раза,
//и сохраняем //результат в список (для удобства обработки на следующем шаге)
        List <Map.Entry <Integer, Integer> >
        result = duplicates.entrySet().stream().filter(d -> d.getValue() > 1).collect(Collectors.toList());
//выводим результат для всех элементов в списке result
        result.forEach(e -> System.out.println(String.format("Элемент %d  встречается %d раз", e.getKey(), e.getValue())));
    }

    public static void main(String[] args) {
        List <Integer> elements = IntStream.range(1, 101).boxed().collect(Collectors.toList());
        elements.set(97, 23);
        elements.set(27, 51);
        elements.set(99, 23);
        findDuplicates(elements);
    }
}

סיכום

בעיות ג'אווה מעשיות שונות מאוד, ואתה לא יודע איזה סוג של פאזל לא ידוע יחליט המראיין לתת לך. עם זאת, כל מעסיק מתאים מבין שהרבה יותר חשובה מהיכולת שלך לפתור בעיות ג'אווה מסובכות תהיה היכולת שלך לפתור בעיות מעשיות אמיתיות , כמו אלה שתתקל בהן במהלך עבודתך. אז תפתור אותם כמה שיותר. זו הסיבה ש-JavaRush נוצר. נעשה שימוש בחומרים של geeksforgeeks בהכנת מאמר זה.