שלום

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

לדוגמא:

משתמש מכניס: 4 5 6 7 4 5 3 2 21 5 6 7 1 9

פלט: 3 2 21 1 9

אני לא מצליח לכתוב את זה מסתבך עם הלולאות

תנו טיפ בבקשה.

מה אתה לא מצליח?

לקרוא את המערך אתה מצליח?

מה הרעיון שלך?

איזה קוד התחלת לכתוב?

זה משהו שכתבתי אבל אני מסתבך ולא מצליח למצוא את הכיוון

public class check {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		int arr [] = new int[args.length];
		int mispar=0;
		for(int i=0; i<arr.length; i++){
			arr[i]= Integer.parseInt(args[i]);
			mispar= arr[0];
			for(int j = 1; j<arr.length; j++){

				if(mispar==arr[j]){
					 mispar= arr[j];
					 }
					 else{
						 mispar= arr[i];
					 }

			}

			System.out.print(mispar +", ");
		}


	}

}

וזה עוד משהו שכתבתי אבל לא עובד

public class sts {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		int mispar =0;
		boolean check;
		int arr [] = new int[args.length];
		int a = arr.length;
		for(int i=0; i<arr.length; i++){
			arr[i]= Integer.parseInt(args[i]);	}

		{

			do{
				check= false;
				for(int j=0; j<a; j++)
					if(arr[j]!=arr[j+1]){
						mispar=arr[j];
						check=true;
					};
				} while(check);

				for(int i=0; i<arr.length; i++)
					System.out.print(mispar+' ');
				System.out.println();

		}
	}
}

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

התכנון צריך לרוב לכלול שני מרכיבים

1) מבני זכרון

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

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

2) זרימה של התכנית

יש כמה שיטות לעצב זרימה של תכנית

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

שוב - במקרה שלך נראה על פניו כאילו אפשר להכיל את כל המשימה במחלקה אחת (למרות שאפשר גם לחלק למחלקות ואביקטים)

אז אפשר במקרה זה לנקוט בשיטה של top down שאומרת מתחילים בחלוקה גסה למשימות ואח"כ ניגשים לכל משימה ומפרקים לתת משימות וכן הלאה עד שמגיעים למשימות פשוטות מאד שאין צורך לחלק עוד

לדוגמא במקרה שלך הייתי אומר

1) קליטת קלט לתוך מבנה פנימי -

1.1) קלט - מערך מחרוזות המתקבל מmain

1.2) פלט - מערך פנימי של מספרים

המשימה יכולה גם לכלול בדיקות תקינות וכו

2) מציאת כל המספרים המופיעים פעם אחת במערך הפנימי

2.1) קלט - מערך פנימי של מספרים כפי שנקלטו

2.2) פלט - מערך חדש הכולל את המספרים שענו לתנאי

3) הדפסת פלט

עכשיו אתה מתרגם את זה למתודות שונות. מתודה main קוראת למשימות במקום לבצע את כל הלוגיקה בעצמה

מתקבלת תכנית שגם יותר קריאה וגם יותר קלה לבדיקה ודיבוג.

אתה יכול לכתוב ולבדוק כל מתודה בנפרד ואחרי שאתה יודע שמתודת קליטת קלט עובדת אתה מתרכז במשימה השניה וכו

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

ההגדרות קלט ופלט הן הגדרות פונקציונאליות (ז"א תוחמות את הלוגיקה של כל משימה)

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

טוב, מפה תנסה להתקדם לבד?

הקוד הראשון שלך לא רחוק מהתשובה , כמה דברים - תוסיף משתנה בוליאני שיקבל true אם מצאת עוד מס' דומה במערך. את הלולאה השנייה תאתחל את J לאפס

כי אתה רוצה לסרוק את כל המערך ותוסיף את התנאי הבא - (if(mispar==Integer.parseInt(args[j])&&j!=i אז תשנה את המשתנה הבוליאני ל .true בסוף , תבדוק את המשתנה הבוליאני ולפי זה תדע אם להדפיס או לא - ואל תשכח לאתחל אותו ל false בתחילת הלולאה החיצונית.

המערך arr סתם מיותר