Python Programming (4311601) - Winter 2024 Solution (Gujarati)

પ્રશ્ન 1(અ) [3 ગુણ]

#

પ્રોબ્લમ સોલવિંગ, અલ્ગોરિધમ અને સ્યુડો કોડ વ્યાખ્યાયિત કરો.

જવાબ:

• પ્રોબ્લમ સોલવિંગ: જટિલ સમસ્યાઓને વ્યવસ્થિત પગલાઓમાં વહેંચવું
• અલ્ગોરિધમ: મર્યાદિત, નિશ્ચિત, અસરકારક અને યોગ્ય આઉટપુટ આપતું હોવું જોઈએ
• સ્યુડો કોડ: માનવ ભાષા અને programming કોડ વચ્ચેનો સેતુ

મેમરી ટ્રીક: “PAP - Problem, Algorithm, Pseudo”

પ્રશ્ન 1(બ) [4 ગુણ]

#

ફ્લોચાર્ટના જુદા જુદા સિમ્બોલ સમજાવો. બે નંબર માંથી મહત્તમ નંબર શોધતો ફ્લોચાર્ટ ડિઝાઇન કરો.

જવાબ:

બે નંબરના મહત્તમ માટે ફ્લોચાર્ટ:

flowchart LR
    A([શરૂઆત]) --> B[/A, B ઇનપુટ કરો/]
    B --> C{A > B?}
    C -->|હા| D[Max = A]
    C -->|ના| E[Max = B]
    D --> F[/Max દર્શાવો/]
    E --> F
    F --> G([અંત])

• શરૂઆત/અંત: પ્રવેશ અને બહાર નીકળવાના બિંદુઓ
• ઇનપુટ/આઉટપુટ: ડેટા ફ્લો ઓપરેશન્સ
• નિર્ણય: શરતી branching
• પ્રક્રિયા: ગણતરીના પગલાં

મેમરી ટ્રીક: “SIPO - Start, Input, Process, Output”

પ્રશ્ન 1(ક) [7 ગુણ]

#

પાયથોનના વિવિધ એરિથમેટિક ઓપરેટરોની યાદી બનાવો. વિવિધ એરિથમેટિક ઓપરેશન્સ માટેનો Python કોડ લખો.

જવાબ:

કોડ:

a = 10
b = 3
print(f"ઉમેરો: {a + b}")
print(f"બાદબાકી: {a - b}")
print(f"ગુણાકાર: {a * b}")
print(f"ભાગાકાર: {a / b}")
print(f"ફ્લોર ડિવિઝન: {a // b}")
print(f"મોડ્યુલસ: {a % b}")
print(f"ઘાત: {a ** b}")

મેમરી ટ્રીક: “Add-Sub-Mul-Div-Floor-Mod-Pow”

પ્રશ્ન 1(ક OR) [7 ગુણ]

#

પાયથોનના વિવિધ કંપેરિઝન ઓપરેટરોની યાદી બનાવો. વિવિધ કંપેરિઝન ઓપરેશન્સ માટેનો Python કોડ લખો.

જવાબ:

કોડ:

x = 8
y = 5
print(f"સમાન: {x == y}")
print(f"અસમાન: {x != y}")
print(f"મોટું: {x > y}")
print(f"નાનું: {x < y}")
print(f"મોટું સમાન: {x >= y}")
print(f"નાનું સમાન: {x <= y}")

મેમરી ટ્રીક: “Equal-Not-Greater-Less-GreaterEqual-LessEqual”

પ્રશ્ન 2(અ) [3 ગુણ]

#

મેમ્બરશિપ ઓપરેટર્સ ઉપર ટૂંક નોંધ લખો.

જવાબ:

• in ઓપરેટર: જો એલિમેન્ટ sequence માં મળે તો True આપે
• not in ઓપરેટર: જો એલિમેન્ટ sequence માં ન મળે તો True આપે
• ઉપયોગ: Lists, strings, tuples, dictionaries માં

મેમરી ટ્રીક: “In-Not-In for membership testing”

પ્રશ્ન 2(બ) [4 ગુણ]

#

પાયથોન વ્યાખ્યાયિત કરો. પાયથોન પ્રોગ્રામિંગની વિવિધ એપ્લિકેશનો લખો.

