למעשה, שני מספרי פיבונאצ'י הראשונים מוגדרים מראש. מספר פיבונאצ'י הראשון הוא 0 ומספר פיבונאצ'י השני הוא 1. עם אינדקס מבוסס אפס ובהנחה שמספרי פיבונאצ'י נמצאים במערך, אז:
במדד 0 , מספר פיבונאצ'י הוא 0 , ( מוגדר מראש ) ;במדד 1 , מספר פיבונאצ'י הוא 1 , ( מוגדר מראש ) ;
במדד שתיים , מספר פיבונאצ'י הוא 1 = 1 + 0 , ( לפי הגדרה ) ;
במדד 3 , מספר פיבונאצ'י הוא שתיים = 1 + 1 , ( לפי הגדרה ) ;
במדד 4 , מספר פיבונאצ'י הוא 3 = שתיים + 1 , ( לפי הגדרה ) ;
במדד 5 , מספר פיבונאצ'י הוא 5 = 3 + שתיים , ( לפי הגדרה ) ;
במדד 6 , מספר פיבונאצ'י הוא 8 = 5 + 3 , ( לפי הגדרה ) ;
במדד 7 , מספר פיבונאצ'י הוא 13 = 8 + 5 , ( לפי הגדרה ) ;
במדד 8 , מספר פיבונאצ'י הוא עשרים ואחת = 13 + 8 , ( לפי הגדרה ) ;
במדד 9 , מספר פיבונאצ'י הוא 3. 4 = עשרים ואחת + 13 , ( לפי הגדרה ) ;
וכן הלאה.
בתכנות, המשתנה n, ולא i משמש עבור האינדקסים המבוססים על אפס עבור מספרי פיבונאצ'י אלה. ועם זה, שנים עשר מספרי פיבונאצ'י הראשונים הם:
| 0 | 1 | 1 | שתיים | 3 | 5 | 8 | 13 | עשרים ואחת | 3. 4 | 55 | 89 |
| 0 | 1 | שתיים | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | אחד עשר |
השורה השנייה בטבלה נותנת את האינדקסים מבוססי האפס, שלכל אחד מהם יהיה המשתנה n בתכנות. השורה הראשונה נותנת את מספרי פיבונאצ'י המתאימים. אז, מספרי פיבונאצ'י הם לא סתם מספרים. הגדרת הליבה מתחילה ב-0, עבור מספר פיבונאצ'י הראשון ו-1 עבור מספר פיבונאצ'י השני. שאר המספרים מופקים משם.
ניתן להפיק מספרי פיבונאצ'י בזמן O(n) וגם בזמן O(1). עבור זמן O(n), אם n הוא 12 למשל, אז ייווצרו שנים עשר מספרי פיבונאצ'י הראשונים. עבור זמן O(1), רק מספר פיבונאצ'י אחד מופק. לדוגמה, אם n הוא 6, אז ייווצר מספר פיבונאצ'י 8.
מאמר זה מסביר את שתי הדרכים הללו להפקת מספרי פיבונאצ'י ב-Java.
נוסחה למספר פיבונאצ'י
יש נוסחה מתמטית למספר פיבונאצ'י. ניתן לכתוב את הנוסחה הזו בשלוש שורות או בשורה אחת. בשלוש שורות כתוב כך:
שבו F נ הוא מספר פיבונאצ'י ב-n המבוסס על אפס ה' אינדקס. כך מוגדר מספר פיבונאצ'י.
הפקת מספרי פיבונאצי בזמן O(n).
אם יש להפיק מספרי פיבונאצ'י בפעמי O(3), המספרים 0, 1, 1 היו מיוצרים; אלה שלושת מספרי פיבונאצ'י הראשונים. ה-n האחרון מבוסס אפס ה' האינדקס כאן, הוא 2. אם מספרי פיבונאצ'י אמורים להיות מיוצרים בפעמי O(7), המספרים 0, 1, 1, 2, 3, 5, 8 יופקו; אלו הם שבעת מספרי פיבונאצ'י הראשונים. ה-n האחרון מבוסס אפס ה' האינדקס כאן, הוא 6. אם מספרי פיבונאצ'י אמורים להיות מיוצרים ב-O(n) פעמים, המספרים, 0, 1, 1, 2, 3, 5, 8 – – -, יופקו; אלו הם מספרי פיבונאצ'י הראשונים. ה-n האחרון מבוסס אפס ה' המדד כאן הוא n-1.
שיטת Java במחלקה להפקת n מספרי פיבונאצ'י הראשונים היא:
מעמד פיבונאצ'י {בָּטֵל פיבונאצ'י ( int [ ] פ ) {
int נ = פ. אורך ;
אם ( נ > 0 )
פ [ 0 ] = 0 ;
אם ( נ > 1 )
פ [ 1 ] = 1 ;
ל ( int אני = שתיים ; אני < נ ; אני ++ ) { //n=0 ו-n=2 נשקלו
int currNo = פ [ אני - 1 ] + פ [ אני - שתיים ] ;
פ [ אני ] = currNo ;
}
}
}
הכיתה, פיבונאצ'י היא פרטית. ה fibonacci() השיטה לוקחת את המערך P ומחזירה void. השיטה מתחילה בקביעת אורך המערך. אורך זה של n הוא מספר מספרי פיבונאצ'י הנדרשים. מספרי פיבונאצ'י הראשון והשני נקבעים במפורש ומוכנסים למיקום הראשון והשני במערך.
שאר מספרי פיבונאצ'י המתחילים מהשלישי (אינדקס, n = 2) נקבעים בלולאת for וממוקמים במיקומים שלהם במערך. אז, הפונקציה צריכה להחזיר ריק. ההצהרה העיקרית ב-for-loop מוסיפה את שני המספרים הקודמים.
משתנה האינדקס, i, שימש במקום n, לצורך הבהירות.
מחלקת Java Main מתאימה (עם השיטה הראשית של Java) היא:
פּוּמְבֵּי מעמד רָאשִׁי {פּוּמְבֵּי סטָטִי בָּטֵל רָאשִׁי ( חוּט args [ ] ) {
int M = 12 ;
int [ ] arr = חָדָשׁ int [ M ] ;
Fibonacci obj = חָדָשׁ פיבונאצ'י ( ) ;
obj. פיבונאצ'י ( arr ) ;
ל ( int אני = 0 ; אני < M ; אני ++ )
מערכת . הַחוּצָה . הדפס ( arr [ אני ] + '' ) ;
מערכת . הַחוּצָה . println ( ) ;
}
}
לאחר הפקת המספרים בשיטת fibonacci(), השיטה הראשית של Java קוראת אותם.
הפקת מספר פיבונאצי אחד בזמן קבוע
יש נוסחה מתמטית שניתן להשתמש בה כדי לייצר מספר פיבונאצ'י, כאשר ניתן לאינדקס המתאים מבוסס אפס, n. הנוסחה היא:
כאשר n הוא האינדקס מבוסס האפס ו-Fib נ הוא מספר פיבונאצ'י המתאים. שימו לב שבצד ימין של המשוואה, לא השורש הריבועי של 5 מועלה בחזקת n; זה הביטוי בסוגריים שמועלה לעוצמה n. יש שני ביטויים כאלה.
אם n הוא 0, Fib נ יהיה 0. אם n הוא 1, Fib נ יהיה 1. אם n הוא 2, Fib נ יהיה 1. אם n הוא 3, Fib נ יהיה 2. אם n הוא 4, Fib נ יהיה 3 - וכן הלאה. הקורא יכול לאמת נוסחה זו באופן מתמטי, על ידי החלפת n בערכים שונים והערכה.
כאשר מקודדים, נוסחה זו תייצר רק מספר פיבונאצ'י אחד עבור n. אם נדרשים יותר ממספר פיבונאצ'י אחד, יש לקרוא לקוד של הנוסחה פעם אחת עבור כל אחד מהאינדקסים התואמים השונים.
ב-Java, השיטה לייצר מספר פיבונאצ'י אחד בלבד היא:
יְבוּא java.lang.* ;מעמד שֶׁקֶר {
לְהַכפִּיל fibNo ( int נ ) {
לְהַכפִּיל FibN = ( מתמטיקה . פאו ( ( 1 + מתמטיקה . sqrt ( 5 ) ) / שתיים , נ ) – מתמטיקה . פאו ( ( 1 - מתמטיקה . sqrt ( 5 ) ) / שתיים , נ ) ) / מתמטיקה . sqrt ( 5 ) ;
לַחֲזוֹר FibN ;
}
}
את החבילה java.lang.* היה צורך לייבא בתחילת התוכנית. הסיבה לכך היא שהחבילה כוללת את המחלקה Math, שיש לה את השיטות power (pow) ושורש ריבועי (sqrt). שיטת Java המותאמת אישית כאן מיישמת את הנוסחה המתמטית ישירות.
מורכבות הזמן עבור פונקציה זו היא O(1), אילף קבוע של פעולה ראשית אחת. מחלקת Java Main מתאימה, עם השיטה הראשית של Java לשיטה שלעיל היא:
פּוּמְבֵּי מעמד רָאשִׁי {פּוּמְבֵּי סטָטִי בָּטֵל רָאשִׁי ( חוּט args [ ] ) {
int נ = אחד עשר ;
Fib obj = חָדָשׁ שֶׁקֶר ( ) ;
לְהַכפִּיל ימין = obj. fibNo ( נ ) ;
מערכת . הַחוּצָה . println ( ימין ) ;
}
}
האינדקס n = 11 נשלח ומספר פיבונאצ'י, 89 מוחזר. הפלט הוא:
89.000000000000003ניתן להסיר את הספרות העשרוניות המיותרות, אבל זה דיון לזמן אחר.
סיכום
מספרי פיבונאצ'י הם רצף מסוים של מספרים שלמים. כדי לקבל את המספר הנוכחי, הוסף את שני המספרים הקודמים המיידיים המתאימים. שני מספרי פיבונאצ'י הראשונים, 0 ואחריו 1, מוצהרים מראש, עבור כל הרצף. שאר מספרי פיבונאצ'י מופקים משם.
כדי להפיק מספרי פיבונאצ'י ממדד 2, לזה שמתאים לאינדקס n-1, השתמש בלולאת for עם ההצהרה הראשית:
int currNo = פ [ אני - 1 ] + פ [ אני - שתיים ] ;כאשר currNo הוא מספר פיבונאצ'י הנוכחי ו-P הוא המערך לאחסון n המספרים.
כדי להפיק מספר פיבונאצ'י אחד בלבד מכל אינדקס n מבוסס אפס, השתמש בנוסחה המתמטית:
