# פתרונות: תרגול לבחינה בפייתון (תשפ"ז)
> כל פתרון כאן **הורץ**, והפלט שמופיע מתחתיו הוא הפלט האמיתי. יש עוד דרכים נכונות לפתור כל תרגיל.
---
## 1. פירוק מספר שלם לספרות: `//`, `%` ו‑`**` עם בסיס 10
### תרגיל 1 🟢: סכום וכמות ספרות
```python
num = int(input("הקלד מספר: "))
count = 0
total = 0
while num > 0:
total += num % 10 # the last digit
count += 1
num = num // 10 # drop the last digit
print("ספרות:", count)
print("סכום:", total)
```
הקלט: `50731`
הפלט:
```text
הקלד מספר: 50731
ספרות: 5
סכום: 16
```
### תרגיל 2 🟢: כמה פעמים מופיעה ספרה
```python
num = int(input("מספר: "))
d = int(input("ספרה: "))
times = 0
while num > 0:
if num % 10 == d:
times += 1
num //= 10
print("הספרה", d, "מופיעה", times, "פעמים")
```
הקלט: `1707170` · `7`
הפלט:
```text
מספר: 1707170
ספרה: 7
הספרה 7 מופיעה 3 פעמים
```
### תרגיל 3 🟢: בלי לולאה: מספר תלת‑ספרתי
```python
num = int(input("מספר תלת-ספרתי: "))
hundreds = num // 100
tens = num // 10 % 10
units = num % 10
print(hundreds, tens, units)
print(units * 100 + tens * 10 + hundreds)
```
הקלט: `472`
הפלט:
```text
מספר תלת-ספרתי: 472
4 7 2
274
```
### תרגיל 4 🟢: ספרת האחדות וספרת העשרות
```python
num = int(input("מספר: "))
print("אחדות:", num % 10)
print("עשרות:", num // 10 % 10)
```
הקלט: `3786`
הפלט:
```text
מספר: 3786
אחדות: 6
עשרות: 8
```
### תרגיל 5 🟡: מספר הפוך ופלינדרום
```python
num = int(input("מספר: "))
temp = num # keep the original number
rev = 0
while temp > 0:
rev = rev * 10 + temp % 10
temp //= 10
print("הפוך:", rev)
if rev == num:
print("פלינדרום")
else:
print("לא פלינדרום")
```
הקלט: `12321`
הפלט:
```text
מספר: 12321
הפוך: 12321
פלינדרום
```
### תרגיל 6 🟡: הספרה במקום k
```python
num = int(input("מספר: "))
k = int(input("k: "))
print(num // 10 ** k % 10)
```
הקלט: `905162` · `3`
הפלט:
```text
מספר: 905162
k: 3
5
```
`**` מחושב לפני `//` ו‑`%`: `905162 // 1000` הוא 905, ו‑`905 % 10` הוא 5.
### תרגיל 7 🔴: מספר מהספרות הזוגיות
```python
num = int(input("מספר: "))
result = 0
place = 0 # the position of the next digit in the new number
while num > 0:
digit = num % 10
if digit % 2 == 0:
result += digit * 10 ** place
place += 1
num //= 10
print(result)
```
הקלט: `48725`
הפלט:
```text
מספר: 48725
482
```
### תרגיל 8 🔴: ספרות בסדר עולה
```python
num = int(input("מספר: "))
ok = True
prev = num % 10 # the rightmost digit
num //= 10
while num > 0:
digit = num % 10
if digit >= prev: # going left, every digit must be smaller
ok = False
prev = digit
num //= 10
if ok:
print("עולה")
else:
print("לא עולה")
```
הקלט: `1359`
הפלט:
```text
מספר: 1359
עולה
```
### תרגיל 9 🔴: כל ספרה פעמיים
```python
num = int(input("מספר: "))
result = 0
place = 0
while num > 0:
digit = num % 10
result += digit * 10 ** place + digit * 10 ** (place + 1)
place += 2
num //= 10
print(result)
```
הקלט: `472`
הפלט:
```text
מספר: 472
447722
```
---
## 2. לולאות `while` ו‑`for`, לולאות מקוננות וזקיף
### תרגיל 10 🟢: המספרים הזוגיים עד 20
```python
for i in range(2, 21, 2):
print(i, end=" ")
print()
```
הפלט:
```text
2 4 6 8 10 12 14 16 18 20
```
### תרגיל 11 🟢: לוח הכפל של מספר
```python
n = int(input("מספר: "))
for i in range(1, 11):
print(n, "x", i, "=", n * i)
```
הקלט: `7`
הפלט:
```text
מספר: 7
7 x 1 = 7
7 x 2 = 14
7 x 3 = 21
7 x 4 = 28
7 x 5 = 35
7 x 6 = 42
7 x 7 = 49
7 x 8 = 56
7 x 9 = 63
7 x 10 = 70
```
### תרגיל 12 🟢: חיוביים ושליליים עד זקיף
```python
pos = 0
neg = 0
num = int(input("מספר (0 לסיום): "))
while num != 0:
if num > 0:
pos += 1
else:
neg += 1
num = int(input("מספר (0 לסיום): "))
print("חיוביים:", pos, "שליליים:", neg)
```
הקלט: `5` · `-2` · `8` · `-7` · `3` · `0`
הפלט:
```text
מספר (0 לסיום): 5
מספר (0 לסיום): -2
מספר (0 לסיום): 8
מספר (0 לסיום): -7
מספר (0 לסיום): 3
מספר (0 לסיום): 0
חיוביים: 3 שליליים: 2
```
### תרגיל 13 🟡: ציונים עד זקיף
```python
count = 0
total = 0
best = -1
grade = int(input("ציון (-1 לסיום): "))
while grade != -1:
count += 1
total += grade
if grade > best:
best = grade
grade = int(input("ציון (-1 לסיום): "))
if count == 0:
print("אין ציונים")
else:
print("כמות:", count)
print("ממוצע:", total / count)
print("הכי גבוה:", best)
```
הקלט: `80` · `95` · `70` · `-1`
הפלט:
```text
ציון (-1 לסיום): 80
ציון (-1 לסיום): 95
ציון (-1 לסיום): 70
ציון (-1 לסיום): -1
כמות: 3
ממוצע: 81.66666666666667
הכי גבוה: 95
```
### תרגיל 14 🟡: לולאה מקוננת: סכום ספרות 6
```python
for n in range(1, 61):
temp = n
s = 0
while temp > 0:
s += temp % 10
temp //= 10
if s == 6:
print(n, end=" ")
print()
```
הפלט:
```text
6 15 24 33 42 51 60
```
### תרגיל 15 🟡: משולש מספרים
```python
n = int(input("n: "))
for i in range(1, n + 1):
for j in range(1, i + 1):
print(j, end=" ")
print()
```
הקלט: `4`
הפלט:
```text
n: 4
1
1 2
1 2 3
1 2 3 4
```
### תרגיל 16 🔴: זקיף ומקסימום
```python
best_num = 0
best_sum = -1
num = int(input("מספר (0 לסיום): "))
while num != 0:
temp = num
s = 0
while temp > 0:
s += temp % 10
temp //= 10
if s > best_sum:
best_sum = s
best_num = num
num = int(input("מספר (0 לסיום): "))
print(best_num, "עם סכום ספרות", best_sum)
```
הקלט: `345` · `99` · `1000` · `0`
הפלט:
```text
מספר (0 לסיום): 345
מספר (0 לסיום): 99
מספר (0 לסיום): 1000
מספר (0 לסיום): 0
99 עם סכום ספרות 18
```
### תרגיל 17 🔴: מספרים ראשוניים עד 50
```python
for n in range(2, 51):
prime = True
for d in range(2, n):
if n % d == 0:
prime = False
break
if prime:
print(n, end=" ")
print()
```
הפלט:
```text
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47
```
---
## 3. רשימות: איברים סמוכים ורשימת מונים
### תרגיל 18 🟢: זוג שבו השני כפול
```python
nums = [3, 6, 2, 4, 8, 5, 10, 1]
count = 0
for i in range(len(nums) - 1): # the last index has no neighbour
if nums[i + 1] == 2 * nums[i]:
print(nums[i], nums[i + 1])
count += 1
print("זוגות:", count)
```
הפלט:
```text
3 6
2 4
4 8
5 10
זוגות: 4
```
### תרגיל 19 🟢: מיקום וערך
```python
prices = [12, 7, 30, 18]
best = 0 # the INDEX of the highest price so far
for i in range(len(prices)):
print("מקום", i, "ערך", prices[i])
if prices[i] > prices[best]:
best = i
print("המחיר הגבוה נמצא במקום", best)
```
הפלט:
```text
מקום 0 ערך 12
מקום 1 ערך 7
מקום 2 ערך 30
מקום 3 ערך 18
המחיר הגבוה נמצא במקום 2
```
### תרגיל 20 🟢: כמה פעמים השכן גדול יותר
```python
steps = [5, 8, 6, 9, 12, 4]
count = 0
for i in range(len(steps) - 1):
if steps[i + 1] > steps[i]:
count += 1
print(count)
```
הפלט:
```text
3
```
### תרגיל 21 🟡: שלושה שווים ברצף
```python
lst = [4, 1, 1, 7, 7, 7, 2]
found = False
for i in range(len(lst) - 2): # i, i+1, i+2 must all exist
if lst[i] == lst[i + 1] and lst[i + 1] == lst[i + 2]:
found = True
print(found)
```
הפלט:
```text
True
```
### תרגיל 22 🟡: רשימת מונים: הספרה השכיחה
```python
num = int(input("מספר: "))
counts = [0] * 10
while num > 0:
counts[num % 10] += 1 # the digit is the INDEX
num //= 10
best = 0
for d in range(10):
if counts[d] > 0:
print("הספרה", d, ":", counts[d], "פעמים")
if counts[d] > counts[best]:
best = d
print("השכיחה:", best)
```
הקלט: `3803583`
הפלט:
```text
מספר: 3803583
הספרה 0 : 1 פעמים
הספרה 3 : 3 פעמים
הספרה 5 : 1 פעמים
הספרה 8 : 2 פעמים
השכיחה: 3
```
### תרגיל 23 🟡: ציונים שאף אחד לא קיבל
```python
grades = [7, 9, 7, 10, 5, 9, 7, 8, 5, 10]
counts = [0] * 11 # indexes 1..10 are the grades
for g in grades:
counts[g] += 1
for g in range(1, 11):
if counts[g] == 0:
print(g, end=" ")
print()
```
הפלט:
```text
1 2 3 4 6
```
### תרגיל 24 🟡: מיקום מול ערך (שאלת מעקב)
```python
lst = [3, 0, 2, 2, 1]
print(lst[lst[0]])
print(lst[lst[4]])
for i in range(len(lst)):
if lst[i] == i:
print("שווה במקום", i)
```
הפלט:
```text
2
0
שווה במקום 2
```
`lst[0]` הוא 3, ולכן `lst[lst[0]]` הוא `lst[3]`, כלומר 2. רק במקום 2 הערך שווה למיקום.
### תרגיל 25 🔴: הרצף העולה הארוך ביותר
```python
temps = [18, 20, 23, 21, 22, 25, 27, 28, 24]
run = 1
best = 1
for i in range(len(temps) - 1):
if temps[i + 1] > temps[i]:
run += 1
if run > best:
best = run
else:
run = 1
print("הרצף העולה הארוך ביותר:", best)
```
הפלט:
```text
הרצף העולה הארוך ביותר: 5
```
הרצף הוא 21, 22, 25, 27, 28.
### תרגיל 26 🔴: כל מספר בדיוק פעם אחת
```python
for lst in [[3, 1, 4, 2], [3, 1, 3, 2]]:
n = len(lst)
counts = [0] * (n + 1)
ok = True
for x in lst:
if x < 1 or x > n:
ok = False
else:
counts[x] += 1
for v in range(1, n + 1):
if counts[v] != 1:
ok = False
print(lst, ok)
```
הפלט:
```text
[3, 1, 4, 2] True
[3, 1, 3, 2] False
```
---
## 4. מילון (`dict`)
### תרגיל 27 🟢: ספר טלפונים
```python
phones = {}
phones["נור"] = "050-1111111"
phones["אדם"] = "052-2222222"
phones["מאיה"] = "054-3333333"
print(phones["נור"])
if "רון" in phones:
print("רון נמצא")
else:
print("רון לא נמצא")
for name in phones.keys():
print(name)
```
הפלט:
```text
050-1111111
רון לא נמצא
נור
אדם
מאיה
```
### תרגיל 28 🟢: מחירון
```python
prices = {"עט": 4, "מחברת": 9, "מחק": 2}
print(prices["מחברת"])
for item, price in prices.items():
print(item, price)
total = 0
for item in ["עט", "עט", "מחברת"]:
total += prices[item] # access by key
print("לתשלום:", total)
```
הפלט:
```text
9
עט 4
מחברת 9
מחק 2
לתשלום: 17
```
### תרגיל 29 🟡: ספירת מילים
```python
sentence = input("משפט: ")
counts = {} # an empty dictionary
for word in sentence.split():
if word in counts:
counts[word] += 1
else:
counts[word] = 1 # insert a new key
for word, n in counts.items():
print(word, n)
```
הקלט: `כן לא כן אולי כן לא`
הפלט:
```text
משפט: כן לא כן אולי כן לא
כן 3
לא 2
אולי 1
```
### תרגיל 30 🟡: אותיות שחוזרות
```python
word = input("מילה: ")
counts = {}
for ch in word:
if ch in counts:
counts[ch] += 1
else:
counts[ch] = 1
for ch in counts.keys():
if counts[ch] > 1:
print(ch, counts[ch])
```
הקלט: `banana`
הפלט:
```text
מילה: banana
a 3
n 2
```
### תרגיל 31 🔴: ממוצע לכל תלמיד
```python
pairs = [("דנה", 90), ("עומר", 60), ("דנה", 80), ("עומר", 100), ("לין", 75)]
grades = {}
for name, grade in pairs:
if name not in grades:
grades[name] = []
grades[name].append(grade)
for name in grades:
print(name, sum(grades[name]) / len(grades[name]))
```
הפלט:
```text
דנה 85.0
עומר 80.0
לין 75.0
```
### תרגיל 32 🔴: מילון הפוך
```python
cities = {"נור": "ירכא", "אדם": "עכו", "מאיה": "ירכא", "רון": "חיפה"}
by_city = {}
for name, city in cities.items():
if city not in by_city:
by_city[city] = []
by_city[city].append(name)
for city in by_city:
print(city, by_city[city])
```
הפלט:
```text
ירכא ['נור', 'מאיה']
עכו ['אדם']
חיפה ['רון']
```
---
## 5. קבצים (`txt` בלבד): קריאה, כתיבה, `split`
### תרגיל 33 🟢: מספור שורות
```python
file = open("names.txt", "r", encoding="utf-8")
n = 1
for line in file:
print(str(n) + ".", line.strip())
n += 1
file.close()
```
הפלט:
```text
1. נור
2. אדם
3. מאיה
```
### תרגיל 34 🟢: כתיבה ואחר כך קריאה
```python
file = open("squares.txt", "w", encoding="utf-8")
for i in range(1, 6):
file.write(str(i * i) + "\n") # write() takes a string only
file.close()
file = open("squares.txt", "r", encoding="utf-8")
print(file.read())
file.close()
```
הפלט:
```text
1
4
9
16
25
```
### תרגיל 35 🟡: הדוגמה מההנחיות: מי נכשל במתמטיקה
```python
file = open("grades.txt", "r", encoding="utf-8")
lines = list(file) # the same as file.readlines()
for line in lines:
data = line.split("#")
name = data[0]
subject = data[1]
grade = int(data[2]) # text from the file -> int
if subject == "מתמטיקה" and grade < 55:
print(name)
file.close()
```
הפלט:
```text
רון
דנה
```
`int("45\n")` מצליח, כי `int()` מתעלם מה‑`\n` שבסוף. אבל אם השדה האחרון היה טקסט, היה צריך `line.strip()` לפני ה‑`split`.
### תרגיל 36 🟡: שורת כותרת עם readline
```python
file = open("stock.txt", "r", encoding="utf-8")
title = file.readline() # only the first line
print(title.strip())
for line in file: # continues from the second line
parts = line.strip().split(",")
if int(parts[1]) < 10:
print(parts[0], parts[1])
file.close()
```
הפלט:
```text
מלאי סניף ירכא
עט 8
מחק 3
```
### תרגיל 37 🟡: שורות, מילים ותווים
```python
file = open("story.txt", "r", encoding="utf-8")
text = file.read() # the whole file as ONE string
file.close()
print("שורות:", len(text.split("\n")) - 1)
print("מילים:", len(text.split()))
print("תווים:", len(text))
```
הפלט:
```text
שורות: 3
מילים: 8
תווים: 36
```
הקובץ מסתיים ב‑`\n`, ולכן `split("\n")` מחזיר בסוף מחרוזת ריקה, ומחסירים 1. ב‑`len(text)` נספרים גם הרווחים וה‑`\n`.
### תרגיל 38 🔴: ממוצע לכל מקצוע, לקובץ חדש
```python
file = open("grades.txt", "r", encoding="utf-8")
sums = {}
counts = {}
for line in file: # loop over the lines of the file
data = line.strip().split("#")
subject = data[1]
grade = int(data[2])
if subject not in sums:
sums[subject] = 0
counts[subject] = 0
sums[subject] += grade
counts[subject] += 1
file.close()
out = open("summary.txt", "w", encoding="utf-8")
for subject in sums:
out.write(subject + ":" + str(sums[subject] / counts[subject]) + "\n")
out.close()
out = open("summary.txt", "a", encoding="utf-8")
out.write("סוף\n")
out.close()
check = open("summary.txt", "r", encoding="utf-8")
print(check.read())
check.close()
```
הפלט:
```text
מתמטיקה:64.0
אנגלית:71.5
היסטוריה:88.0
סוף
```
`write` מקבלת רק מחרוזת, ולכן הממוצע עובר דרך `str()`. ו‑`write` לא מוסיפה ירידת שורה לבד: כותבים `"\n"`.
### תרגיל 39 🔴: המצטיין בכל מקצוע
```python
file = open("grades.txt", "r", encoding="utf-8")
best = {} # subject -> [name, grade]
for line in file:
data = line.strip().split("#")
name, subject, grade = data[0], data[1], int(data[2])
if subject not in best or grade > best[subject][1]:
best[subject] = [name, grade]
file.close()
for subject, pair in best.items():
print(subject, pair[0], pair[1])
```
הפלט:
```text
מתמטיקה דני 95
אנגלית דנה 82
היסטוריה שירה 88
```
---
## 6. מחרוזות: `len`, `split`, `strip`, `lower`/`upper`, `replace`, `find`, חיתוך
### תרגיל 40 🟢: ניקוי קלט
```python
name = input("שם משתמש: ")
clean = name.strip().lower().replace(" ", "_")
print(clean)
print(len(clean))
```
הקלט: ` Ahmad Kais `
הפלט:
```text
שם משתמש: Ahmad Kais
ahmad_kais
10
```
### תרגיל 41 🟢: אינדקסים וחיתוך (שאלת מעקב)
```python
text = "Python"
print(text[0], text[-1], text[1:4])
print(text.upper(), text.find("th"), text.find("x"))
print(text.replace("P", "J"), len(text))
```
הפלט:
```text
P n yth
PYTHON 2 -1
Jython 6
```
`text[1:4]` הוא מהמקום 1 עד המקום 4, **לא כולל** 4: התווים במקומות 1, 2, 3.
### תרגיל 42 🟢: ראשונה, אחרונה ואמצעית
```python
word = input("מילה: ")
print(len(word))
print(word[0], word[-1], word[len(word) // 2])
```
הקלט: `python`
הפלט:
```text
מילה: python
6
p n h
```
### תרגיל 43 🟡: find וחיתוך: כתובת דוא"ל
```python
emails = ["dana@gmail.com", "omer.walla.co.il", "lin@atid.org"]
for e in emails:
at = e.find("@")
if at == -1:
print(e, "- כתובת לא תקינה")
else:
print(e[:at], e[at + 1:])
```
הפלט:
```text
dana gmail.com
omer.walla.co.il - כתובת לא תקינה
lin atid.org
```
### תרגיל 44 🟡: ספירת תנועות
```python
text = input("משפט: ").lower()
count = 0
for ch in text:
if ch in "aeiou":
count += 1
print(count)
```
הקלט: `I Love Python And SQL`
הפלט:
```text
משפט: I Love Python And SQL
5
```
### תרגיל 45 🔴: משפט פלינדרום
```python
text = input("משפט: ").replace(" ", "").lower()
ok = True
for i in range(len(text) // 2):
if text[i] != text[len(text) - 1 - i]:
ok = False
print(text, ok)
```
הקלט: `Never odd or even`
הפלט:
```text
משפט: Never odd or even
neveroddoreven True
```
### תרגיל 46 🔴: סכום מספרים מתוך מחרוזת
```python
text = "12,7,30, 5 ,8"
parts = text.split(",")
total = 0
biggest = int(parts[0].strip())
for p in parts:
n = int(p.strip())
total += n
if n > biggest:
biggest = n
print("סכום:", total, "הגדול:", biggest)
```
הפלט:
```text
סכום: 62 הגדול: 30
```