જવાબ:

પાયથોન વ્યાખ્યા: સરળતા અને વાંચનીયતા માટે જાણીતી high-level, interpreted programming language.

• Interpreted: compilation ની જરૂર નથી
• Cross-platform: બહુવિધ OS પર ચાલે છે
• વિશાળ libraries: વ્યાપક standard library

મેમરી ટ્રીક: “Web-Data-AI-Desktop-Games”

પ્રશ્ન 2(ક) [7 ગુણ]

#

પાયથોન પ્રોગ્રામ લખો જે નીચેની વિગતોનો ઉપયોગ કરીને વીજળી બિલની ગણતરી કરે છે.

જવાબ:

દરોનું ટેબલ:

કોડ:

units = int(input("વપરાયેલ યુનિટ્સ દાખલ કરો: "))

if units <= 100:
    bill = units * 5.00
elif units <= 200:
    bill = units * 7.50
elif units <= 300:
    bill = units * 10.00
else:
    bill = units * 15.00

print(f"કુલ બિલ: રૂ {bill}")

• શરતી તર્ક: if-elif-else structure
• દર ગણતરી: યુનિટ slabs આધારિત
• યુઝર ઇનપુટ: interactive billing system

મેમરી ટ્રીક: “Input-Check-Calculate-Display”

પ્રશ્ન 2(અ OR) [3 ગુણ]

#

આઇડેન્ટિટી ઓપરેટર્સ ઉપર ટૂંક નોંધ લખો.

જવાબ:

• is ઓપરેટર: ઓબ્જેક્ટ identity સરખાવે, values નહીં
• is not ઓપરેટર: ઓબ્જેક્ટ્સ જુદા છે કે નહીં ચકાસે
• મેમરી સરખામણી: સમાન મેમરી સ્થાન ચકાસે

મેમરી ટ્રીક: “Is-IsNot for object identity”

પ્રશ્ન 2(બ OR) [4 ગુણ]

#

પાયથોનમાં ઇન્ડેન્ટેશન શું છે? પાયથોનની વિવિધ વિશેષતાઓ સમજાવો.

જવાબ:

ઇન્ડેન્ટેશન: કોડ બ્લોક્સ વ્યાખ્યાયિત કરવા માટે લાઇનની શરૂઆતમાં whitespace.

• ઇન્ડેન્ટેશન: curly braces {} ને બદલે છે
• સુસંગત: સામાન્ય રીતે પ્રતિ level 4 spaces
• ફરજિયાત: કોડ માળખું બનાવે છે

મેમરી ટ્રીક: “Simple-Interpreted-Object-Cross-Large”

પ્રશ્ન 2(ક OR) [7 ગુણ]

#

પાયથોન પ્રોગ્રામ લખો જે નીચેની વિગતોનો ઉપયોગ કરીને વિદ્યાર્થીના વર્ગ/ગ્રેડની ગણતરી કરતો પાયથોન પ્રોગ્રામ લખો.

જવાબ:

ગ્રેડિંગ ટેબલ:

કોડ:

percentage = float(input("ટકાવારી દાખલ કરો: "))

if percentage >= 70:
    grade = "ડિસ્ટિંક્શન"
elif percentage >= 60:
    grade = "ફર્સ્ટ ક્લાસ"
elif percentage >= 50:
    grade = "સેકન્ડ ક્લાસ"
elif percentage >= 35:
    grade = "પાસ ક્લાસ"
else:
    grade = "નિષ્ફળ"

print(f"ગ્રેડ: {grade}")

• બહુવિધ શરતો: Nested if-elif structure
• ગ્રેડ નિર્ધારણ: ટકાવારી ranges આધારિત
• Float ઇનપુટ: દશાંશ ટકાવારી handle કરે

મેમરી ટ્રીક: “Distinction-First-Second-Pass-Fail”

પ્રશ્ન 3(અ) [3 ગુણ]

#

સિલેક્શન કંટ્રોલ સ્ટેટમેન્ટ શું છે? તેની યાદી બનાવો.

જવાબ:

• Selection statements: શરતો આધારે program flow control કરે
• Boolean evaluation: True/False logic વાપરે
• Branching: execution ના જુદા રસ્તાઓ

મેમરી ટ્રીક: “If-IfElse-IfElif-Nested”

