מי שיודע קצת java בבקשה שיכנס..

את צריכה להשתמש ב if
אני לומדת שפה דומה.

מחסנית הכוונה למערך?

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

אולי תנסי עם for?
זה צריך להיות עם if בדוק

אני מבין את הרעיון
גם צריך לולאה בתוך לולאה

שואל השאלה:
לא חושבת שזה אפשרי עם for, אבל תודה :)

אולי לולאת while ואז איף?

שואל השאלה:
זה מה שעשיתי

למה עשית פעמים while
תנסי פעם אחת while ואז if

שואל השאלה:
טוב, תודה לכם.. אני אמשיך לנסות

שני האיברים במחסנית שמתחברים לx הם אחד אחרי השני או שכל שני איברים במחסנית?

שואל השאלה:
כל שני איברים במחסנית

הסתדרת?

שכחתי לענות,
אם זה לא אסור, הייתי מכניס את כל איברי המחסנית למערך, בלולאת while.

אחר כך, באמצעות לולאה כפולה שהתנאי עצירה שלה הוא גם שלא נגמר המערך וגם משתנה דגל שיודע שלא נמצא זוג שמסתכם לx, ארוץ על המערך וכאשר האינדקס הראשון לא שווה לאינדקס השני(כדי לא לחבר איבר עם עצמו) אבדוק אם תוצאת החיבור היא x.

כלומר בשביל כל איבר, ארוץ על המערך לראות אם יש איבר שמשלים אותו לx(שאיננו הוא עצמו).

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

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

אנונימי שמעליי
נראה לי אפשר עם עוד איזה שתי מחסניות לעבור על הכל לא? בלי קשר אם זה צמוד או לא

אני לא מצליח לדמיין מה תעשה עם עוד שתי מחסניות, אם תוכל לתאר לי את האלגוריתם אשמח לראות. את רוב הצרות שלי אני פותר עם מערכים פשוט חח.

וואי אני אקום מחר בבוקר ואסתכל מול דף
קשה לי ככה חחח

חח בסדר, לילה טוב :).

אם את צריכה עזרה שלחי הודעה בפרטי

למדתם תור?

אנונימי איך תבנה מערך אם אתה לא יודע את האורך של המחסנית? ניסית לעשות את זה מתישהו על מחשב?

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

פיתרון עדכני למטה

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

super natural
במקרה הזה זה עובד... תנסה עם איקס שווה ל18 והמחסנית הבאה ותראה שזה לא עובד:
2
8
10
5
(2 ראש המחסנית)

הבנתי צודק/ת לא חשבתי על זה לבדוק זוגות של כל מספרים אפשריים זה יהיה ביעילות מסובכת

שניה אחשוב על משהו

אוקי חשבתי על משהו אבל זה סיבוכיות o(n בריבוע)

האמת שאולי עם תור או רשימה מקושרת אפשר לעשות את זה אבל אם זה רק מחסניות אז צריך איזה n מחסניות (n איברים במחסנית) אחרת אני לא רואה פתרון אחר
אבל אולי יש משהו שלא חשבתי עליו
ואפשר באמת לספור איברים ולבנות מערך.. בעקרון זה מתקבל בבגרות (את יכולה לעשות את זה בפעולת עזר ) השאלה מה דרשו מהם בבית ספר

כן זהו זה נראה לי פשוט מסובך ככה יחסית לתרגילים ראשונים

אה, רשימה במקום מערך יותר טוב אולי, כי לא צריך לספור איברים, נכון, שכחתי ממנה חח

חח כן אבל דו כיוונית עדיפה נראה לי
לא יודעת אם היא למדה

לא זוכר מה היא דו כיוונית אבל נראה לי די מיותר, שתשמור את הפירסט פשוט וממנו היא יכולה לרוץ כמה פעמים שבא לה כי זה לא משנה את הרשימה, פשוט שיהיו לה שני משתנים זמניים שאיתם תרוץ בלולאות(ותאפס את הפנימית לפי הפירסט)

אני כותב את הקוד ואעלה אותו כמו שצריך ואשלח לינק

import java.util.stack;

public class main {

public static int sizeofstack(stack<integer> s1){
stack<integer> s2 = new stack<>();
int size=0;
while(!s1.empty()){ // סופרים את מספרים האיברים
s2.push(s1.pop());
size++;
}
while(!s2.empty()){ // מחזירים בחזרה את האיברים למחסנית
s1.push(s2.pop());
}
return size;
}
//
public static boolean issumexist(stack<integer> s1 , int x){
//הפעולה מקבלת מחסנית ומספר
// הפעולה מחזירה אמת אם קיים סכום של זוג מספרים שווה למספר שהתקבל
// הפעולה גם תמנע שגיאות ובעיות כגון אם גודל המחסנית אינו גדול מ 1 אין מה לבדוק כי היא לא תבצע את הסכום ולכן נחזיר ישר שקר
int size = sizeofstack(s1);
if (size>1){
stack<integer> s2 = new stack<>();
int first = s1.pop() , second = s1.pop();
if (size>2){
while (!s1.isempty()){
if (first + second!=x){
s2.push(second);
while (!s1.isempty()){
second = s1.pop();
if (first + second == x)
return true;
s2.push(second);
}
while (!s2.isempty()){ // מחזירים את האיברים שנותרו למחסנית
s1.push(s2.pop());
}
} else
return true;

if (sizeofstack(s1)<2)
return false;
else{
first = s1.pop();
second = s1.pop();
}

}
} else if(size==2) { // במקרה וגודל המחסנית הוא 2 אז נבצע בדיקה ישירה ללא צורך להיכנס לתוך לולאה .
if (first + second == x)
return true;
}
}
return false;
}

public static void main(string[] args) {
stack<integer> s = new stack<>();
s.push(8);
s.push(7);
s.push(6);
s.push(1);
s.push(9);
system.out.println(s.tostring());
system.out.println("size of stack: " + sizeofstack(s));
system.out.println(issumexist(s,10));
}
}

זה ארוך אבל זה עובד ב 100% עבור כל מקרה קיצון
גם אם המחסנית בגודל של 2 , גם אם יש איבר יחיד במחסנית .
עכשיו הפיתרון השתמשתי במחקת stack המובנת של java
שזה פחות או יותר אותו דבר רק שהיא לא מקבלת משתנים פרימיטיבים .
זאת אומרת את לא יכולה ליצור מחסנית מטיפוס int חייב ליצור מ integer
integer זה מחלקה וזה שייך למשהו שנקרא wrapper class .
שזה בעצם אומר שלכל טיפוס פרימיטיבי יש מחלקה משלו ודרכה אפשר לעשות פעולות כמו tostring .
אוטומטית שמכניסים איבר ל wrapper class כמו ככה :
integer x = 5 ;
אין צורך לרשום : integer x = new integer(5);
שני הדרכים יעבדו לך אבל java מקצרת לך את הכתיבת קוד .

^ נראה לי שאתה לא בודק אם אתה מחבר איבר עם עצמו, אם נניח אתה שולח 10 כx, ואחד האיברים במחסנית הוא 5, נראה לי שתהיה שגיאה והפעולה תחזיר אמת. אתה צריך משתנה זמני שיציין מקום במחסנית לדעתי...

אני בדקתי הכל טוב תעתיק את כל זה ל ide ותריץ תראה שזה עובד , כל מה שהדבר הזה עושה זה פשוט אם יש לך מחסנית : [5,3,8,10]
first ישמור על 10 וכל פעם יעשה סכום עם 8 .. 3 .. 5.. אם הוא ראה שזה שווה ל x יחזיר אמת אחרת זה ממשיך
first ישמור הפעם את הערך 8 יבדוק אם 8 ועוד 3 או 5 שווים ל x
כל פעם בתכלס מספר הבדיקות יצטמצם אבל זה עדין בסיבוכיות o של n בריבוע

קיצר הכי טוב לספור את האיברים ולבנות מערך

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

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

תעתיקי את מה שהקלדתי מקודם למעלה

ואם את צריכה עזרה שלחי פרטי

המחסנית מממשת ממשק לstream?

אם כן אתה יכול לסנן כל איבר שלא שווה לx ולבדוק האם אורך הסטרים הוא 2 או יותר

נניח stack s

bool predicate = integer.compare(s.stream()
.filter(x::equals)
.count(), 2) >= 0

שואל השאלה:
תודה