‫هﻨﺪﺳﺔ ﻣﻌﻠﻮﻣﺎﺗﻴﺔ‬

‫اﻟﺴﻨﺔ اﻟﺜﺎﻟﺜﺔ‬
‫ﺑﺮﻣﺠﺔ ﻣﺘﻘﺪﻣﺔ ) ‪(٢‬‬
‫اﻟﻔﺼﻞ اﻟﺜﺎﻧﻲ‬
‫)‪(٢٠١٣-٢٠١٢‬‬
‫اﻟﻤﺤﺎﺿﺮة )‪(٤‬‬
‫اﻟ ﺎﺿ ة‬
‫د‪ .‬ﻣﻬﻨﺪ أﺣﻤﺪ رﺟﺐ‬

‫ﺍﻟﺮﺍﺑﻊ‬
‫ﺍﻟﻔﺼﻞﻞ ﺍﻟ ﺍ‬
‫ﺍﻟﻔ‬
‫ﺍﳉﻤﻞ ﺍﶈﺮﻓﻴﺔ ﻭﺍﳌﺼﻔﻮﻓﺎﺕ‬

‫‪1‬‬
 ‫هﻨﺪﺳﺔ ﻣﻌﻠﻮﻣﺎﺗﻴﺔ‬
‫اﻟﺴﻨﺔ اﻟﺜﺎﻟﺜﺔ‬
‫ﺑﺮﻣﺠﺔ ﻣﺘﻘﺪﻣﺔ ) ‪(٢‬‬ ‫‪ .1-4‬ﺍﻟﺘﻌﺎﻣﻞ ﻣﻊ ﺍﳉﻤﻞ ﺍﶈﺮﻓﻴﺔ ‪.‬‬
‫اﻟﻔﺼﻞ اﻟﺜﺎﻧﻲ‬
‫)‪(٢٠١٣-٢٠١٢‬‬
‫اﻟﻤﺤﺎﺿﺮة )‪(٤‬‬
‫اﻟ ﺎﺿ ة‬
‫د‪ .‬ﻣﻬﻨﺪ أﺣﻤﺪ رﺟﺐ‬
‫ﺍﻷﺷﻜﺎﻝ‬
‫ﺷﻴﻮﻋﺎ ﻭﻻ ﺗﻌﺪ ﻣﻦ ﻷ ﻜ‬
‫ﹰ‬ ‫ﺃﺷﻜﺎﻝ ﺍﻟﺒﻴﺎﻧﺎﺕ ﺍﻟﻐﺮﺿﻴ‪‬ﺔ‬
‫‪‬ﺗ‪‬ﻌ ‪‬ﺪ ﺍﳉﻤﻞ ﺍﶈﺮﻓﻴﺔ )‪ (Strings‬ﺃﺃﻛﺜﺮ ﺃ ﻜ‬
‫ﺍﻷﺳﺎﺳﻴﺔ ﰲ ﻟﻐﺔ ﺍﳉﺎﻓﺎ ‪ .‬ﻭﻛﻞ ﻣﺘﺤﻮﻝ ﻳ‪‬ﻌﺮ‪‬ﻑ ﻣﻦ ﺍﻟﺸﻜﻞ )‪ (String‬ﻫﻮ ﻣﺘﺤﻮﻝ ﻳﺆﺷﺮ ﻋﻠﻰ ﻏﺮﺽ‬
‫ﻣﻦ ﺍﻟﺼﻒ )‪ . (String‬ﻭﻟﻠﺼﻒ )‪ (String‬ﳎﻤﻮﻋﺔ ﻣﻦ ﺍﻟﺪﻭﺍﻝ ﻭﺍﻟﻄﺮﺍﺋﻖ ﺍﻟﱵ ﺗﻔﻴﺪ ﰲ ﻣﻌﺎﳉﺔ ﺍﳉﻤﻞ‬
‫ﺍﶈﺮﻓﻴﺔ ﻛﻤﺎ ﻫﻮ ﻣﻮﺿﺢ ﰲ ﺍﳉﺪﻭﻝ ﺍﻵﰐ ‪:‬‬

‫‪Method‬‬ ‫‪Description‬‬
‫)‪char charAt(int‬‬ ‫ﺩﺍﻟﺔ ﺗﻌﻴﺪ ﳏﺮﻓﹰﺎ ﰲ ﻣﻜﺎﻥ ﳏﺪﺩ ﻣﻦ ﺍﳉﻤﻠﺔ‬
‫ﳌﻘﺎﺭﻧﺔ ﲨﻠﺘﲔ‪ ،‬ﻭﺗﻌﻴﺪ ) ‪ (-1‬ﺇﺫﺍ ﻛﺎﻧﺖ ﺍﳉﻤﻠﺔ ﺍﻷﻭﱃ‬
‫)‪int compareTo(String‬‬ ‫ﺗﺴﺒﻖ ﺍﻟﺜﺎﻧﻴﺔ ﻭ )‪ (0‬ﺇﺫﺍ ﺗﻄﺎﺑﻘﺖ ﺍﳉﻤﻠﺘﺎﻥ ﻭ )‪ (1‬ﰲ ﺣﺎﻝ‬
‫ﺍﻟﻌﻜﺲ‪.‬‬
‫)‪i compareToIgnoreCase(String‬‬
‫‪int‬‬ ‫‪TI‬‬ ‫) ‪C (S i‬‬ ‫ﺍﻟﺴﺎﺑﻘﺔ‬
‫ﻟﻠﺪﺍﻟﺔ ﺍﻟ ﺎ ﻘ‬
‫ﻣﺸﺎ‪‬ﺔ ﻟﻠ ﺍﻟ‬
‫ﺎ‬
‫)‪boolean contains(CharSequence‬‬ ‫ﺩﺍﻟﺔ ﺗﻌﻴﺪ )‪ (true‬ﺇﺫﺍ ﺗﻀﻤﻨﺖ ﺍﳉﻤﻠﺔ ﺍﻟﻮﺳﻴﻂ‬
‫)‪boolean endsWith(String‬‬ ‫ﺩﺍﻟﺔ ﺗﻌﻴﺪ )‪ (true‬ﺇﺫﺍ ﺍﻧﺘﻬﺖ ﺍﳉﻤﻠﺔ ﺑﺎﻟﻮﺳﻴﻂ‬
‫)‪boolean equals(String‬‬
‫)‪q ( g‬‬ ‫ﻭﺍﻟﻮﺳﻴﻂ‬
‫ﺗﻄﺎﺑﻘﺖ ﺍﳉﻤﻠﺔ ﻭ ﻮ ﻴ‬
‫ﺗﻌﻴﺪ ))‪ ((true‬ﺇﺇﺫﺍ ﺑ‬
‫ﺩﺍﻟﺔ ﻴ‬
‫)‪boolean equalsIgnoreCase(String‬‬ ‫ﻣﺸﺎ‪‬ﺔ ﻟﻠﺪﺍﻟﺔ ﺍﻟﺴﺎﺑﻘﺔ‬
‫)‪int indexOf(char‬‬ ‫ﺗﻌﻴﺪ ﺗﺮﺗﻴﺐ ﺍﶈﺮﻑ ﰲ ﺍﳉﻤﻠﺔ ﻭ)‪ (-1‬ﰲ ﺣﺎﻝ ﻋﺪﻡ ﻭﺟﻮﺩﻩ‬
‫ﺩﺍﻟﺔ ﺗﻌﻴﺪ ﺗﺮﺗﻴﺐ ﺍﳉﻤﻠﺔ ﺍﻟﻮﺳﻴﻂ ﻭ )‪ (-1‬ﰲ ﺣﺎﻝ ﻋﺪﻡ‬
‫)‪int indexOf(String‬‬
‫ﻭﺟﻮﺩﻩ‬
‫ﺩﺍﻟﺔ ﺗﻌﻴﺪ ﺗﺮﺗﻴﺐ ﲨﻠﺔ ﺍﻟﻮﺳﻴﻂ ﺑﺪﺀﹰﺍ ﻣﻦ ﺍﻟﻮﺳﻴﻂ ﺍﻟﺜﺎﱐ‬
‫)‪int indexOf(String, int start‬‬
‫ﻭ)‪ (-1‬ﰲ ﺣﺎﻝ ﻋﺪﻡ ﻭﺟﻮﺩﻩ‬
‫)‪ (-1‬ﰲ‬
‫)‪( 1‬‬ ‫ﺍﻟﻮﺳﻴﻂ ﻭ‬
‫ﻑ ﺍﻟ ﻂ‬ ‫ﺍﻷﺧﲑ ﻟﻠﻟﻠﻤﺤﺮﻑ‬
‫ﺍﻟﺘﺮﺗﻴﺐ ﺍﻷﺧ‬
‫ﺩﺍﻟﺔ ﺗﺗﻌﻴﺪﺪ ﺍﻟﺘ ﺗ‬
‫)‪int lastIndexOf(char‬‬
‫ﺣﺎﻝ ﻋﺪﻡ ﻭﺟﻮﺩﻩ‬

‫‪2‬‬
 ‫هﻨﺪﺳﺔ ﻣﻌﻠﻮﻣﺎﺗﻴﺔ‬
‫اﻟﺴﻨﺔ اﻟﺜﺎﻟﺜﺔ‬ ‫‪Method‬‬ ‫‪Description‬‬
‫ﺑﺮﻣﺠﺔ ﻣﺘﻘﺪﻣﺔ ) ‪(٢‬‬ ‫ﺩﺍﻟﺔ ﺗﻌﻴﺪ ﺍﻟﺘﺮﺗﻴﺐ ﺍﻷﺧﲑ ﻟﻠﺠﻤﻠﺔ ﺍﻟﻮﺳﻴﻂ ﻭ )‪ (-1‬ﰲ‬
‫اﻟﻔﺼﻞ اﻟﺜﺎﻧﻲ‬ ‫)‪int lastIndexOf(String‬‬
‫ﺣﺎﻝ ﻋﺪﻡ ﻭﺟﻮﺩﻩ‬
‫)‪(٢٠١٣-٢٠١٢‬‬
‫اﻟﻤﺤﺎﺿﺮة )‪(٤‬‬
‫اﻟ ﺎﺿ ة‬ ‫ﺑﺪﺀﺍ ﻣﻦ‬
‫ﺍﻟﻮﺳﻴﻂ ﺪ ﺍﹰ‬
‫ﻟﻠﺠﻤﻠﺔ ﺍﻟ ﻂ‬
‫ﺍﻷﺧﲑ ﻟﻠ ﻠﺔ‬
‫ﺍﻟﺘﺮﺗﻴﺐ ﺍﻷﺧ‬
‫ﺩﺍﻟﺔ ﺗﺗﻌﻴﺪﺪ ﺍﻟﺘ ﺗ‬
‫ﺍﻟﺔ‬
‫د‪ .‬ﻣﻬﻨﺪ أﺣﻤﺪ رﺟﺐ‬
‫)‪int lastIndexOf(String, int‬‬
‫ﺍﻟﻮﺳﻴﻂ ﺍﻟﺜﺎﱐ ﻭ)‪ (-1‬ﰲ ﺣﺎﻝ ﻋﺪﻡ ﻭﺟﻮﺩﻩ‬
‫)(‪int length‬‬ ‫ﺩﺍﻟﺔ ﺗﻌﻴﺪ ﻃﻮﻝ ﺍﳉﻤﻠﺔ‬
‫ﺩﺍﻟﺔ ﺗﻌﻴﺪ ﲨﻠﺔ ﺟﺪﻳﺪﺓ ﺑﻌﺪ ﺇﺑﺪﺍﻝ ﻛﻞ ﳏﺮﻑ ﻳﻄﺎﺑﻖ‬
‫)‪String replace(char, char‬‬
‫ﺍﻷﻭﻝ ﲟﺤﺮﻑ ﺍﻟﻮﺳﻴﻂ ﺍﻟﺜﺎﱐ‬
‫ﺍﻟﻮﺳﻴﻂ ﻷ‬
‫ﺩﺍﻟﺔ ﺗﻌﻴﺪ ﲨﻠﺔ ﺟﺪﻳﺪﺓ ﺑﻌﺪ ﺇﺑﺪﺍﻝ ﻛﻞ ﲨﻠﺔ ﺟﺰﺋﻴﺔ‬
‫)‪String replaceAll(String old,String new‬‬ ‫ﺗﻄﺎﺑﻖ ﺍﻟﻮﺳﻴﻂ ﺍﻷﻭﻝ ﲜﻤﻠﺔ ﺟﺰﺋﻴﺔ ﺗﻄﺎﺑﻖ ﺍﻟﻮﺳﻴﻂ‬
‫ﺍﻟﺜﺎﱐ‬
‫ﺗﻌﻴﺪ ﲨﻠﺔ ﺟﺪﻳﺪﺓ ﺑﻌﺪ ﺇﺑﺪﺍﻝ ﺍﳉﻤﻠﺔ ﺍﳉﺰﺋﻴﺔ ﺍﻷﻭﱃ‬
‫)‪String replaceFirst(String old, String new‬‬ ‫ﺍﳌﻄﺎﺑﻘﺔ ﻟﻠﻮﺳﻴﻂ ﺍﻷﻭﻝ ﺑﺎﳉﻤﻠﺔ ﺍﳉﺰﺋﻴﺔ ﺍﳌﻄﺎﺑﻘﺔ‬
‫ﻟﻠﻮﺳﻴﻂ ﺍﻟﺜﺎﱐ‬
‫)‪String[] split(String‬‬ ‫ﺩﺍﻟﺔ ﺗﻘﺴﻴﻢ ﺍﳉﻤﻠﺔ ﺇﱃ ﻣﺼﻔﻮﻓﺔ ﻣﻦ ﺍﳉﻤﻞ ﺍﳉﺰﺋﻴﺔ‬
‫)‪boolean startsWith(String‬‬ ‫ﺩﺍﻟﺔ ﺗﻌﻴﺪ )‪ (true‬ﺇﺫﺍ ﺍﺑﺘﺪﺃﺕ ﺍﳉﻤﻠﺔ ﺑﺎﳉﻤﻠﺔ ﺍﻟﻮﺳﻴﻂ‬
‫ﺩﺍﻟﺔ ﺗﻌﻴﺪ )‪ (true‬ﺇﺫﺍ ﺍﺑﺘﺪﺃﺕ ﺍﳉﻤﻠﺔ ﺑﺎﳉﻤﻠﺔ ﺍﻟﻮﺳﻴﻂ‬
‫)‪boolean startsWith(String, int‬‬
‫ﰲ ﻣﻜﺎﻥ ﳏﺪﺩ ﺑﺎﻟﻮﺳﻴﻂ ﺍﻟﺜﺎﱐ‬
‫ﱴ ‪‬ﺎﻳﺔ‬
‫ﺍﻟﻮﺳﻴﻂ ﺣﱴ‬
‫ﺗﺮﺗﻴﺒﻪ ﻮ‬
‫ﲟﺤﺮﻑ ﺮ‬
‫ﺩﺍﻟﺔ ﺗﻌﻴﺪ ﲨﻠﺔ ﺗﺒﺪﺃ ﺮ‬
‫)‪String substring(int‬‬
‫ﺍﳉﻤﻠﺔ‬
‫ﺩﺍﻟﺔ ﺗﻌﻴﺪ ﲨﻠﺔ ﺗﺒﺪﺃ ﲟﺤﺮﻑ ﺗﺮﺗﻴﺒﻪ ﺍﻟﻮﺳﻴﻂ ﺍﻷﻭﻝ‬
‫)‪String substring(int, int‬‬
‫ﺣﱴ ﺍﶈﺮﻑ ﺍﻟﺬﻱ ﺗﺮﺗﻴﺒﻪ ﺍﻟﻮﺳﻴﻂ ﺍﻟﺜﺎﱐ‬
‫)(‪char[] toCharArray‬‬ ‫ﺩﺍﻟﺔ ﺗﻌﻴﺪ ﺍﳉﻤﻠﺔ ﺇﱃ ﻣﺼﻔﻮﻓﺔ ﻣﻦ ﺍﶈﺎﺭﻑ‬
‫)(‪String toLowerCase‬‬ ‫ﺩﺍﻟﺔ ﺗﻌﻴﺪ ﺍﳉﻤﻠﺔ ﺇﱃ ﲨﻠﺔ ﻣﻜﺘﻮﺑﺔ ﲟﺤﺎﺭﻑ ﺻﻐﲑﺓ‬
‫)(‪String toString‬‬ ‫ﺩﺍﻟﺔ ﺗﻌﻴﺪ ﺍﳉﻤﻠﺔ ﺇﱃ ﲨﻠﺔ‬
‫)(‪String toUpperCase‬‬ ‫ﺩﺍﻟﺔ ﺗﻌﻴﺪ ﺍﳉﻤﻠﺔ ﺇﱃ ﲨﻠﺔ ﻣﻜﺘﻮﺑﺔ ﲟﺤﺎﺭﻑ ﻛﺒﲑﺓ‬
‫ﺍﳉﻤﻠﺔ‬
‫ﻣﻘﺪﻣﺔ ﺍﳉ ﻠ‬
‫ﻓﺮﺍﻏﺎﺕ ﻘ‬
‫ﺍﳉﻤﻠﺔ ﺑﺪﻭﻥﻥ ﻓ ﺍﻏﺎ‬
‫ﺩﺍﻟﺔ ﺗﻌﻴﺪ ﺍﳉ ﻠ‬
‫ﺍﻟ‬
‫)(‪String trim‬‬
‫ﻭ‪‬ﺎﻳﺘﻬﺎ‬
‫)‪String valueOf(primitiveType‬‬ ‫ﺩﺍﻟﺔ ﺗﻌﻴﺪ ﲨﻠﺔ ﻷﻱ ﺷﻜﻞ ﺃﺳﺎﺳﻲ‬
‫‪3‬‬
 ‫هﻨﺪﺳﺔ ﻣﻌﻠﻮﻣﺎﺗﻴﺔ‬
‫اﻟﺴﻨﺔ اﻟﺜﺎﻟﺜﺔ‬
(٢ ) ‫ﺑﺮﻣﺠﺔ ﻣﺘﻘﺪﻣﺔ‬
‫اﻟﻔﺼﻞ اﻟﺜﺎﻧﻲ‬
(٢٠١٣-٢٠١٢) ‫ ﺣﻴﺚ ﻳﻘﻮﻡ ﲝﺴﺎﺏ ﻋﺪﺩ‬، (String) ‫ﻭﻓﻴﻤﺎ ﻳﻠﻲ ﻣﺜﺎﻝ ﺑﺴﻴﻂ ﻳﻮﺿﺢ ﺍﺳﺘﺨﺪﺍﻡ ﺍﻟﺼﻒ‬
(٤) ‫اﻟﻤﺤﺎﺿﺮة‬
‫اﻟ ﺎﺿ ة‬
‫ ﻣﻬﻨﺪ أﺣﻤﺪ رﺟﺐ‬.‫د‬ : ‫ﺍﻷﺣﺮﻑ ﺍﻟﺼﻮﺗﻴﺔ ﰲ ﲨﻠﺔ ﳏﺮﻓﻴﺔ ﻳﺘﻢ ﺇﺩﺧﺎﳍﺎ ﻣﻦ ﻟﻮﺣﺔ ﺍﳌﻔﺎﺗﻴﺢ‬

import java.util.Scanner;
public class CountVowels
{
static Scanner sc = new Scanner(System.in);
public static void main(String[] args)
{
System.out.print("Enter a string: ");
String s = sc.nextLine();
int vowelCount = 0;
for (int i = 0; i < s.length(); i++)
{
char c = s.charAt(i);
if ( (c == ‘A’) || (c == ‘a’) ||
(c == ‘E’) || (c == ‘e’) ||
(c == ‘I’) || (c == ‘i’) ||
(c == ‘O’) || (c == ‘o’) ||
(c == ‘U’) || (c == ‘u’) )
vowelCount++;
}
System.out.println("That string contains "
+ vowelCount + " vowels.");
}
}

4
 ‫هﻨﺪﺳﺔ ﻣﻌﻠﻮﻣﺎﺗﻴﺔ‬
‫اﻟﺴﻨﺔ اﻟﺜﺎﻟﺜﺔ‬
‫ﺑﺮﻣﺠﺔ ﻣﺘﻘﺪﻣﺔ ) ‪(٢‬‬
‫اﻟﻔﺼﻞ اﻟﺜﺎﻧﻲ‬ ‫ﻣﻼﺣﻈﺔ ) ‪ : (1-4‬ﻳﻌﺪ ﺻﻒ ﺍﳉﻤﻞ ﺍﶈﺮﻓﻴﺔ )‪ (String‬ﻣﻦ ﺍﻟﺼﻔﻮﻑ ﺍﳌﺘﻤﻴﺰﺓ ﰲ ﻟﻐﺔ ﺍﳉﺎﻓﺎ‪،‬‬
‫)‪(٢٠١٣-٢٠١٢‬‬
‫اﻟﻤﺤﺎﺿﺮة )‪(٤‬‬
‫اﻟ ﺎﺿ ة‬ ‫ﻳﻀﻔﻲ‬
‫ﺍﺽ ﺟﺪﻳﺪﺓ ﳑﺎ ﻳﻀﻔ‬
‫ﺃﻏﺮﺍﺽ‬‫‪‬ﺪ ﻭﺑﻨﺎﺀ ﺃﻏ‬
‫ﺗﺸﻴﻴﺪ‬
‫ﺩﻭﻣﺎ ﺗﺸ‬
‫ﺃﻏﺮﺍﺿﻪ ﻏﲑ ﻗﺎﺑﻠﺔ ﻟﻠﺘﻌﺪﻳﻞ ﻭﺃﻱ ﻣﻌﺎﳉﺔ ﳍﺎ ﺗﺘﻄﻠﺐ ﺩﻭﻣﺎﹰ‬
‫ﺇﻻ ﺃﻥ ﺃﻏ ﺍﺿﻪ‬
‫د‪ .‬ﻣﻬﻨﺪ أﺣﻤﺪ رﺟﺐ‬
‫ﻋﻠﻰ ﺻﻒ ﺍﳉﻤﻞ ﺍﶈﺮﻓﻴﺔ )‪ (String‬ﺻﻔﺔ ﺿﻌﻒ ﺍﻟﻔﻌﺎﻟﻴﺔ ‪ .‬ﻭﻗﺪ ﺍﻗﺘﺮﺣﺖ ﰲ ﻟﻐﺔ ﺍﳉﺎﻓﺎ ﺻﻔﺎﻥ‬
‫)‪ . (StringBuilder, StringBuffer‬ﺍﻟﺼﻔﺎﻥ‬ ‫ﻣﺸﺎ‪‬ﺎﻥ ﻟﻠﺼﻒ )‪ (String‬ﳊﻞ ﻫﺬﻩ ﺍﳌﺸﻜﻠﺔ ﻭﳘﺎ‬
‫ﺐ ﻮ‬
‫ﺍﻟﺘﻨﻮﻳﻪ ﺃﻥ ﺍﻟﺼﻒ‬ ‫ﻭﺍﻟﻄﺮﺍﺋﻖﻖ ‪ ،‬ﻭﻭﳚﺐ‬
‫ﺍﻟﺪﻭﺍﻝ ﻭ ﺮ‬
‫ﳎﻤﻮﻋﺔ ﻭﻭﺍﺣﺪﺓ ﻣﻦﻦ ﻭ‬
‫ﺍﻟﺴﺎﺑﻘﺎﻥ ﻣﺘﺸﺎ‪‬ﺎﻥ ﻭﻭﳝﺘﻠﻜﺎﻥ ﻮ‬
‫)‪ (StringBuilder‬ﺃﺿﻴﻒ ﻟﻠﺒﻴﺌﺔ ﺍﻟﱪﳎﻴﺔ )‪ (JDK 5‬ﻭﻫﻮ ﻏﲑ ﺁﻣﻦ ﻋﻨﺪ ﺍﺳﺘﺨﺪﺍﻣﻪ ﰲ ﺍﻟﺘﻄﺒﻴﻘﺎﺕ‬
‫ﺍﳌﺘﻀﻤﻨ‪‬ﺔ ﻟﻠﻤﺴﺎﻟﻚ ‪ .‬ﻭﻛﻞ ﻏﺮﺽ ﻣﻦ ﻫﺬﻳﻦ ﺍﻟﺼﻔﲔ ﻳﻘﻮﻡ ﲝﺠﺰ ﻣﻜﺎﻥ ﰲ ﺍﻟﺬﺍﻛﺮﺓ ﻳﺪﻋﻰ )‪(buffer‬‬
‫ﻟﻴﻀﻊ ﻓﻴﻪ ﺍﳉﻤﻠﺔ ﺍﶈﺮﻓﻴﺔ ‪ ،‬ﻭﳝﻜﻦ ﳍﺬﺍ )‪ (buffer‬ﺃﻥ ﻳﺰﺩﺍﺩ ﻋﻨﺪ ﺍﳊﺎﺟﺔ ﻭﺍﳌﻌﺎﳉﺔ ‪.‬‬

‫‪(String‬‬
‫‪(String,‬‬ ‫ﺍﺧﺘﻴﺎﺭ ﺍﻟﺼﻒ ﺍﳌﻨﺎﺳﺐ ﻣﻦ ﺑﲔ ﺍﻟﺼﻔﻮﻑ‬
‫ﺗﺴﺎﻋﺪﻙ ﰲ ﺍﺧﺘ ﺎﺭ‬
‫ﻤﺎ ﻳﻠﻳﻠﻲ ﻣﻼﺣﻈﺎﺕ ﺗ ﺎﻋﺪﻙ‬
‫ﻭﻓﻓﻴﻤﺎ‬
‫)‪:StringBuilder, StringBuffer‬‬

‫ﺍﺿﻪ ﻏﻏﲑ‬
‫ﺃﻏﺮﺍﺿﻪ‬
‫)‪ (String‬ﻷﻥ ﺃﻏ‬
‫ﺍﻟﺼﻒ ) ‪(St i‬‬
‫ﺍﺳﺘﺨﺪﻡ ﺍﻟ ﻒ‬
‫ﻋﻨﺪﻫﺎ ﺍ ﺘﺨﺪ‬
‫ﻳﻌﺪﻝ( ﻑ‬
‫ﻳﺘﻐﲑ )ﻟ)ﻟﻦ ‪ ‬ﺪ‪‬ﻝ(‬
‫ﺍﻟﻨﺺ ﻟﻟﻦ ﺘﻐ‬
‫‪-‬ﺇﺫﺍ ﻛﺎﻥ ﺍﻟﻨ‬
‫ﻗﺎﺑﻞﺓ ﻟﻠﺘﻌﺪﻳﻞ‪.‬‬
‫ﳑﻜﻦ ﻣﻦ ﺧﻼﻝ ﻣﺴﻠﻚ ﻭﺍﺣﺪ ﻓﻘﻂ ‪،‬‬
‫‪-‬ﺇﺫﺍ ﻛﺎﻥ ﺍﻟﻨﺺ ﳝﻜﻦ ﺃﻥ ﻳﺘﻐﲑ ﻭﻛﺎﻥ ﺍﻟﻮﺻﻮﻝ ﺇﻝﻩﻱ ﺍﹰ‬
‫ﻋﻨﺪﻫﺎ ﺍﺳﺘﺨﺪﻡ ﺍﻟﺼﻒ )‪.(StringBuilder‬‬
‫ﻑ‬
‫ﻋﻨﺪﻫﺎ‬
‫ﳑﻜﻦ ﻣﻦ ﺧﻼﻝ ﻋﺪﺓ ﻣﺴﺎﻟﻚ‪ ،‬ﻑ‬
‫‪-‬ﺇﺫﺍ ﻛﺎﻥ ﺍﻟﻨﺺ ﳝﻜﻦ ﺃﻥ ﻳﺘﻐﲑ ﻭﻛﺎﻥ ﺍﻟﻮﺻﻮﻝ ﺇﻝﻩﻱ ﹰﺍ‬
‫ﺍﺳﺘﺨﺪﻡ ﺍﻟﺼﻒ )‪.(StringBuffer‬‬

‫‪5‬‬
 ‫هﻨﺪﺳﺔ ﻣﻌﻠﻮﻣﺎﺗﻴﺔ‬ ‫‪Method‬‬ ‫‪Description‬‬
‫اﻟﺴﻨﺔ اﻟﺜﺎﻟﺜﺔ‬ ‫)‪append(primitiveType‬‬ ‫ﺩﺍﻟﺔ ﺗﻀﻴﻒ ﲨﻠﺔ ﺍﻟﺸﻜﻞ ﺍﻷﺳﺎﺳﻲ ﺇﱃ ‪‬ﺎﻳﺔ ﺍﳉﻤﻠﺔ‬ ‫‪-‬ﺍﳉﺪﻭﻝ ﺍﻵﰐ ﻳﻠﺨﺺ ﺃﻫﻢ ﺍﻟﺪﻭﺍﻝ ﻭﺍﻟﻄﺮﺍﺋﻖ ﺍﳌﺘﻮﻓﺮﺓ ﰲ ﻛﻞ ﻣﻦ ﺍﻟﺼﻔﲔ‬
‫ﺑﺮﻣﺠﺔ ﻣﺘﻘﺪﻣﺔ ) ‪(٢‬‬
‫اﻟﻔﺼﻞ اﻟﺜﺎﻧﻲ‬ ‫)‪append(Object‬‬ ‫ﺩﺍﻟﺔ ﺗﻀﻴﻒ ﲨﻠﺔ ﺍﻟﻐﺮﺽ ﺇﱃ ‪‬ﺎﻳﺔ ﺍﳉﻤﻠﺔ‬
‫)‪: (StringBuilder, StringBuffer‬‬
‫)‪(٢٠١٣-٢٠١٢‬‬ ‫)‪append(CharSequence‬‬ ‫ﺩﺍﻟﺔ ﺗﻀﻴﻒ ﳎﻤﻮﻋﺔ ﳏﺎﺭﻑ ﻛﺠﻤﻠﺔ ﺇﱃ ‪‬ﺎﻳﺔ ﺍﳉﻤﻠﺔ‬
‫اﻟﻤﺤﺎﺿﺮة )‪(٤‬‬
‫اﻟ ﺎﺿ ة‬
‫)(‪int capacity‬‬ ‫ﺩﺍﻟﺔ ﺗﻌﻴﺪ ﺣﺠﻢ ﺍﻟﻐﺮﺽ ﻣﻦ ﺍﻟﺼﻒ ‪StringBuilder‬‬
‫د‪ .‬ﻣﻬﻨﺪ أﺣﻤﺪ رﺟﺐ‬
‫)‪char charAt(int‬‬ ‫ﺩﺍﻟﺔ ﺗﻌﻴﺪ ﺍﶈﺮﻑ ﺍﻟﺬﻱ ﺗﺮﺗﻴﺒﻪ ﺍﻟﻮﺳﻴﻂ‬
‫)‪delete(int, int‬‬ ‫ﺩﺍﻟﺔ ﳊﺬﻑ ﳎﻤﻮﻋﺔ ﳏﺎﺭﻑ ﳏﺪﺩﺓ ﺑﺎﻟﻮﺳﻴﻄﲔ‬
‫)‪deleteCharAt(int‬‬ ‫ﺩﺍﻟﺔ ﳊﺬﻑ ﳏﺮﻑ ﺗﺮﺗﻴﺒﻪ ﺍﻟﻮﺳﻴﻂ‬
‫)‪ensureCapacity(int‬‬ ‫ﺩﺍﻟﺔ ﻟﺰﻳﺎﺩﺓ ﺣﺠﻢ ﺍﻟﻐﺮﺽ ﰲ ﺣﺎﻝ ﻛﻮﻧﻪ ﺃﻗﻞ ﻣﻦ ﺍﻟﻮﺳﻴﻂ‬
‫)‪int indexOf(String‬‬ ‫ﺩﺍﻟﺔ ﺗﻌﻴﺪ ﺗﺮﺗﻴﺐ ﺍﳉﻤﻠﺔ ﺍﻟﻮﺳﻴﻂ ﻭ)‪ (-1‬ﰲ ﺣﺎﻝ ﻋﺪﻡ ﻭﺟﻮﺩﻩ‬
‫ﻭ‪(-‬‬ ‫ﺩﺍﻟﺔ ﺗﻌﻴﺪ ﺗﺮﺗﻴﺐ ﺍﳉﻤﻠﺔ ﺑﺎﻟﻮﺳﻴﻂ ﺑﺪﺀﹰﺍ ﻣﻦ ﺍﻟﻮﺳﻴﻂ ﺍﻟﺜﺎﱐ‬
‫)‪int indexOf(String, int‬‬
‫)‪ 1‬ﰲ ﺣﺎﻝ ﻋﺪﻡ ﻭﺟﻮﺩﻩ‬
‫ﻣﻜﺎﻥ ﳏﺪﺩ ﺑﺎﻟﻮﺳﻴﻂ‬
‫ﺍﻷﺳﺎﺳﻲ ﰲ ﻜ‬
‫ﺍﻟﺸﻜﻞ ﻷ‬
‫ﺩﺍﻟﺔ ﻹﺩﺧﺎﻝ ﲨﻠﺔ ﻜ‬
‫)‪insert(int, primitiveType‬‬
‫ﺍﻷﻭﻝ‬
‫)‪insert(int, Object‬‬ ‫ﺩﺍﻟﺔ ﻹﺩﺧﺎﻝ ﲨﻠﺔ ﺍﻟﻐﺮﺽ ﰲ ﻣﻜﺎﻥ ﳏﺪﺩ ﺑﺎﻟﻮﺳﻴﻂ ﺍﻷﻭﻝ‬
‫ﺩﺍﻟﺔ ﻹﺩﺧﺎﻝ ﳎﻤﻮﻋﺔ ﳏﺎﺭﻑ ﻛﺠﻤﻠﺔ ﰲ ﻣﻜﺎﻥ ﳏﺪﺩ ﺑﺎﻟﻮﺳﻴﻂ‬
‫)‪insert(int, CharSequence‬‬
‫ﺍﻷ ﻝ‬
‫ﺍﻷﻭﻝ‬
‫ﺩﺍﻟﺔ ﺗﻌﻴﺪ ﺍﻟﺘﺮﺗﻴﺐ ﺍﻷﺧﲑ ﻟﻠﺠﻤﻠﺔ ﺍﻟﻮﺳﻴﻂ ﻭ )‪ (-1‬ﰲ ﺣﺎﻝ ﻋﺪﻡ‬
‫)‪int lastIndexOf(String‬‬
‫ﻭﺟﻮﺩﻩ‬
‫ﺩﺍﻟﺔ ﺗﻌﻴﺪ ﺍﻟﺘﺮﺗﻴﺐ ﺍﻷﺧﲑ ﻟﻠﺠﻤﻠﺔ ﺍﻟﻮﺳﻴﻂ ﺑﺪﺀﹰﺍ ﻣﻦ ﺍﻟﻮﺳﻴﻂ‬
‫)‪int lastIndexOf(String, int‬‬
‫ﻭﺟﻮﺩﻩ‬
‫)‪ ((-1‬ﰲ ﺣﺎﻝﻝ ﻋﺪﻡﻡ ﻭﺟﻮ‬
‫ﱐ ﻭ)‪1‬‬
‫ﺍﻟﺜﺎﱐ‬
‫)(‪int length‬‬ ‫ﺩﺍﻟﺔ ﺗﻌﻴﺪ ﻃﻮﻝ ﺍﳉﻤﻠﺔ‬
‫ﺩﺍﻟﺔ ﺗﻌﻴﺪ ﲨﻠﺔ ﺟﺪﻳﺪﺓ ﺑﻌﺪ ﺇﺑﺪﺍﻝ ﲨﻠﺔ ﺍﶈﺎﺭﻑ ﺍﶈﺪﺩﺓ‬
‫)‪replace(int, int, String‬‬
‫ﺑﺎﻟﻮﺳﻴﻄﲔ ﺍﻷﻭﻝ ﻭﺍﻟﺜﺎﱐ ﲜﻤﻠﺔ ﺍﻟﻮﺳﻴﻂ ﺍﻟﺜﺎﻟﺚ‬
‫)(‪reverse‬‬ ‫ﺩﺍﻟﺔ ﺗﻌﻴﺪ ﲨﻠﺔ ﺑﺸﻜﻞﻞ ﻣﻌﻜﻮﺱ‬
‫ﺩﺍﻟﺔ ﺗﺴﻨﺪ ﶈﺮﻑ ﺍﳉﻤﻠﺔ ﻭﺍﻟﺬﻱ ﺗﺮﺗﻴﺒﻪ ﺍﻟﻮﺳﻴﻂ ﺍﻷﻭﻝ ﲟﺤﺮﻑ‬
‫)‪setCharAt(int, char‬‬
‫ﺍﻟﻮﺳﻴﻂ ﺍﻟﺜﺎﱐ‬
‫)‪setLength(int‬‬ ‫ﺩﺍﻟﺔ ﻹﺳﻨﺎﺩ ﻃﻮﻝ ﳏﺪﺩ ﻟﻠﻐﺮﺽ ﺍﳉﻤﻠﺔ‬
‫)‪String substring(int‬‬ ‫ﺩﺍﻟﺔ ﺗﻌﻴﺪ ﲨﻠﺔ ﺗﺒﺪﺃ ﲟﺤﺮﻑ ﺗﺮﺗﻴﺒﻪ ﺍﻟﻮﺳﻴﻂ ﺣﱴ ‪‬ﺎﻳﺔ ﺍﳉﻤﻠﺔ‬
‫ﺩﺍﻟﺔ ﺗﻌﻴﺪ ﲨﻠﺔ ﺗﺒﺪﺃ ﲟﺤﺮﻑ ﺗﺮﺗﻴﺒﻪ ﺍﻟﻮﺳﻴﻂ ﺍﻷﻭﻝ ﺣﱴ ﺍﶈﺮﻑ‬
‫)‪String substring(int, int‬‬
‫ﺍﻟﺬﻱ ﺗﺮﺗﻴﺒﻪ ﺍﻟﻮﺳﻴﻂ ﺍﻟﺜﺎﱐ‬
‫)(‪String toString‬‬ ‫ﺩﺍﻟﺔ ﺗﻌﻴﺪ ﺍﳉﻤﻠﺔ ﺇﱃ ﲨﻠﺔ‬
‫‪6‬‬
 ‫هﻨﺪﺳﺔ ﻣﻌﻠﻮﻣﺎﺗﻴﺔ‬
‫اﻟﺴﻨﺔ اﻟﺜﺎﻟﺜﺔ‬
(٢ ) ‫ﺑﺮﻣﺠﺔ ﻣﺘﻘﺪﻣﺔ‬ import java.util.Scanner;
‫اﻟﻔﺼﻞ اﻟﺜﺎﻧﻲ‬
(٢٠١٣-٢٠١٢) public class StringBuilderApp
(٤) ‫اﻟﻤﺤﺎﺿﺮة‬
‫اﻟ ﺎﺿ ة‬ {
‫ ﻣﻬﻨﺪ أﺣﻤﺪ رﺟﺐ‬.‫د‬
static Scanner sc = new Scanner(System.in);
public static void main(String[] args)
{
System.out.print("Enter a string: ");
String s = sc.nextLine();
StringBuilder sb = new StringBuilder(s);
int vowelCount = 0;
for (int i = 0; i < s.length(); i++)
{
char c = s.charAt(i);
if ( (c == 'A') || (c == 'a')
|| (c == 'E') || (c == 'e')
|| (c == 'I') || (c == 'i')
|| (c == 'O') || (c == 'o')
|| (c == 'U') || (c == 'u') )
{
sb.setCharAt(i, '*');
}
}
System.out.println();
System.out.println(s);
System.out.println(sb.toString());
}
}

7
 ‫هﻨﺪﺳﺔ ﻣﻌﻠﻮﻣﺎﺗﻴﺔ‬
‫اﻟﺴﻨﺔ اﻟﺜﺎﻟﺜﺔ‬ import java.io.*;
(٢ ) ‫ﺑﺮﻣﺠﺔ ﻣﺘﻘﺪﻣﺔ‬ import java.util.*;
‫اﻟﻔﺼﻞ اﻟﺜﺎﻧﻲ‬
(٢٠١٣-٢٠١٢)
public class Rot13Input
(٤) ‫اﻟﻤﺤﺎﺿﺮة‬
‫اﻟ ﺎﺿ ة‬ {
‫ ﻣﻬﻨﺪ أﺣﻤﺪ رﺟﺐ‬.‫د‬ public static void main(String[ ] args) throws IOException
{
Scanner scan= new Scanner(System.in);
for(;;)
{
System.out.print("> ");
String line = scan.nextLine( );
if ((line == null) || line.equals("quit"))
break;
S i B ff buf
StringBuffer b f = new StringBuffer(line);
S i B ff (li )
for(int i = 0; i < buf.length( ); i++)
buf.setCharAt(i, rot13(buf.charAt(i)));
System.out.println(buf);
}
}
public static char rot13(char c)
{
if ((c >= 'A') && (c <= 'Z'))
{
c += 13;
if (c > 'Z')
c -= 26;
}
if ((((c >= 'a')) && (c( <= 'z'))))
{
c += 13;
if (c > 'z')
c -= 26;
}
return c;
}
}
8
 ‫هﻨﺪﺳﺔ ﻣﻌﻠﻮﻣﺎﺗﻴﺔ‬
‫اﻟﺴﻨﺔ اﻟﺜﺎﻟﺜﺔ‬
‫ﺑﺮﻣﺠﺔ ﻣﺘﻘﺪﻣﺔ ) ‪(٢‬‬
‫اﻟﻔﺼﻞ اﻟﺜﺎﻧﻲ‬
‫)‪(٢٠١٣-٢٠١٢‬‬
‫اﻟﻤﺤﺎﺿﺮة )‪(٤‬‬
‫اﻟ ﺎﺿ ة‬
‫د‪ .‬ﻣﻬﻨﺪ أﺣﻤﺪ رﺟﺐ‬

‫‪ .2-4‬ﺍﳌﺼﻔﻮﻓﺎﺕ ‪.‬‬

‫ﺍﳌﺼﻔﻮﻓﺔ ﲤﺜﻞ ﳎﻤﻮﻋﺔ ﻣﻦ ﺍﳌﺘﺤﻮﻻﺕ ﳝﻜﻦ ﺍﻹﺷﺎﺭﺓ ﺇﻟﻴﻬﺎ ﻣﻦ ﺧﻼﻝ ﻣﺘﺤﻮﻝ ﻭﺣﻴﺪ ﻣﺮﺗﺒﻂ‬
‫ﺑﺘﺮﻗﻴﻢ ﻳﺸﲑ ﺇﱃ ﻋﺪﺩ ﺍﳌﺘﺤﻮﻻﺕ ﰲ ﺍ‪‬ﻤﻮﻋﺔ ﻭﺍﻟﱵ ﻧﺪﻋﻮﻫﺎ ﺑﺎﻟﻌﻨﺎﺻﺮ ‪ .‬ﻭﺍﳌﺼﻔﻮﻓﺔ ﲝﺪ ﺫﺍ‪‬ﺎ ﲤﺜﻞ‬
‫ﻏﺮﺿﹰﺎ ‪ ،‬ﻛﻤﺎ ﳝﻜﻨﻬﺎ ﺃﻥ ﺗﺸﲑ ﺇﱃ ﳎﻤﻮﻋﺔ ﺃﻏﺮﺍﺽ ‪ .‬ﻭﺍﳌﺼﻔﻮﻓﺔ ﺫﺍﺕ ﻃﻮﻝ ﺛﺎﺑﺖ ﻋﻨﺪ ﺍﻟﺘﺸﻴﻴ‪‬ﺪ‬
‫ﻭﺍﳌﺼﻔﻮﻓﺔ ﻗﺪ‬
‫ﺑﺎﻹﻣﻜﺎﻥ ﺗﻐﺗﻐﻴﲑﻩ ‪ .‬ﺍﳌ ﻔ ﻓﺔ‬
‫ﻭﻟﻴﺲ ﺎﻹ ﻜﺎﻥ‬
‫ﺍﳌﺼﻔﻮﻓﺔ ﻟ‬
‫ﻋﻨﺎﺻﺮ ﺍﳌ ﻔ ﻓﺔ‬
‫ﻋﺪﺩ ﺎ‬‫ﻳﺸﲑ ﺇﱃ ﺪ‬ ‫ﺍﻟﻄﻮﻝﻝ ﺸ‬‫ﺬﺍ ﺍﻟﻄ‬
‫ﻭﺍﻹﻧﺸﺎﺀ ‪ ،‬ﻭﻫﺬﺍ‬
‫ﺍﻹﻧﺸﺎ‬
‫ﺗﻜﻮﻥ ﺃﺣﺎﺩﻳﺔ ﺍﻟﺒﻌﺪ ﺃﻭ ﺛﻨﺎﺋﻴﺔ ﺍﻟﺒﻌﺪ ﺃﻭ ﺛﻼﺛﻴﺔ ﺍﻟﺒﻌﺪ ﻭﻫﻜﺬﺍ ‪.‬‬

‫ﻭﻣﻦ ﺍﳌﺴﺎﺋﻞ ﺍﳌﻬﻤﺔ ﰲ ﺍﺳﺘﺨﺪﺍﻡ ﺍﳌﺼﻔﻮﻓﺎﺕ ﻣﺴﺄﻟﺔ ﺍﻟﺘﺮﺗﻴﺐ ‪ .‬ﻛﻤﺎ ﳝﻜﻨﻨﺎ ﻋ ‪‬ﺪ ﻣﺴﺄﻟﺔ ﺗﺮﺗﻴﺐ ﺍﻷﻋﺪﺍﺩ‬
‫ﺍﳌﻮﺟﻮﺩﺓ ﰲ ﻣﺼﻔﻮﻓﺔ ﻣﻦ ﺍﳌﺴﺎﺋﻞ ﺍﳌﻬﻤﺔ ﰲ ﺍﳋﻮﺍﺭﺯﻣﻴﺎﺕ ‪ ،‬ﻭﻫﻨﺎﻙ ﺍﻟﻌﺪﻳﺪ ﻣﻦ ﺍﳋﻮﺍﺭﺯﻣﻴﺎﺕ ﺍﻟﱵ ﺗﻌﺎﰿ‬
‫ﺍﳌﺴﺄﻟﺔ ‪.‬‬
‫ﻫﺬﻩ ﺍﳌ ﺄﻟﺔ‬
‫ﺬ‬

‫‪9‬‬
 ‫هﻨﺪﺳﺔ ﻣﻌﻠﻮﻣﺎﺗﻴﺔ‬
‫اﻟﺴﻨﺔ اﻟﺜﺎﻟﺜﺔ‬
(٢ ) ‫ﺑﺮﻣﺠﺔ ﻣﺘﻘﺪﻣﺔ‬
‫اﻟﻔﺼﻞ اﻟﺜﺎﻧﻲ‬ public class SortNumbers
(٢٠١٣-٢٠١٢)
(٤) ‫اﻟﻤﺤﺎﺿﺮة‬
‫اﻟ ﺎﺿ ة‬ {
‫ ﻣﻬﻨﺪ أﺣﻤﺪ رﺟﺐ‬.‫د‬ public static void sort(double[ ] nums)
{
for(int i = 0; i < nums.length; i++)
{
int min = i;
for(int j = i; j < nums.length; j++)
{
if (nums[j] < nums[min])
min = j;
}
double tmp;
tmp = nums[i];
nums[i] = nums[min];
nums[min] = tmp;
}
}

public static void main(String[ ] args)

{
double[ ] nums = new double[10];
for(int i = 0; i < nums.length; i++)
nums[i] = Math.random( ) * 100;
sort(nums);
for(int i = 0; i < nums.length; i++)
System.out.println(nums[i]);
}
}

10
 ‫هﻨﺪﺳﺔ ﻣﻌﻠﻮﻣﺎﺗﻴﺔ‬
‫اﻟﺴﻨﺔ اﻟﺜﺎﻟﺜﺔ‬ ( ‫ ﻳﺘﻢ ﰲ ﺍﻟﺒﺪﺍﻳﺔ ﺗﻌﺮﻳﻒ ﻣﺼﻔﻮﻓﺔ ﺣﺠﻤﻬﺎ ﻳﺴﺎﻭﻱ‬: ‫ﺧﻮﺍﺭﺯﻣﻴﺔ ﺍﳌﻨﺨﻞ ﻭﺍﻟﱵ ﺗﺘﻠﺨﺺ ﻓﻴﻤﺎ ﻳﻠﻲ ﺍﻵﰐ‬
(٢ ) ‫ﺑﺮﻣﺠﺔ ﻣﺘﻘﺪﻣﺔ‬
‫اﻟﻔﺼﻞ اﻟﺜﺎﻧﻲ‬
‫( ﲝﻴﺚ ﺗﺴﻨﺪ‬Boolean) ‫ﺎ ﻣﻦ ﺍﻟﺸﻜﻞ ﺍﳌﻨﻄﻘﻲ‬‫( ﻭﻣﺮﻛﺒﺎ‬int) Math.ceil(Math.sqrt(max)) )
(٢٠١٣-٢٠١٢) ‫ ﻭﻣﻦ ﰒ ﺗﺘﻢﻢ ﻋﻤﻠﻴﺔ ﳔﻞ‬، (true) ‫( ﻭﻟﻠﻤﺮﻛﺒﺎﺕ ﺍﳌﺘﺒﻘﻴﺔ ﺍﻟﻘﻴﻤﺔ‬false) ‫ﻟﻠﻤﺮﻛﺒﺔ ﺍﻷﻭﱃ ﻭﺍﻟﺜﺎﻧﻴﺔ ﺍﻟﻘﻴﻤﺔ‬
(٤) ‫اﻟﻤﺤﺎﺿﺮة‬
‫اﻟ ﺎﺿ ة‬
‫ ﻣﻬﻨﺪ أﺣﻤﺪ رﺟﺐ‬.‫د‬ (false) ‫ ﻭﺫﻟﻚ ﻋﻦ ﻃﺮﻳﻖ ﺇﺳﻨﺎﺩ ﺍﻟﻘﻴﻤﺔ‬، (3) ‫ﻟﻸﻋﺪﺍﺩ ﺍﻷﻭﻟﻴﺔ ﺍﻷﺻﻐﺮ ﻓﺎﻷﺻﻐﺮ ﺑﺪﺀﹰﺍ ﻣﻦ ﺍﻟﻌﺪﺩ‬
‫ ﻭﺑﺎﻧﺘﻬﺎﺀ ﻋﻤﻠﻴﺔ ﳔﻞ ﺍﻷﻋﺪﺍﺩ ﺍﻷﻭﻟﻴﺔ ﻳﺘﻢ ﺍﳌﺮﻭﺭ ﺑﺎﳌﺼﻔﻮﻓﺔ‬. ‫ﻟﻠﻤﺮﻛﺒﺔ ﺍﳌﻘﺎﺑﻠﺔ ﻟﻠﻌﺪﺩ ﺍﻷﻭﱄ ﺍﳌﻨﺨﻮﻝ‬
. ‫( ﻭﺍﻟﱵ ﲤﺜﻞ ﺍﻟﻌﺪﺩ ﺍﻷﻭﱄ ﺍﻷﻛﱪ ﺍﳌﺮﺍﺩ ﺇﳚﺎﺩﻩ‬false) ‫ﺑﺸﻜﻞ ﻋﻜﺴﻲ ﺇﱃ ﺃﻭﻝ ﻣﺮﻛﺒﺔ ﻗﻴﻤﺘﻬﺎ‬
public class Sieve
{
public static void main(String[ ] args)
{
int max = 100;;
try { max = Integer.parseInt(args[0]); }
catch (Exception e) { }
boolean[ ] isprime = new boolean[max+1];
for(int i = 0; i <= max; i++)
isprime[i] = true;
isprime[0] = isprime[1] = false;
int n = (int) Math.ceil(Math.sqrt(max));
System.out.println(n);
for(int i = 0; i <= n; i++)
{
if (isprime[i])
for(int j = 2*i; j <= max; j = j + i)
isprime[j] = false;
}
int largest;
for(largest = max; !isprime[largest]; largest--) ;
System out print("The largest prime less than or equal");
System.out.print("The
System.out.println( " to " + max + " is " + largest );
}
11 }
 ‫هﻨﺪﺳﺔ ﻣﻌﻠﻮﻣﺎﺗﻴﺔ‬
‫اﻟﺴﻨﺔ اﻟﺜﺎﻟﺜﺔ‬
(٢ ) ‫ﺑﺮﻣﺠﺔ ﻣﺘﻘﺪﻣﺔ‬
‫اﻟﻔﺼﻞ اﻟﺜﺎﻧﻲ‬
(٢٠١٣-٢٠١٢) public class BoboAndTheLockers
(٤) ‫اﻟﻤﺤﺎﺿﺮة‬
‫اﻟ ﺎﺿ ة‬ {
‫ ﻣﻬﻨﺪ أﺣﻤﺪ رﺟﺐ‬.‫د‬
public static void main(String[] args)
{
boolean[] lockers = new boolean[1001];
for (int i = 1; i <= 1000; i++)
lockers[i] = false;
for (int skip = 1; skip <= 1000; skip++)
{
System.out.println("Bobo is changing every"+ skip + " lockers.");
for (int locker = skip; locker < 1000; locker += skip)
lockers[locker] = !lockers[locker];
}
System.out.println("Bobo is bored" +" now so he's going home.");
String list = "";
int openCount = 0;
for (int i = 1; i <= 1000; i++)
if (lockers[i])
{
openCount++;
list += i + " ";
}
System.out.println("Bobo left " + openCount+ " lockers open.");
System.out.println("The open lockers are: " + list);
}
}

12
 ‫هﻨﺪﺳﺔ ﻣﻌﻠﻮﻣﺎﺗﻴﺔ‬
‫اﻟﺴﻨﺔ اﻟﺜﺎﻟﺜﺔ‬
‫ﺑﺮﻣﺠﺔ ﻣﺘﻘﺪﻣﺔ ) ‪(٢‬‬
‫اﻟﻔﺼﻞ اﻟﺜﺎﻧﻲ‬
‫)‪(٢٠١٣-٢٠١٢‬‬
‫اﻟﻤﺤﺎﺿﺮة )‪(٤‬‬
‫اﻟ ﺎﺿ ة‬
‫د‪ .‬ﻣﻬﻨﺪ أﺣﻤﺪ رﺟﺐ‬
‫ﻣﻼﺣﻈﺔ )‪ : (2-4‬ﺇﺿﺎﻓﺔ ﺇﱃ ﺍﻟﻄﺮﻳﻘﺔ ﻵ‬
‫ﻭﺍﻵﻟﻴﺔ ﺍﻟﱵ ﺗﺸ‪‬ﻴ‪‬ﺪ ‪‬ﺎ ﺍﳌﺼﻔﻮﻓﺎﺕ ‪ ،‬ﻓﺈﻥ ﻟﻐﺔ ﺍﳉﺎﻓﺎ‬ ‫ﻼ ﻈ‬
‫ﺗﺘﻀﻤﻦ ﳎﻤﻮﻋﺔ ﻣﻦ ﺍﻟﺪﻭﺍﻝ ﺍﻟﺴﺎﻛﻨﺔ ﺿﻤﻦ ﺍﳊﺰﻣﺔ )‪ (java.util‬ﺗﺴﻬﻢ ﺑﺸﻜﻞ ﻓﻌ‪‬ﺎﻝ ﰲ ﻣﻌﺎﳉﺔ‬
‫ﺍﳌﺼﻔﻮﻓﺎﺕ ‪ .‬ﻭﻣﻦ ﻫﺬﻩ ﺍﻟﺪﻭﺍﻝ ‪:‬‬

‫‪Method‬‬ ‫‪Description‬‬
‫)‪ (-1‬ﰲ‬ ‫ﺩﺍﻟﺔ ﺗﺒﺤﺚ ﻋﻦ ﺍﻟﻮﺳﻴﻂ ﺍﻟﺜﺎﱐ ﰲ ﺍﳌﺼﻔﻮﻓﺔ ﻭﺗﻌﻴﺪ‬
‫)‪static int binarySearch(array, key‬‬
‫ﻋﺪﻡ ﻭﺟﻮﺩﻩ‬
‫ﺣﺎﻝ ﺪ‬
‫ﺎﻝ‬
‫ﺩﺍﻟﺔ ﺗﻌﻴﺪ )‪ (true‬ﺇﺫﺍ ﺗﻄﺎﺑﻘﺖ ﻣﺮﻛﺒﺎﺕ ﺍﳌﺼﻔﻮﻓﺘﲔ‬
‫)‪boolean deepEquals(array1, array2‬‬
‫)ﻣﺼﻔﻮﻓﺎﺕ ﺫﺍﺕ ﺑﻌﺪﻳﻦ ﻭﺃﻛﺜﺮ(‬
‫ﻣﺮﻛﺒﺎﺕ ﺍﳌ ﻔ ﻓﺘﲔ‬
‫ﺍﳌﺼﻔﻮﻓﺘﲔ‬ ‫ﻘﺖ ﻛ ﺎﺕ‬‫ﺗﻄﺎﺑﻘﺖ‬
‫)‪ (true‬ﺇﺫﺍ ﺗﻄﺎ‬
‫ﺗﻌﻴﺪ ) ‪(t‬‬
‫ﺩﺍﻟﺔ ﺗ ﺪ‬
‫)‪boolean equals(array1, array2‬‬
‫)ﻣﺼﻔﻮﻓﺎﺕ ﺃﺣﺎﺩﻳﺔ ﺍﻟﺒﻌﺪ(‬
‫)‪static void fill(array,value‬‬ ‫ﺩﺍﻟﺔ ﻟﺘﻌﺒﺌﺔ ﻣﺮﻛﺒﺎﺕ ﺍﳌﺼﻔﻮﻓﺔ ﺑﺎﻟﻮﺳﻴﻂ ﺍﻟﺜﺎﱐ‬
‫ﺑﺎﻟﻮﺳﻴﻄﲔ ﺍﻟﺜﺎﱐ‬
‫ﻓﺔ ﺍﶈﺪﺩﺓ ﺎﻟ ﻄﲔ‬
‫ﺍﳌﺼﻔﻮﻓﺔ‬
‫ﺎﺕ ﺍﳌ ﻔ‬
‫ﻣﺮﻛﺒﺎﺕ‬
‫ﺩﺍﻟﺔ ﻟﺘﻟﺘﻌﺒﺌﺔﺌﺔ ﻛ‬
‫)‪static void fill(array,from, to, value‬‬
‫ﻭﺍﻟﺜﺎﻟﺚ ﺑﻘﻴﻤﺔ ﺍﻟﻮﺳﻴﻂ ﺍﻟﺮﺍﺑﻊ‬
‫)‪static void sort(array‬‬ ‫ﺩﺍﻟﺔ ﻟﺘﺮﺗﻴﺐ ﻣﺮﻛﺒﺎﺕ ﻣﺼﻔﻮﻓﺔ‬
‫ﺑﺎﻟﻮﺳﻴﻄﲔ ﺍﻟﺜﺎﱐ‬
‫ﻓﺔ ﺍﶈﺪﺩﺓ ﺑﺎﻟ ﻄﲔ‬
‫ﺍﳌﺼﻔﻮﻓﺔ‬
‫ﺎﺕ ﺍﳌﺼﻔ‬
‫ﻣﺮﻛﺒﺎﺕ‬
‫ﻟﺘﺮﺗﻴﺐ ﻣ ﻛ‬
‫ﺩﺍﻟﺔ ﻟﺘ ﺗ‬
‫)‪static void sort(array,from, to‬‬
‫ﻭﺍﻟﺜﺎﻟﺚ‬
‫)‪static String toString(array‬‬ ‫ﺩﺍﻟﺔ ﻟﺘﺤﻮﻳﻞ ﻣﺮﻛﺒﺎﺕ ﻣﺼﻔﻮﻓﺔ ﺇﱃ ﲨﻠﺔ‬

‫‪13‬‬
 ‫هﻨﺪﺳﺔ ﻣﻌﻠﻮﻣﺎﺗﻴﺔ‬
‫اﻟﺴﻨﺔ اﻟﺜﺎﻟﺜﺔ‬
(٢ ) ‫ﺑﺮﻣﺠﺔ ﻣﺘﻘﺪﻣﺔ‬
‫اﻟﻔﺼﻞ اﻟﺜﺎﻧﻲ‬
class OverLoadedMethods .(Generics) ‫ ﺍﻟﺼﻔﻮﻑ ﻭﺍﻟﺪﻭﺍﻝ ﺍﻟﺸﺎﻣﻠﺔ‬.3-4
(٢٠١٣-٢٠١٢)
{
(٤) ‫اﻟﻤﺤﺎﺿﺮة‬
‫اﻟ ﺎﺿ ة‬ public static void printArray( Integer[] inputArray)
‫ ﻣﻬﻨﺪ أﺣﻤﺪ رﺟﺐ‬.‫د‬ { ‫ﻫﻞ ﻧﺴﺘﻄﻴﻊ ﺃﻥ ﻧﻜﺘﺐ ﺩﺍﻟﺔ ﺑﺮﳎﻴﺔ ﻭﺣﻴﺪﺓ ﺗﻘﻮﻡ ﺑﺘﺮﺗﻴﺐ ﺃﻱ ﻣﺼﻔﻮﻓﺔ ﻣﻦ ﺍﻷﻋﺪﺍﺩ ﺍﻟﺼﺤﻴﺤﺔ‬
for ( Integer element : inputArray ) ‫ﺃﻭ ﺃﻱ ﻣﺼﻔﻮﻓﺔ ﻣﻦ ﺍﳉﻤﻞ ﺍﶈﺮﻓﻴﺔ ؟ ﲟﻌﲎ ﺁﺧﺮ ﻫﻞ ﳝﻜﻨﻨﺎ ﺗﻌﺮﻳﻒ ﺩﺍﻟﺔ ﺷﺎﻣﻠﺔ ﳝﻜﻦ ﺍﺳﺘﺨﺪﺍﻣﻬﺎ ﻣﻦ‬
System.out.printf("%s", element );
System.out.println(); ‫ﻼ ﻳﺼﻠﺢ ﻟﺘﻮﺻﻴﻒ ﺃﻱ ﺷﻜﻞ ﻣﻦ‬
‫ﻑ ﺻﻔﹰﺎ ﺷﺎﻣ ﹰ‬‫ﺃﺟﻞ ﺃﻱ ﺷﻜﻞ ﻣﻦ ﺍﻟﺒﻴﺎﻧﺎﺕ ؟ ﻫﻞ ﳝﻜﻨﻨﺎ ﺃﻥ ﻧﻌﺮ‬
} . ‫ﻟﺍﻟﺒﻴﺎﻧﺎﺕ ؟ ﻫﺬﺍ ﻣﺎ ﺳﺘﺤﺎﻭﻝﻝ ﻫﺬﻩ ﻟﺍﻟﻔﻘﺮﺓ ﺍﻹﺟﺎﺑﺔ ﻋﻨﻪ‬
public static void printArray( Double[] inputArray )
{
for ( Double element : inputArray ) ‫( ﺑﺜﻼﺙ ﺻﻴﻎ ﳐﺘﻠﻔﺔ‬printArray()) ‫ ﻣﻊ ﺍﻟﺘﻨﻮﻳﻪ ﻭﺟﻮﺩ ﺍﻟﺪﺍﻟﺔ‬، ‫ﻟﻨﺤﺎﻭﻝ ﺍﻟﻨﻈﺮ ﺇﱃ ﺍﻟﺘﻄﺒﻴﻖ ﺍﻵﰐ‬
System.out.printf("%s", element ); : ‫ﱵ ﺗﻌﺎﳉﻬﺎ‬
‫ﺗﻨﺎﺳﺐ ﺍﻟﺒﻴﺎﻧﺎﺕ ﺍﻟﱵ‬
System.out.println();
}
public static void printArray( Character[] inputArray)
{
for ( Character element : inputArray ) public static<E> void printArray( E[] inputArray)
System.out.printf("%s", element ); {
System.out.println(); for ( E element : inputArray )
} System.out.printf("%s", element );
public static void main( String[] args ) System.out.println();
{ }
Integer[] integerArray = {1, 2, 3, 4, 5, 6};

Double[] doubleArray = {1.1, 2.2, 3.3, 4.4, 5.5, 6.6};

Character[] characterArray = { 'H' , 'E' , 'L' , 'L' , 'O' };
System.out.println( "Array
Array integerArray contains : "););
printArray( integerArray );
System.out.println( "Array doubleArray contains : ");
printArray( doubleArray ); public static void printArray( Object[] inputArray)
System.out.println( "Array characterArray contains : "); {
printArray( characterArray ); for ( Object
j element : inputArrayy )
} System.out.printf("%s", element );
} System.out.println();
}
14
 ‫هﻨﺪﺳﺔ ﻣﻌﻠﻮﻣﺎﺗﻴﺔ‬
‫اﻟﺴﻨﺔ اﻟﺜﺎﻟﺜﺔ‬ : ‫ﻭﻓﻴﻤﺎ ﻳﻠﻲ ﺗﻄﺒﻴﻖ ﻳﻮﺿﺢ ﺍﺳﺘﺨﺪﺍﻡ ﻣﻔﻬﻮﻡ ﺍﻟﺪﺍﻟﺔ ﺍﻟﺸﺎﻣﻠﺔ ﻭﺍﻟﺼﻒ ﺍﻟﺸﺎﻣﻞ‬
(٢ ) ‫ﺑﺮﻣﺠﺔ ﻣﺘﻘﺪﻣﺔ‬
‫اﻟﻔﺼﻞ اﻟﺜﺎﻧﻲ‬
(٢٠١٣-٢٠١٢)
class Pair<T>
(٤) ‫اﻟﻤﺤﺎﺿﺮة‬
‫اﻟ ﺎﺿ ة‬ {
‫ ﻣﻬﻨﺪ أﺣﻤﺪ رﺟﺐ‬.‫د‬ public Pair() { first = null; second = null; }
public Pair(T first, T second)
{ this.first = first; this.second = second; }
public T getFirst() { return first; }
public T getSecond() { return second; }
public void setFirst(T newValue) { first = newValue; }
public void setSecond(T newValue) { second = newValue; }
private T first;
private T second; class MaximumTest
} {
class ArrayAlg public static< E extends Comparable<E>> E maximum(E x,E y,E z)
{ {
public static Pair<String> minmax(String[] a) E max=x;
{ if(y.compareTo(max)>0)
if (a == null || a.length == 0) return null; max=y;
String min = a[0];
String max = a[0]; if(z.compareTo(max)>0)
for (int i = 1; i < a.length; i++) max=z;
{ return max;
if (min.compareTo(a[i]) > 0) min = a[i]; }
if (max.compareTo(a[i]) < 0) max = a[i]; public
bli static
t ti voidid main(
i ( String[]
St i [] args )
} {
return new Pair<String>(min, max); System.out.printf( "Maximum of %d, %d and %d is
} %d\n\n",3,4,5,maximum(3,4,5));
} System.out.printf( "Maximum of %1f, %1f and %1f is
public class PairTest1 %f\n\n",6.6,8.8,7.7,maximum(6.6,8.8,7.7));
{ System.out.printf( "Maximum of %s, %s and %s is
public static void main(String[] args) %s\n","pear","apple","orange",maximum("pear","apple","orange"));
{ }
String[] words = { "Mary", "had", "a", "little", "lamb" }; }
P i <St i > mm = ArrayAlg.minmax(words);
Pair<String> A Al i ( d)
System.out.println("min = " + mm.getFirst());
System.out.println("max = " + mm.getSecond());
}
15 }
 ‫هﻨﺪﺳﺔ ﻣﻌﻠﻮﻣﺎﺗﻴﺔ‬
‫اﻟﺴﻨﺔ اﻟﺜﺎﻟﺜﺔ‬
‫ﺑﺮﻣﺠﺔ ﻣﺘﻘﺪﻣﺔ ) ‪(٢‬‬
‫اﻟﻔﺼﻞ اﻟﺜﺎﻧﻲ‬
‫)‪(٢٠١٣-٢٠١٢‬‬
‫اﻟﻤﺤﺎﺿﺮة )‪(٤‬‬
‫اﻟ ﺎﺿ ة‬
‫د‪ .‬ﻣﻬﻨﺪ أﺣﻤﺪ رﺟﺐ‬
‫ﺃﺳﺌﻠﺔ ﻭﲤﺎﺭﻳﻦ‬
‫ﻮﻡ ﺑﻄﺒﺎﻋﺔ ﺇﺇﺣﺼﺎﺋﻴﺔ ﺗﺘﻀﻤﻦﻦ‬
‫ﳏﺮﻓﻴﺔ ‪ ،‬ﰒ ﻳﻘﻮﻡ‬
‫ﺑﻘﺮﺍﺀﺓ ﺃﻭﻭ ﺇﺇﺩﺧﺎﻝ ﲨﻠﺔ ﺮ‬
‫ﺐ ﺗﻄﺒﻴﻘﹰﺎ ﻳﺴﻤﺢﺢ ﺮ‬
‫‪- ١‬ﺍﻛﺘﺐ‬
‫ﺍﶈﺎﺭﻑ ﺍﳌﺆﻟﻔﺔ ﻣﻨﻬﺎ ﺍﳉﻤﻠﺔ ﻭﺃﻋﺪﺍﺩﻫﺎ ‪.‬‬
‫‪- ٢‬ﺍﻛﺘﺐ ﺗﻄﺒﻴﻘﹰﺎ ﻳﺴﻤﺢ ﺑﻘﺮﺍﺀﺓ ﺃﻭ ﺇﺩﺧﺎﻝ ﲨﻠﺔ ﳏﺮﻓﻴﺔ ﻣﺆﻟﻔﺔ ﻣﻦ ﻋﺪﺓ ﻛﻠﻤﺎﺕ ‪ ،‬ﻭﻣﻦ ﰒ‬
‫ﺍﳌﻜﺮﺭﺓ ‪.‬‬
‫ﺍﻟﻜﻠﻤﺎﺕ ﺍﳌﻜ ﺓ‬
‫ﺑﻄﺒﺎﻋﺔ ﺍﻟﻜﻠ ﺎ‬
‫ﻘﻳﻘﻮﻡ ﻄ ﺎ‬
‫‪- ٣‬ﺍﻛﺘﺐ ﺗﻄﺒﻴﻘﹰﺎ ﻳﺴﻤﺢ ﺑﻘﺮﺍﺀﺓ ﺃﻭ ﺇﺩﺧﺎﻝ ﻋﺪﺩ ‪ ،‬ﻭﻣﻦ ﰒ ﺍﻟﺘﺄﻛﺪ ﻣﻦ ﺃﻧﻪ ﻏﲑ ﺃﻭﱄ ﻟﻴﻘﻮﻡ‬
‫ﻼ )‪. (54=2*3*3*3‬‬
‫ﺑﻌﺪﻫﺎ ﺍﻟﺘﻄﺒﻴﻖ ﺑﻄﺒﺎﻋﺔ ﻋﻮﺍﻣﻞ ﺍﻟﻌﺪﺩ ) ﻣﻀﺎﺭﻳﺐ ﺍﻟﻌﺪﺩ( ﻣﺴﺘﺨﺪﻣﹰﺎ ﺍﻟﻘﻮﺍﺋﻢ ‪ .‬ﻓﻤﺜ ﹰ‬
‫‪- ٤‬ﺍﻛﺘﺐ ﺗﻄﺒﻴﻘﹰﺎ ﻳﺴﻤﺢ ﺑﺈﺩﺧﺎﻝ ﲨﻠﺘﲔ ﳏﺮﻓﻴﺘﲔ ﺗﺘﺸﺎﺭﻛﺎﻥ ﺑﻌﺾ ﺍﻟﻜﻠﻤﺎﺕ ‪ ،‬ﲝﻴﺚ ﻳﻘﻮﻡ‬
‫ﲟﺎ ﻳﻠﻲ ‪:‬‬
‫ﺍﻟﺜﺎﻧﻴﺔ ﻟﻸﻭﱃ ( ‪.‬‬
‫ﺍﳉﻤﻠﺔ ﺍﻟﺜﺎﻧ ﺔ‬
‫ﻠﺘﲔ ﰲ ﲨﻠﺔ ﻭﺍﺣﺪﺓ ) ﺇﺿﺎﻓﺔ ﺍﳉ ﻠﺔ‬
‫ﺍﳉﻤﻠﺘﲔ‬
‫‪-‬ﺩﻣﺞ ﺍﳉ‬
‫‪-‬ﺣﺬﻑ ﻛﻠﻤﺎﺕ ﺍﳉﻤﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ ﻣﻦ ﺍﻷﻭﱃ ﰒ ﻃﺒﺎﻋﺔ ﲨﻠﺔ ﺍﻟﺪﻣﺞ ‪.‬‬
‫‪-‬ﺣﺬﻑ ﻛﻠﻤﺎﺕ ﺍﳉﻤﻠﺔ ﺍﻷﻭﱃ ﻣﻦ ﺍﻟﺜﺎﻧﻴﺔ ﰒ ﻃﺒﺎﻋﺔ ﲨﻠﺔ ﺍﻟﺪﻣﺞ ‪.‬‬
‫‪- ٥‬ﺍﻛﺘﺐ ﺗﻄﺒﻴﻘﺎﹰ ﻳﻘﺮﺃ ﻣﻠﻔﺎﹰ ﻧﺼﻴﺎﹰ ‪ ،‬ﰒ ﻳﻘﻮﻡ ﲝﺴﺎﺏ ﻋﺪﺩ ﺍﻟﻜﻠﻤﺎﺕ ﺍﳌﺨﺘﻠﻔﺔ ﻭﻏﲑ ﺍﳌﺘﺸﺎ‪‬ﺔ‬
‫ﻣﻊ ﻃﺒﺎﻋﺘﻬﺎ ﻋﻠﻰ ﺍﻟﺸﺎﺷﺔ ‪.‬‬

‫‪16‬‬