כיצד להדפיס מספרים מ-1 עד 100 ב-Java ללא לולאות ותנאים?

פוסט זה מיועד בעיקר למי שמתכונן לראיונות. זה המקום שבו הם אוהבים לשאול סוגים כאלה של חידות. למעשה, המשימה שעל הפרק קלה והגיונית יותר לפתרון עם מחזורים ותנאים. ואנחנו חושבים שכל תלמיד JavaRush יוכל לעשות זאת לאחר הרמה הרביעית של קווסט JavaSyntax . אבל הרוב המכריע של השיטות לעיל מיועדות למי שכבר "נכנס" ל- Java Multithreading . הערה: מדובר על אי שימוש ישיר בלולאות ובתנאים. למעשה, הם "מובנים" באופן מרומז ברוב הפתרונות שהוזכרו.

אז, שיטה 1: פשוט כתוב את זה!

כמובן, הדבר הראשון שעולה בראשו של מתחיל הוא חיפוש ישיר. לא הגיוני, אבל פשוט ומובן. בדיוק באותה הדרך שבה פתרנו בעיות ברמות הראשונות של JavaRush.

System.out.println("1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 , 11 , 12 , 13 , 14 , 15 , 16 , 17 , 18 , 19 , 20 ,
 21 , 22 , 23 , 24 , 25 , 26 , 27 , 28 , 29 , 30 , 31 , 32 , 33 , 34 , 35 , 36 , 37 , 38 , 39 , 40 , 41 , 42 ,
 43 , 44 , 45 , 46 , 47 , 48 , 49 , 50 , 51 , 52 , 53 , 54 , 55 , 56 , 57 , 58 , 59 , 60 , 61 , 62 , 63 , 64 ,
 65 , 66 , 67 , 68 , 69 , 70 , 71 , 72 , 73 , 74 , 75 , 76 , 77 , 78 , 79 , 80 , 81 , 82 , 83 , 84 , 85 , 86 , 87 , 88 , 89 , 90 , 91 , 92 , 93 , 94 , 95 , 96 ,
 97 , 98 , 99 , 100");

אבל, אתה חייב להודות, זה איכשהו משעמם. לכן, אתה יכול להשתמש בשיטה השנייה.

שיטה 2: השתמש במחרוזות ועקוף את toString

public static void main(String[] args) {

        Object[] numbers = new Object[100];
        Arrays.fill(numbers, new Object() {    //создаем анонимный класс
            private int count = 0;
            @Override
            public String toString() {
                return Integer.toString(++count);
            }
        });
        System.out.println(Arrays.toString(numbers));

    }

ההערה @Overrideמציינת שאנו הולכים לעקוף שיטת מחלקה בסיסית. במקרה הזה אנחנו עוקפים toString. למעשה, זה, כמו כמעט כל הפתרונות הבאים, מכיל לולאות. מחזורים אלה פשוט מובנים בשיטות המשמשות.

שיטה 3: השתמש ברקורסיה

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

public class Recursion {

    public void ShowNums(int i) {
    // метод, который печатает

        int x = 1;

// блок try проверяет, достигли ли мы нуля
        try {
            int m = x / i;				// здесь выбрасывается исключение при i = 0
            System.out.println(i);
            i--;
            ShowNums(i);				// а вот и рекурсивный вызов
        }
        catch(ArithmeticException e) {
		// деление на нуль выбрасывает ArithmeticException
            return;					// Останавливается при попытке деления на нуль
        }

    }

     public static void main(String[] args) {

        Recursion r = new Recursion();
        r.ShowNums(100);				// вызов метода со meaningм 100
    }

}

שיטה 4: השתמש בסמאפור

public class To100 {
    public static void main(String[] args) {
        final int max = 100;
        new java.util.concurrent.Semaphore(max) {
            void go() {
                acquireUninterruptibly();
                System.err.println(max-availablePermits());
                go();
            }
        }.go();
    }
}

סמפורים הם אמצעי סנכרון לגישה למשאב. ב-Java, סמפורים מיוצגים על ידיSemaphoreהספרייהjava.util.concurrent.

שיטה 5: השתמש בחוטים

public class Counter extends Thread{

    private int cnt;

    public Counter(){
        this.cnt = 0;
    }

    private void increment(){
        System.out.println(cnt++);
        try{
            Thread.sleep(1000);
        }catch(Exception e){}
        increment();
    }

    public void run(){
        increment();
    }

    public static void main(String[] args) throws Exception{
        Counter cntr = new Counter();
        cntr.start();
        cntr.join(100000);
        cntr.interrupt();
        System.exit(0);
    }
}

שיטה 6: הכר את הספריות שלך!

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

public class To100 {
    public static void main(String[] args) {
        String set = new java.util.BitSet() {{ set(1, 100+1); }}.toString();
        System.out.append(set, 1, set.length()-1);
    }
}

שיטה 7: השתמש במחלקה Vector

כן, המחלקה הווקטורית מיושנת ונעשה בה שימוש נדיר ביותר. ובכל זאת, למה לא?

import java.util.Vector;

public class PrintOneToHundered {
  static int i;
  PrintOneToHundered() {}
  public String toString() { return ++i+""; }
  public static void main(String[] args) {
    Vector v1  =new Vector(); v1  .add(new PrintOneToHundered());
    Vector v2  =new Vector(); v2  .addAll(v1 ); v2  .addAll(v1 );
    Vector v4  =new Vector(); v4  .addAll(v2 ); v4  .addAll(v2 );
    Vector v8  =new Vector(); v8  .addAll(v4 ); v8  .addAll(v4 );
    Vector v16 =new Vector(); v16 .addAll(v8 ); v16 .addAll(v8 );
    Vector v32 =new Vector(); v32 .addAll(v16); v32 .addAll(v16);
    Vector v64 =new Vector(); v64 .addAll(v32); v64 .addAll(v32);
    Vector v100=new Vector(); v100.addAll(v64); v100.addAll(v32); v100.addAll(v4);
    System.out.println(v100);
  }
}

מבוסס על חומרים מ-Quora