પ્રશ્ન 3(બ) [4 ગુણ]

#

નેસ્ટેડ લૂપ ઉપર ટૂંક નોંધ લખો.

જવાબ:

• Nested માળખું: બીજા લૂપની અંદર લૂપ
• સંપૂર્ણ execution: આંતરિક લૂપ પૂરું થાય પછી બાહ્ય આગળ વધે
• Pattern creation: 2D structures માટે ઉપયોગી

કોડ ઉદાહરણ:

for i in range(3):
    for j in range(2):
        print(f"i={i}, j={j}")

મેમરી ટ્રીક: “Outer-Inner-Complete-Pattern”

પ્રશ્ન 3(ક) [7 ગુણ]

#

યુઝર ડિફાઇન ફંક્શન લખો જે 1 થી 100 સુધીની બધી સંખ્યાઓ દર્શાવે, જે 4 થી વિભાજ્ય છે.

જવાબ:

કોડ:

def display_divisible_by_4():
    print("1 થી 100 સુધીની 4 થી વિભાજ્ય સંખ્યાઓ:")
    for num in range(1, 101):
        if num % 4 == 0:
            print(num, end=" ")
    print()

# ફંક્શન કૉલ
display_divisible_by_4()

Return સાથે વિકલ્પ:

def get_divisible_by_4():
    return [num for num in range(1, 101) if num % 4 == 0]

result = get_divisible_by_4()
print(result)

• ફંક્શન વ્યાખ્યા: def keyword નો ઉપયોગ
• Range ફંક્શન: 1 થી 100 iteration
• Modulus ચકાસણી: num % 4 == 0 શરત
• List comprehension: વૈકલ્પિક અભિગમ

મેમરી ટ્રીક: “Define-Range-Check-Display”

પ્રશ્ન 3(અ OR) [3 ગુણ]

#

રિપીટેશન કંટ્રોલ સ્ટેટમેન્ટ શું છે? તેની યાદી બનાવો.

જવાબ:

• Repetition statements: કોડ બ્લોક્સ વારંવાર execute કરે
• Iteration control: looping ની જુદી પદ્ધતિઓ
• Loop variables: iteration progress track કરે

મેમરી ટ્રીક: “For-While-Nested”

પ્રશ્ન 3(બ OR) [4 ગુણ]

#

break અને continue સ્ટેટમેન્ટ વચ્ચેનો તફાવત આપો.

જવાબ:

કોડ ઉદાહરણ:

# break ઉદાહરણ
for i in range(5):
    if i == 3:
        break
    print(i)  # આઉટપુટ: 0, 1, 2

# continue ઉદાહરણ  
for i in range(5):
    if i == 2:
        continue
    print(i)  # આઉટપુટ: 0, 1, 3, 4

મેમરી ટ્રીક: “Break-Exit, Continue-Skip”

પ્રશ્ન 3(ક OR) [7 ગુણ]

#

યુઝર ડિફાઇન ફંક્શન લખો જે 1 થી 100 સુધીની બધી બેકી સંખ્યાઓ દર્શાવે.

જવાબ:

કોડ:

def display_even_numbers():
    print("1 થી 100 સુધીની બેકી સંખ્યાઓ:")
    for num in range(2, 101, 2):
        print(num, end=" ")
    print()

# વૈકલ્પિક પદ્ધતિ
def display_even_alt():
    even_nums = []
    for num in range(1, 101):
        if num % 2 == 0:
            even_nums.append(num)
    print(even_nums)

# ફંક્શન કૉલ
display_even_numbers()

• કાર્યક્ષમ range: બેકી સંખ્યાઓ માટે range(2, 101, 2)
• Modulus પદ્ધતિ: % 2 == 0 સાથે વૈકલ્પિક ચકાસણી
• ફંક્શન ડિઝાઇન: પુનઃઉપયોગી કોડ બ્લોક

મેમરી ટ્રીક: “Range-Step-Even-Display”

પ્રશ્ન 4(અ) [3 ગુણ]

#

ફંક્શન વ્યાખ્યાયિત કરો. પાયથોનમાં ઉપલબ્ધ વિવિધ પ્રકારના ફંક્શનની યાદી આપો.

જવાબ:

