משימות Java עם טוויסט: שלום, ראיונות!

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

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

משימה 1: צור לולאה אינסופית מאפס

סופק גוש קוד. הוסף לזה כדי שהלולאה תהיה אינסופית.

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

// Insert code here

        for (int i = start; i <= start + 1; i++) {
             /* This should be an infinite loop, but don't change anything here */
        }
    }
}

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

פִּתָרוֹן

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

class ToInfinity {
    public static void main(String[] args) {
        int start = Integer.MAX_VALUE - 1;
        for (int i = start; i <= start + 1; i++) {
            // Infinite loop
            System.out.println(i); // Be sure we are in an infinite loop
        }
    }
}

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

משימה 2: צור הערת הפעלה

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

פִּתָרוֹן

קוד Java למשימה זו:

public class ExecutableComment {
    public static void main(String[] args) {
        // The comment below will be executed!
        // \u000d System.out.println("executable comment");
    }
}

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

executable comment

הסיבה לכך היא שהמהדר של Java מפרש את תו Unicode \u000dכשורה חדשה, וקורא את הקוד שלנו כך: קוד Java עבור המשימה הזו, כפי שהוא מתפרש על ידי המהדר:

public class ExecutableComment {
    public static void main(String[] args) {
        // The comment below will be executed!
        // \u000d
        System.out.println("comment executed");
    }
}

משימה 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כדי לקבוע אם להמשיך או לצאת מהלולאה הפנימית.

משימה 4: מצא כפיל בודד במערך של מספרים שלמים

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

הנה האלגוריתם

חשב את הסכום של כל המספרים מ-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();
// Find the sum of all list elements
        int totalSum = elements.stream().mapToInt(e -> e).sum();
        System.out.println("The repeated element is: " + (totalSum - distinctSum));
    }

    public static void main(String[] args) {
// Create a list of sequential elements in the interval [1..101).
        List <Integer> elements = IntStream.range(1, 101).boxed().collect(Collectors.toList());
// Add the value 23 at index 53
        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);
        }
        // Add a duplicate to the list
        numbers.add(25);
        Duplicate dn = new Duplicate();
        System.out.println("The repeated element is: " + dn.findDuplicateNumber(numbers));
    }
}

משימה 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 <>();
// Use the following rule to populate the Map duplicates:
// the key is the element value, and the value is the number of times it occurs
        elements.forEach(e -> duplicates.put(e, duplicates.get(e) == null ? 1 : duplicates.get(e) + 1));
// Remove any elements that don't occur more than once from the Map duplicates
// and store the result as a list (to make it easy to work with in the next step)
        List <Map.Entry <Integer, Integer> >
        result = duplicates.entrySet().stream().filter(d -> d.getValue() > 1).collect(Collectors.toList());
// Write the results for all elements to the result list
        result.forEach(e -> System.out.println(String.format("Element %d  occurs %d times", 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);
    }
}

סיכום

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