מציג תוצאות 1 עד 9 מתוך 9

אשכול: פעולות(פונקציות) שימושיות עבור מדעי המחשב ב'

  1. #1
    הסמל האישי שלHurricane אסיסטנט חבר Emath בכיר

    פרטי משתמש

    ברירת מחדל [פרסום] מלא פעולות לבגרות! חובה הדפסה! :)

    כתבתי מספר פעולות שרובן רקורסיביות על החומר של מדעי המחשב ב', בתקווה שזה יעזור לכם בבגרות.
    בהצלחה לכולם!!

    קוד:
    	/*
    	 * ****************************EASY STUFF****************************************
    	 */
    	
    	//הפעולה מחזירה את מכפלת שני המספרים
    	public static int multiplication(int a, int b)
    	{
    		if (b == 1)
    			return a;
    		
    		return a + multiplication(a, b - 1);
    	}
    	
    	//הפעולה מחזירה את החלוקה השלמה של שני המספרים
    	public static int division(int a, int b)
    	{
    		if (a < b)
    			return 0;
    		
    		return 1 + division(a - b, b);
    	}
    	
    	//הפעולה מחזירה את שארית החלוקה - מודולו
    	public static int modulus(int a, int b)
    	{
    		if (a < b)
    			return a;
    		
    		return modulus(a - b, b);
    	}
    	
    	//הפעולה מחזירה את איי בחזקת בי
    	public static int power(int a, int b)
    	{
    		if (b == 1)
    			return a;
    		
    		return a * power(a, b - 1);
    	}
    	
    	//הפעולה ממירה את המספר איקס לבסיס בייס
    	public static String toBase(int x, int base)
    	{
    		if (x == 0)
    			return "0";
    		
    		String baseString = "";
    		
    		if (x != 0)
    		{
    			baseString += toBase(x / base, base);
    			
    			if (x % base > 9)
    				baseString += (char)(x % base - 10 + 'A');
    			else
    				baseString += x % base;
    		}
    		
    		return baseString;
    	}
    	
    	//הפעולה מחזירה את האיבר ה- N בסדרה חשבונית
    	public static int computeArithmeticAn(int a1, int d, int n)
    	{
    		if (d == 0 || n == 1)
    			return a1;
    		
    		return d + computeArithmeticAn(a1, d, n-1);
    	}
    	
    	//הפעולה מחזירה את האיבר ה- N בסדרה הנדסית
    	public static int computeGeometricalAn(int a1, int q, int n)
    	{
    		if (q == 1 || n == 1)
    			return a1;
    		
    		return q * computeGeometricalAn(a1, q, n - 1);
    	}
    	
    	//הפעולה מחזירה את המחלק הגדול ביותר
    	//עבור 30 ו- 12, הפעולה תחזיר 3, כי זהו המחלק הגדול ביותר
    	public static int gcd(int a, int b)
    	{
    		if (a == b)
    			return a;
    		
    		if (a < b)
    			return gcd(a, b - a);
    		else
    			return gcd(a - b, b);
    	}
    	
    	//הפעולה מחזירה את מספר האותיות במילה.
    	//מילה נגמרת כשיש נקודה. הנחה: המחרוזת מסתיימת בנקודה
    	public static int numberOfCharsInWord(String word)
    	{
    		if (word.compareTo(".") == 0)
    			return 0;
    		
    		return 1 + numberOfCharsInWord(word.substring(1));
    	}
    	
    	//הפעולה מחזירה את מספר הפעמים שהתו מופיע במחרוזת
    	public static int charInString(String string, char charToFind)
    	{
    		if (string.length() == 0)
    			return 0;
    		
    		if (string.charAt(0) == charToFind)
    			return 1 + charInString(string.substring(1), charToFind);
    		else
    			return charInString(string.substring(1), charToFind);
    	}
    	
    	//הפעולה מחזירה אמת אם המחרוזת היא פולינדרום
    	public static boolean isPalindrome(String string)
    	{
    		if (string.length() == 1)
    			return true;
    		
    		if (string.charAt(0) != string.charAt(string.length() - 1))
    			return false;
    		
    		return isPalindrome(string.substring(1, string.length() - 1));
    	}
    	
    	//הפעולה מחזירה את סכום איברי המערך
    	public static int sumArray(int[] array, int index)
    	{
    		if (index == array.length - 1)
    			return array[array.length - 1];
    		
    		return array[index] + sumArray(array, index + 1);
    	}
    	
    	//הפעולה מדפיסה את לוח הכפל
    	public static void multiplicationBoard(int i, int j)
    	{
    		if (i <= 10 && j <= 10)
    		{
    			for (int k = i; k <= 10; k++)
    				System.out.print(k * j + " ");
    			
    			System.out.println();
    			multiplicationBoard(i, j + 1);
    		}
    	}
    	
    	//הפעולה מקבלת מחרוזת ומחזירה מספר.
    	//המספר הוא המספר שמופיע במחרוזת, עד שיש תו אחר שהוא לא מספר.
    	//עבור המחרוזת:
    	//351ab50, הפעולה תחזיר 351.
    	//יש באג והפעולה מחזירה את המספר הפוך. כלומר 153
    	public static int numFromString(String string, int power)
    	{
    		if (string.length() == 1 || string.length() > 1 && !isNumber(string.charAt(0)))
    		{
    			if (isNumber(string.charAt(0)))
    				return power * (string.charAt(0) - 48);
    			else
    				return 0;
    		}
    		
    		if (isNumber(string.charAt(0)))
    			return power * (string.charAt(0) - 48) + numFromString(string.substring(1), power * 10);
    		
    		return numFromString(string.substring(1), power * 10);
    	}
    	
    	//הפעולה מחזירה אמת אם התו הוא מספר
    	public static boolean isNumber(char myChar)
    	{
    		return myChar >= '0' && myChar <= '9';
    	}
    	
    	//הפעולה מחזירה את עצרת המספר
    	public static long factorial(int num)
    	{
    		if (num == 1 || num == 0)
    			return 1;
    		
    		return num * factorial(num - 1);
    	}
    	
    	//הפעולה מדפיסה בקבוק. עבור הקלט: *, 3, הפעולה תדפיס
    	//***
    	//**
    	//*
    	//**
    	//***
    	public static void bottle(char myChar, int times)
    	{
    		if (times == 1)
    			System.out.println(myChar);
    		
    		if (times > 1)
    		{
    			for (int i = 1; i <= times; i++)
    				System.out.print(myChar);
    		
    			System.out.println();
    			bottle(myChar, times - 1);
    		
    			for (int i = 1; i <= times; i++)
    				System.out.print(myChar);
    			
    			System.out.println();
    		}
    	}
    	
    	//הפעולה תחזיר את מיקומו של הערך איקס במערך
    	public static int getIndex(int[] array, int low, int high, int x)
    	{
    		if (low > high)
    			return 0;
    		
    		if (array[low] == x)
    			return 0;
    		
    		return 1 + getIndex(array, low + 1, high, x);
    	}
    	
    	//הפעולה תחזיר את ערכו של האיבר ה- N בסדרת פיבונצ'י
    	public static int fibonacci(int n)
    	{
    		if (n == 1)
    			return 0;
    		
    		if (n == 2)
    			return 1;
    		
    		return fibonacci(n - 1) + fibonacci(n - 2);
    	}
    	
    	//הפעולה תחזיר את מספר הספרות במספר
    	public static int getNumberOfDigits(int num)
    	{
    		if (num < 10)
    			return 1;
    		return 1 + getNumberOfDigits(num / 10);
    	}
    	
    	//הפעולה תחזיר את מספר הספרות הזהות במיקומן בשני המספרים
    	//עבור המספרים 15671, 81, הפעולה תחזיר 1 (כי רק הספרה הימנית של שני המספרים שווה)
    	public static int compareDigits(int a, int b)
    	{
    		if (a < 10 || b < 10)
    		{
    			if (a == b)
    				return 1;
    			else
    				return 0;
    		}
    		
    		if (a % 10 == b % 10)
    			return 1 + compareDigits(a/10, b/10);
    		else
    			return compareDigits(a/10,b/10);
    	}
    	
    	//הפעולה תחזיר את ממוצע הספרות במספר
    	public static double average(int num)
    	{
    		int len = 1;
    		
    		for (int n = num / 10; n > 0; n /= 10)
    			len++;
    		
    		if (len > 1)
    			return ((num % 10) + (average(num / 10) * (len - 1))) / len;
    		
    		return num;
    	}
    	
    	//הפעולה תדפיס את פתרון מגדלי האנוי
    	public static void hanoiTowers(int n, char fromTower, char toTower, char helpTower)
    	{
    		if (n == 1)
    			System.out.println("Move disk " + n + " from tower " + fromTower + " to tower " + toTower);
    		else
    		{
    			hanoiTowers(n - 1, fromTower, helpTower, toTower);
    			System.out.println("Move disk " + n + " from tower " + fromTower + " to tower " + toTower);
    			hanoiTowers(n - 1, helpTower, toTower, fromTower);
    		}
    	}
    	
    	//הפעולה תדפיס את המרחק בין המספרים
    	//המרחק הוא הפרש מספר הספרות
    	//עבור הארגומנטים: 31, 51516, הפעולה תחזיר 3
    	public static int distance(int num1, int num2)
    	{
    		if (num1 == 0 || num2 == 0)
    		{
    			int digit = 0;
    			while (num1 > 0)
    			{
    				digit++;
    				num1 /= 10;
    			}
    			
    			while (num2 > 0)
    			{
    				digit++;
    				num2 /= 10;
    			}
    			return digit;
    		}
    		
    		return distance(num1 / 10, num2 / 10);
    	}
    	
    	//הפעולה מקבלת מערך ובודקת אם ערכי המערך מהווים סדרה חשבונית
    	//כלומר קיים הפרש קבוע בין איברי המערך
    	public static boolean isArithmeticArray(int[] arr)
    	{
    		if (arr.length < 2)
    			return true;
    		
    		return isArithmeticArrayHelper(arr, 1, arr[1] - arr[0]);
    	}
    	
    	//פונקציית עזר עבור התרגיל מעל
    	public static boolean isArithmeticArrayHelper(int[] arr, int index, int distance)
    	{
    		if (index == arr.length)
    			return true;
    		
    		if (arr[index] - arr[index - 1] != distance)
    			return false;
    		
    		return isArithmeticArrayHelper(arr, index + 1, distance);
    	}
    	
    	/*
    	 * ****************************LIST AND QUEUE****************************************
    	 */
    	
    	//הפעולה תעתיק את הרשימה הנקלטת ותחזיר רשימה חדשה
    	public static List<Integer> copyList(List<Integer> list1)
    	{
    		List<Integer> list2 = new List<Integer>();
    		Node<Integer> pos1 = list1.getFirst();
    		Node<Integer> pos2 = list2.getFirst();
    		
    		while (pos1 != null)
    		{
    			pos2 = list2.insert(pos2, pos1.getInfo());
    			pos1 = pos1.getNext();
    		}
    		return list2;
    	}
    	
    	//הפעולה תעתיק את התור הנקלט ותחזיר תור חדש, מבלי לשנות את התור שנקלט
    	public static Queue<Integer> copyQueue(Queue<Integer> q)
    	{
    		Queue<Integer> temp = new Queue<Integer>();
    		Queue<Integer> q2 = new Queue<Integer>();
    		
    		while (!q.isEmpty())
    		{
    			temp.insert(q.head());
    			q2.insert(q.remove());
    		}
    		
    		while (!temp.isEmpty())
    			q.insert(temp.remove());
    		
    		return q2;
    	}
    	
    	//הפעולה מקבלת רשימה ומחזירה את סכום איבריה
    	public static int sumOfList(List<Integer> list)
    	{
    		if (list.isEmpty())
    			return 0;
    		
    		List<Integer> newList = copyList(list);
    		newList.remove(newList.getFirst());
    		
    		return list.getFirst().getInfo() + sumOfList(newList);
    	}
    	
    	//הפעולה תחזיר את מספר הפעמים שהמספר הופיע ברשימה
    	public static int numberOfTimesItShowed(List<Integer> list, int num)
    	{
    		if (list.isEmpty())
    			return 0;
    		
    		List<Integer> newList = copyList(list);
    		newList.remove(newList.getFirst());
    		
    		if (list.getFirst().getInfo() == num)
    			return 1 + numberOfTimesItShowed(newList, num);
    		
    		return numberOfTimesItShowed(newList, num);
    	}
    	
    	/*
    	 * ****************************BINARY TREES****************************************
    	 */
    	
    	//הפעולה תחזיר אמת אם העץ הוא עץ עלה
    	public static boolean isLeafy(BinTreeNode<Integer> bt)
    	{
    		return bt.getLeft() == null && bt.getRight() == null;
    	}
    	
    	//הפעולה תדפיס את העץ
    	public static void printTree(BinTreeNode<Integer> bt)
    	{
    		System.out.println(bt);
    		
    		if (bt.getLeft() != null)
    			printTree(bt.getLeft());
    		if (bt.getRight() != null)
    			printTree(bt.getRight());
    	}
    	
    	//הפעולה תקלוט ערכים לעץ
    	public static void scanTree(BinTreeNode<Integer> bt)
    	{
    		java.util.Scanner input = new java.util.Scanner(System.in);
    		System.out.println("Enter the info:");
    		bt.setInfo(input.nextInt());
    		
    		if (bt.getLeft() != null)
    			scanTree(bt.getLeft());
    		if (bt.getRight() != null)
    			scanTree(bt.getRight());
    	}
    	
    	//הפעולה תחזיר את מספר הצמתים בעץ
    	public static int numberOfNodes(BinTreeNode<Integer> bt)
    	{
    		if (isLeafy(bt))
    			return 1;
    		
    		int left = 0;
    		int right = 0;
    		
    		if (bt.getLeft() != null)
    			left = numberOfNodes(bt.getLeft());
    		if (bt.getRight() != null)
    			right = numberOfNodes(bt.getRight());
    		
    		return left + right + 1;
    	}
    	
    	//הפעולה תחזיר את מספר העלים בעץ
    	public static int numberOfLeaves(BinTreeNode<Integer> bt)
    	{
    		if (isLeafy(bt))
    			return 1;
    		
    		int left = 0;
    		int right = 0;
    		
    		if (bt.getLeft() != null)
    			left = numberOfLeaves(bt.getLeft());
    		if (bt.getRight() != null)
    			right = numberOfLeaves(bt.getRight());
    		
    		return left + right;
    	}
    	
    	//הפעולה תחזיר את מספר הרמות בעץ
    	public static int numberOfLevels(BinTreeNode<Integer> bt)
    	{
    		if (bt == null || isLeafy(bt))
    			return 0;
    		
    		int left = 0;
    		int right = 0;
    		
    		if (bt.getLeft() != null)
    			left = 1 + numberOfLevels(bt.getLeft());
    		if (bt.getRight() != null)
    			right = 1 + numberOfLevels(bt.getRight());
    		
    		return Math.max(left, right);
    	}
    	
    	//הפעולה תחזיר את סכום הצמתים בעץ
    	public static int sumOfNodes(BinTreeNode<Integer> bt)
    	{
    		if (bt == null)
    			return 0;
    		if (isLeafy(bt))
    			return bt.getInfo();
    		
    		int left = bt.getInfo();
    		int right = bt.getInfo();
    		
    		if (bt.getLeft() != null)
    			left = sumOfNodes(bt.getLeft());
    		if (bt.getRight() != null)
    			right = sumOfNodes(bt.getRight());
    		
    		return left + right + bt.getInfo();
    	}
    	
    	//הפעולה תחזיר את המספר הגדול ביותר בעץ
    	public static int getMax(BinTreeNode<Integer> bt)
    	{
    		if (isLeafy(bt))
    			return bt.getInfo();
    		
    		int left = bt.getInfo();
    		int right = bt.getInfo();
    		
    		if (bt.getLeft() != null)
    			left = getMax(bt.getLeft());
    		if (bt.getRight() != null)
    			right = getMax(bt.getRight());
    		
    		return Math.max(bt.getInfo(), Math.max(left, right));
    	}
    	
    	//הפעולה תחזיר את מספר הצמתים ברמה שהעוברה כפרמטר
    	public static int numberOfNodesOnLevel(BinTreeNode<Integer> bt, int level)
    	{
    		return numberOfNodesOnLevel(bt, level, 0);
    	}
    	
    	public static int numberOfNodesOnLevel(BinTreeNode<Integer> bt, int level, int currentLevel)
    	{
    		if (bt == null)
    			return 0;
    		if (level == currentLevel)
    			return 1;
    		
    		int left = numberOfNodesOnLevel(bt.getLeft(), level, currentLevel+1);
    		int right = numberOfNodesOnLevel(bt.getRight(), level, currentLevel+1);
    		return left + right;
    	}
    	
    	//הפעולה תחזיר אמת אם המספר נמצא בעץ
    	public static boolean isInTree(BinTreeNode<Integer> bt, int number)
    	{
    		if (isLeafy(bt))
    			return bt.getInfo() == number;
    		
    		boolean left = false;
    		boolean right = false;
    		
    		if (bt.getLeft() != null)
    			left = isInTree(bt.getLeft(), number);
    		if (bt.getRight() != null)
    			right = isInTree(bt.getRight(), number);
    		
    		return left || right || bt.getInfo() == number;
    	}
    	
    	//הפעולה תחזיר אמת אם העץ הוא עץ מלא
    	public static boolean isFull(BinTreeNode<Integer> bt)
    	{
    		if (bt.getLeft() == null || bt.getRight() == null)
    			return false;
    
    		return numberOfLeaves(bt.getLeft()) == numberOfLeaves(bt.getRight()) &&
    			numberOfLevels(bt.getLeft()) == numberOfLevels(bt.getRight());
    	}
    	
    	//הפעולה תחזיר את מספר הפעמים שהמספר הופיע בעץ
    	public static int count(BinTreeNode<Integer> bt, int number)
    	{
    		if (bt == null)
    			return 0;
    		
    		if (bt.getInfo() == number)
    			return 1 + count(bt.getLeft(), number) + count(bt.getRight(), number);
    		else
    			return count(bt.getLeft(), number) + count(bt.getRight(), number);
    	}
    	
    	//עץ בינארי יקרא שווה בנים אם הוא עלה או שערך השורש שלו שווה לסכום ערכי בניו וגם כל אחד מבניו הוא עץ שווה בנים.
    	//תרגיל לא ברור >_>
    	public static boolean equalSons(BinTreeNode<Integer> bt)
    	{
    		if (isLeafy(bt))
    			return true;
    		
    		if (bt.getLeft() == null || bt.getRight() == null)
    			return false;
    		
    		if (bt.getInfo() != bt.getLeft().getInfo() + bt.getRight().getInfo())
    			return false;
    		
    		return equalSons(bt.getLeft()) && equalSons(bt.getRight());
    	}
    	
    	//הפעולה תחזיר אמת אם העץ הוא עץ יורד.
    	//עץ יורד הוא עץ שכל ערכי האבות קטנים מערכי הבנים.
    	public static boolean downTree(BinTreeNode<Integer> bt)
    	{
    		if (bt == null || isLeafy(bt))
    			return true;
    		
    		if (bt.getLeft() != null && bt.getInfo() <= bt.getLeft().getInfo())
    			return false;
    		if (bt.getRight() != null && bt.getInfo() <= bt.getRight().getInfo())
    			return false;
    		
    		return downTree(bt.getLeft()) && downTree(bt.getRight());
    	}
    	
    	//הפעולה מחזירה אמת אם העץ הוא עץ מוזניים.
    	//עץ מוזניים הוא עץ שסכום העץ השמאלי שווה לסכום העץ הימני.
    	public static boolean scaleTree(BinTreeNode<Integer> bt)
    	{
    		if (bt == null)
    			return false;
    			
    		if (isLeafy(bt))
    			return true;
    		
    		if (bt.getLeft() == null)
    			if (bt.getInfo() != bt.getRight().getInfo())
    				return false;
    		
    		if (bt.getRight() == null)
    			if (bt.getInfo() != bt.getLeft().getInfo())
    				return false;
    		
    		if (bt.getLeft() != null && bt.getRight() != null && 
    				bt.getInfo() != bt.getLeft().getInfo() + bt.getRight().getInfo())
    			return false;
    		
    		return scaleTree(bt.getLeft()) && scaleTree(bt.getRight());
    	}
    	
    	//עץ פירמידה בגובה אייץ הוא עץ בינארי מלא המכיל מספרים שלמים,
    	//כך שערך כל צומת בעץ הוא גובהו.
    	public static boolean pyramidTree(BinTreeNode<Integer> bt, int h)
    	{
    		if (bt == null || isLeafy(bt) && bt.getInfo() == h)
    			return true;
    		
    		if (bt.getLeft() == null || bt.getRight() == null)
    			return false;
    		
    		if (bt.getInfo() != h)
    			return false;
    		
    		return pyramidTree(bt.getLeft(), h + 1) && pyramidTree(bt.getRight(), h + 1);
    	}
    	
    	//הפעולה מקבלת עץ ומחזירה עץ חדש עם אותם ערכים
    	public static BinTreeNode<Integer> copyTree(BinTreeNode<Integer> bt)
    	{
    		if (bt == null)
    			return null;
    		
    		BinTreeNode<Integer> newTree = new BinTreeNode<Integer>(bt.getInfo());
    		
    		newTree.setLeft(copyTree(bt.getLeft()));
    		newTree.setRight(copyTree(bt.getRight()));
    		
    		return newTree;
    	}
    	
    	//הפעולה תחזיר את ההורה של הילד, שהוא אחד מצמתיו של העץ BT
    	//NULL או שהפעולה תחזיר
    	//אם הילד הוא שורש העץ
    	public static BinTreeNode<Integer> parent(BinTreeNode<Integer> bt, BinTreeNode<Integer> child)
    	{
    		if (bt == null)
    			return null;
    		
    		if (bt.getLeft() == child || bt.getRight() == child)
    			return bt;
    		
    		if (parent(bt.getLeft(), child) == bt.getLeft())
    			return bt.getLeft();
    		
    		if (parent(bt.getRight(), child) == bt.getRight())
    			return bt.getRight();
    		
    		return null;
    	}
    	
    	//הפעולה מקבלת שני עצים ומחזירה אמת אם העצים דומים.
    	//עצים דומים הם עצים שהמבנה הפנימי שלהם, כלומר סדר הצמתים בתוך כל עץ, זהה
    	public static boolean isAlike(BinTreeNode<Integer> bt1, BinTreeNode<Integer> bt2)
    	{
    		if (bt1 == null && bt2 == null)
    			return true;
    		
    		if (bt1 == null && bt2 != null || (bt1 != null && bt2 == null))
    				return false;
    		
    		return isAlike(bt1.getLeft(), bt2.getLeft()) && isAlike(bt1.getRight(), bt2.getRight());
    	}
    נערך לאחרונה על ידי Hurricane, 13-05-2009 בשעה 16:52
    אהבתי sivan1233210, זיו, Weirdo, yinon, Mor_S and 5 others אהב \ אהבו את התגובה
     
    Jello!
    אפליקציה חדשה וממכרת בטירוף לאנדרואיד!



    המדריכים שכתבתי. לכניסה לחצו עליי

  2. #2
    משתמש רשום משתמש מתחיל

    פרטי משתמש

    ברירת מחדל

    וואו איזה מכרה זהב !!! תודה,בהצלחה!

  3. #3
    משתמש רשום משתמש מתחיל

    פרטי משתמש

    ברירת מחדל

    תודה ענקית!

  4. #4
    הסמל האישי שלHurricane אסיסטנט חבר Emath בכיר

    פרטי משתמש

    ברירת מחדל

    הוספתי עוד 4 פעולות בעצים בינאריים!
    Jello!
    אפליקציה חדשה וממכרת בטירוף לאנדרואיד!



    המדריכים שכתבתי. לכניסה לחצו עליי

  5. #5
    משתמש רשום חבר Emath מתקדם

    פרטי משתמש

    ברירת מחדל

    מלך!! למרות שאני לא ניגש לזה השנהף אני שומר את זה לשנה הבאה! :d
    תודה!

  6. #6
    הסמל האישי שלאריאל מנהל כללי חבר Emath בכיר

    פרטי משתמש

    ברירת מחדל

    נחמד מאוד, שמתי בנעוצים !

  7. #7
    משתמש רשום חבר Emath מתקדם

    פרטי משתמש

    ברירת מחדל

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

  8. #8
    משתמש רשום

    פרטי משתמש

    ברירת מחדל

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

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

  9. #9
    משתמש רשום משתמש מתחיל

    פרטי משתמש

    ברירת מחדל

    תודה!

מידע אודות האשכול הנוכחי

Users Browsing this Thread

כרגע 1 משתמשים צופים באשכול זה. (0 חברים ו 1 אורחים )

אשכולות דומים

  1. שאלה (יסודות מדעי המחשב)
    ע"י YaelTz בפורום : JAVA לתיכון
    תגובות: 0
    הודעה אחרונה: 29-04-2009, 16:27
  2. אולימפידת מדעי המחשב
    ע"י nirgt בפורום : דיבורים
    תגובות: 8
    הודעה אחרונה: 19-02-2009, 22:02
  3. עבור מיכאל
    ע"י risto בפורום : מכניקה
    תגובות: 1
    הודעה אחרונה: 23-11-2008, 19:35
  4. תגובות: 2
    הודעה אחרונה: 22-10-2008, 09:41
  5. מדעי המחשב
    ע"י sivan1233210 בפורום : דיבורים
    תגובות: 2
    הודעה אחרונה: 18-09-2008, 16:52

ביקרו באשכול זה : 6

הרשאות

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

לכל שאלה ניתן ליצור איתנו קשר
הצטרפו אלינו