ફંક્શન: ખાસ કાર્ય કરતો પુનઃઉપયોગી કોડ બ્લોક.

• કોડ પુનઃઉપયોગ: એકવાર લખો, ઘણીવાર વાપરો
• મોડ્યુલારિટી: જટિલ સમસ્યાઓને નાના ભાગોમાં વહેંચવી
• Parameters: ફંક્શન્સ માટે ઇનપુટ values

મેમરી ટ્રીક: “Built-User-Lambda-Recursive”

પ્રશ્ન 4(બ) [4 ગુણ]

#

વેરિએબલના સ્કોપ ઉપર ટૂંક નોંધ લખો.

જવાબ:

કોડ ઉદાહરણ:

x = 10  # Global variable

def my_function():
    y = 20  # Local variable
    print(x)  # Global access
    print(y)  # Local access

my_function()
# print(y)  # Error: y accessible નથી

• Variable accessibility: variables ક્યાં વાપરી શકાય
• LEGB rule: Local, Enclosing, Global, Built-in

મેમરી ટ્રીક: “Local-Global-Builtin”

પ્રશ્ન 4(ક) [7 ગુણ]

#

Python કોડ લખો જે ઉપભોક્તાને મુખ્ય સ્ટ્રિંગ અને સબસ્ટ્રિંગ માટે પૂછે છે અને મુખ્ય સ્ટ્રિંગમાં સબસ્ટ્રિંગની મેમ્બરશિપ તપાસે છે.

જવાબ:

કોડ:

def check_substring():
    main_string = input("મુખ્ય સ્ટ્રિંગ દાખલ કરો: ")
    substring = input("સબસ્ટ્રિંગ દાખલ કરો: ")
    
    if substring in main_string:
        print(f"'{substring}' મળ્યું '{main_string}' માં")
        print(f"સ્થિતિ: {main_string.find(substring)}")
    else:
        print(f"'{substring}' મળ્યું નથી '{main_string}' માં")

# વિસ્તૃત વર્ઝન case handling સાથે
def check_substring_enhanced():
    main_string = input("મુખ્ય સ્ટ્રિંગ દાખલ કરો: ")
    substring = input("સબસ્ટ્રિંગ દાખલ કરો: ")
    
    if substring.lower() in main_string.lower():
        print("સબસ્ટ્રિંગ મળ્યું (case-insensitive)")
    else:
        print("સબસ્ટ્રિંગ મળ્યું નથી")

check_substring()

• યુઝર ઇન્ટરેક્શન: string collection માટે input()
• Membership testing: ‘in’ operator નો ઉપયોગ
• Case sensitivity: વૈકલ્પિક case handling

મેમરી ટ્રીક: “Input-Check-Report-Position”

પ્રશ્ન 4(અ OR) [3 ગુણ]

#

લોકલ વેરિએબલ અને ગ્લોબલ વેરિએબલ શું છે?

જવાબ:

ઉદાહરણ:

global_var = 100  # Global

def function():
    local_var = 50  # Local
    print(global_var)  # ✓ સુલભ
    print(local_var)   # ✓ સુલભ

print(global_var)  # ✓ સુલભ
# print(local_var)  # ✗ Error

• Local variables: ફંક્શન્સની અંદર બનાવાયેલ
• Global variables: ફંક્શન્સની બહાર બનાવાયેલ

મેમરી ટ્રીક: “Local-Limited, Global-Everywhere”

પ્રશ્ન 4(બ OR) [4 ગુણ]

#

પાયથોનના કોઈપણ ચાર બિલ્ટ-ઇન ફંક્શન સમજાવો.

જવાબ:

વધારાના ઉદાહરણો:

# len() ફંક્શન
print(len([1, 2, 3, 4]))  # આઉટપુટ: 4

# type() ફંક્શન  
print(type(3.14))  # આઉટપુટ: <class 'float'>

# input() ફંક્શન
age = input("ઉંમર દાખલ કરો: ")

# print() ફંક્શન
print("તમારી ઉંમર છે:", age)

મેમરી ટ્રીક: “Length-Type-Input-Print”

પ્રશ્ન 4(ક OR) [7 ગુણ]

#

Python કોડ લખો જે આપેલ સ્ટ્રિંગમાં સબસ્ટ્રિંગને શોધે છે.

જવાબ:

કોડ:

def locate_substring():
    main_string = input("મુખ્ય સ્ટ્રિંગ દાખલ કરો: ")
    substring = input("શોધવા માટે સબસ્ટ્રિંગ દાખલ કરો: ")
    
    # પદ્ધતિ 1: find() વાપરીને
    position = main_string.find(substring)
    if position != -1:
        print(f"index પર મળ્યું: {position}")
    else:
        print("સબસ્ટ્રિંગ મળ્યું નથી")
    
    # પદ્ધતિ 2: index() exception handling સાથે
    try:
        position = main_string.index(substring)
        print(f"index પર સ્થિત: {position}")
    except ValueError:
        print("સબસ્ટ્રિંગ મળ્યું નથી")
    
    # પદ્ધતિ 3: બધી occurrences શોધો
    positions = []
    start = 0
    while True:
        pos = main_string.find(substring, start)
        if pos == -1:
            break
        positions.append(pos)
        start = pos + 1
    
    if positions:
        print(f"બધી સ્થિતિઓ: {positions}")

locate_substring()

• find() method: index આપે અથવા -1
• index() method: index આપે અથવા exception raise કરે
• બહુવિધ occurrences: બધી સ્થિતિઓ શોધવા માટે લૂપ

મેમરી ટ્રીક: “Find-Index-Exception-Multiple”

પ્રશ્ન 5(અ) [3 ગુણ]

#

સ્ટ્રિંગ વ્યાખ્યાયિત કરો. વિવિધ સ્ટ્રિંગ ઓપરેશન્સની યાદી બનાવો.

જવાબ:

સ્ટ્રિંગ: quotes માં બંધ characters ની sequence.

• Immutable: સ્ટ્રિંગ બનાવ્યા પછી બદલી શકાતી નથી
• Indexing: વ્યક્તિગત characters access કરવું
• Methods: manipulation માટે built-in functions

મેમરી ટ્રીક: “Concat-Repeat-Slice-Length-Case”

પ્રશ્ન 5(બ) [4 ગુણ]

#

આપણે કેવી રીતે ઓળખી શકીએ કે એલિમેન્ટ એ લિસ્ટનો સભ્ય છે કે નહીં? યોગ્ય ઉદાહરણ સાથે સમજાવો.

જવાબ:

ઉદાહરણ:

fruits = ["apple", "banana", "orange", "mango"]

# 'in' ઓપરેટર વાપરીને
if "apple" in fruits:
    print("Apple ઉપલબ્ધ છે")

# 'not in' ઓપરેટર વાપરીને  
if "grapes" not in fruits:
    print("Grapes ઉપલબ્ધ નથી")

# count() method વાપરીને
count = fruits.count("apple")
if count > 0:
    print(f"Apple {count} વખત મળ્યું")

• Boolean પરિણામ: મળે તો True, નહીં તો False
• Case sensitive: “Apple” ≠ “apple”
• કાર્યક્ષમતા: ‘in’ ઓપરેટર સૌથી સામાન્ય

મેમરી ટ્રીક: “In-NotIn-Count for membership”

પ્રશ્ન 5(ક) [7 ગુણ]

#

Python કોડ લખો જે આપેલ સ્ટ્રિંગના બીજા સબસ્ટ્રિંગ સાથે સબસ્ટ્રિંગને બદલે છે. આપેલ સ્ટ્રિંગ ‘Welcome to GTU’ તરીકે ધ્યાનમાં લો અને સબસ્ટ્રિંગ ‘GTU’ ને ‘Gujarat Technological University’ સાથે બદલો.

જવાબ:

કોડ:

def replace_substring():
    # આપેલ સ્ટ્રિંગ
    original = "Welcome to GTU"
    old_substring = "GTU"
    new_substring = "Gujarat Technological University"
    
    # પદ્ધતિ 1: replace() વાપરીને
    result1 = original.replace(old_substring, new_substring)
    print(f"મૂળ: {original}")
    print(f"બદલાયેલ: {result1}")
    
    # પદ્ધતિ 2: મેન્યુઅલ રિપ્લેસમેન્ટ
    if old_substring in original:
        index = original.find(old_substring)
        result2 = original[:index] + new_substring + original[index + len(old_substring):]
        print(f"મેન્યુઅલ પદ્ધતિ: {result2}")
    
    # પદ્ધતિ 3: બધી occurrences બદલો
    test_string = "GTU offers GTU degree from GTU"
    result3 = test_string.replace("GTU", "Gujarat Technological University")
    print(f"બહુવિધ બદલાવ: {result3}")

replace_substring()

આઉટપુટ:

મૂળ: Welcome to GTU
બદલાયેલ: Welcome to Gujarat Technological University

• replace() method: built-in string function
• Slicing method: મેન્યુઅલ string manipulation
• બધી occurrences: દરેક instance બદલે છે

મેમરી ટ્રીક: “Find-Replace-Slice-All”

પ્રશ્ન 5(અ OR) [3 ગુણ]

#

લિસ્ટ વ્યાખ્યાયિત કરો. વિવિધ લિસ્ટ ઓપરેશન્સની યાદી બનાવો.

જવાબ:

લિસ્ટ: ક્રમબદ્ધ items નો collection જે modify કરી શકાય છે.

• Mutable: લિસ્ટ બનાવ્યા પછી બદલી શકાય છે
• Indexed: સ્થિતિ દ્વારા elements access કરાય છે
• Dynamic: કદ વધી અથવા ઘટી શકે છે

મેમરી ટ્રીક: “Add-Remove-Access-Slice-Sort”

પ્રશ્ન 5(બ OR) [4 ગુણ]

#

સ્ટ્રિંગ સ્લાઇસિંગ ઉપર ટૂંક નોંધ લખો. યોગ્ય ઉદાહરણ સાથે સમજાવો.

જવાબ:

સ્ટ્રિંગ સ્લાઇસિંગ: [start🔚step] વાપરીને string ના ભાગો extract કરવું.

ઉદાહરણ:

text = "Python Programming"

print(text[0:6])    # "Python"
print(text[7:])     # "Programming"  
print(text[:6])     # "Python"
print(text[::2])    # "Pto rgamn"
print(text[::-1])   # "gnimmargorP nohtyP"

• Negative indexing: છેલ્લા character માટે -1
• Step parameter: increment control કરે છે

મેમરી ટ્રીક: “Start-End-Step for slicing”

પ્રશ્ન 5(ક OR) [7 ગુણ]

#

Python કોડ લખો જે લિસ્ટમાં સ્પેસિફાઇડ એલિમેન્ટ કેટલી વખત દેખાય છે તેની ગણતરી કરે છે.

જવાબ:

કોડ:

def count_element_occurrences():
    # નમૂના લિસ્ટ બનાવો
    numbers = [1, 2, 3, 2, 4, 2, 5, 2, 6]
    element = int(input("ગણવા માટે એલિમેન્ટ દાખલ કરો: "))
    
    # પદ્ધતિ 1: count() method વાપરીને
    count1 = numbers.count(element)
    print(f"count() વાપરીને: {element} એ {count1} વખત દેખાય છે")
    
    # પદ્ધતિ 2: મેન્યુઅલ ગણતરી
    count2 = 0
    for num in numbers:
        if num == element:
            count2 += 1
    print(f"મેન્યુઅલ ગણતરી: {element} એ {count2} વખત દેખાય છે")
    
    # પદ્ધતિ 3: List comprehension
    count3 = len([x for x in numbers if x == element])
    print(f"List comprehension: {element} એ {count3} વખત દેખાય છે")
    
    # પદ્ધતિ 4: કોઈપણ પ્રકારની લિસ્ટ માટે
    mixed_list = [1, "hello", 3.14, "hello", True, "hello"]
    element_str = input("મિશ્ર લિસ્ટમાં શોધવા માટે એલિમેન્ટ દાખલ કરો: ")
    count4 = mixed_list.count(element_str)
    print(f"મિશ્ર લિસ્ટમાં: '{element_str}' એ {count4} વખત દેખાય છે")

count_element_occurrences()

• count() method: built-in list function
• મેન્યુઅલ iteration: ગણતરી માટે loops વાપરવું
• List comprehension: ગણતરીની Pythonic રીત
• Type flexibility: કોઈપણ ડેટા ટાઇપ સાથે કામ કરે

મેમરી ટ્રીક: “Count-Manual-Comprehension-Flexible”