Python Coding Challenge - Question with Answer (01131125)

 

Explanation:

Create a List

nums = [2, 4, 6]

A list named nums is created with three integer elements: 2, 4, and 6.

This will be used to calculate the average of its elements later.

Initialize Loop Control Variables

i = 0

s = 0

i → Acts as a loop counter, starting from 0.

s → A sum accumulator initialized to 0.

It will store the running total of the numbers in the list.

Start the While Loop

while i < len(nums):

The loop runs as long as i is less than the length of the list nums.

Since len(nums) is 3, this means the loop will run while i = 0, 1, 2.

This ensures every element in the list is processed once.

Add the Current Element to the Sum

    s += nums[i]

At each loop iteration:

The element at index i is accessed: nums[i].

It is added to the sum s.

Example of how s changes:

When i=0: s = 0 + 2 = 2

When i=1: s = 2 + 4 = 6

When i=2: s = 6 + 6 = 12

Increment the Loop Counter

    i += 1

After processing one element, i increases by 1.

This moves to the next element of the list in the next iteration.

Print the Final Result

print(s // len(nums))

Once the loop ends, the total sum s is 12.

The expression s // len(nums) performs integer division:

12 // 3 = 4

Hence, it prints the average (integer form) of the list elements.

Final Output

4

Probability and Statistics using Python

Read More

Top 8 Python Libraries for Deep Learning in 2026

 

1 Tensorflow: The insdustry standard

import tensorflow as tf

x = tf.constant([[1.0, 2.0], [3.0, 4.0]])
y = tf.constant([[5.0, 6.0], [7.0, 8.0]])
result = tf.matmul(x, y)
print(result)

Output:

tf.Tensor(
[[19. 22.]
 [43. 50.]], shape=(2, 2), dtype=float32)

2. Pytocrh- Reasearchers favourite
import torch
x-torch.tensor([[1.,2.],[3.,4.]])
y=torch.tensor([[2.,0.],[0.,2.]])
print(torch.mm(x,y))
Output:
tensor([[2., 4.],
        [6., 8.]])


3. Kera- The beginner deep learning Friend
from tensorflow import keras
from tensorflow.keras import layers
model=keras.Sequential([
    keras.Input(shape=(3,)),
    layers.Dense(4,activation='relu'),
    layers.Dense(1)
])
model.summary()

Output:
Model: "sequential_2"
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┓
┃ Layer (type)                         ┃ Output Shape                ┃         Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━┩
│ dense_5 (Dense)                      │ (None, 4)                   │              16 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dense_6 (Dense)                      │ (None, 1)                   │               5 │
└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘
 Total params: 21 (84.00 B)
 Trainable params: 21 (84.00 B)
 Non-trainable params: 0 (0.00 B)

4. JAX – High-Speed, GPU-Accelerated Computing

import jax.numpy as jnp
from jax import grad
def f(x):
    return x**2+3*x +2

df=grad(f)
print(df(5.0))

Output:
13.0

5. Optuna – Smart Hyperparameter Tuning

import optuna
optuna.logging.set_verbosity(optuna.logging.WARNING)

def objective(trial):
    x = trial.suggest_float('x', -10, 10)
    return (x - 3)**2

study = optuna.create_study(direction='minimize')
study.optimize(objective, n_trials=10)
print(study.best_params)

Output:
{'x': 1.9064779937795588}

6. Numpy– Foundation of All Deep Learning Math

import numpy as np
x=np.array([[1,2,3],[4,5,6]])

print("Mean:",x.mean())
print("Dot product:\n", np.dot(x,x.T))

Output:
Mean: 3.5
Dot product:
 [[14 32]
 [32 77]]

7. Pandas – Data Handling for Deep Learning

import pandas as pd

data = {'Feature1': [1, 2, 3, 4],
        'Feature2': [2, 3, 4, 5],
        'Target': [3, 5, 7, 9]}

df = pd.DataFrame(data)
print(df.head())
print("Mean of Target:", df['Target'].mean())

Output:
   Feature1  Feature2  Target
0         1         2       3
1         2         3       5
2         3         4       7
3         4         5       9
Mean of Target: 6.0


8. scikit-learn

from sklearn.linear_model import LinearRegression
import numpy as np
X=np.array([[1],[2],[3],[4]])
y=np.array([2,4,6,8])

model=LinearRegression().fit(X,y)
print("Prediction for 5:",model.predict([[5]]))

Output:
Prediction for 5: [10.]

Read More

5 Lightweight ML Frameworks You Should Know in 2026

 

1. Scikit-learn — The All-Rounder ML Toolkit

from sklearn.linear_model import LinearRegression
import numpy as np
X=np.array([[1],[2],[3],[4]])
y=np.array([2,4,6,8])

model=LinearRegression().fit(X,y)
print("Prediction fopr input 5:",model.predict([[5]]))
#source code --> clcoding.com 

Output:

Prediction fopr input 5: [10.]

2. Statsmodel- For classic statisticl ML

import statsmodels.api as sm
import numpy as np
x=np.array([1,2,3,4])
y=np.array([2,4,6,8])
X=sm.add_constant(X)
model=sm.OLS(y,X).fit()
print(model.params)

#source code --> clcoding.com 
Output:
[0. 2.]


3. LightGBM — Fast Gradient Boosting by Microsoft

import lightgbm as lgb
import numpy as np
X=np.random.rand(10,3)
y=np.random.randint(0,2,10)
train_data=lgb.Dataset(X,label=y)
params={'objective':'binary','verbose':-1}
model=lgb.train(params,train_data,num_boost_round=10)
print("prediction:",model.predict(X[:3]))
#source code --> clcoding.com 

Output:
Predictions: [0.59171517 0.79370218 0.41264801 0.71209377 0.61403022 0.11052331
 0.18246353 0.61790422 0.72845184 0.49394298]

4.CatBoost — High-Performance Boosting by Yandex

from catboost import CatBoostRegressor
import numpy as np
X = np.random.rand(10, 3)
y = np.random.rand(10)
model = CatBoostRegressor(verbose=0)
model.fit(X, y)

predictions = model.predict(X)
print("Predictions:", predictions)
#source code --> clcoding.com 

Output:
Predictions: [0.59171517 0.79370218 0.41264801 0.71209377 0.61403022 0.11052331
 0.18246353 0.61790422 0.72845184 0.49394298]


5. H2O.ai— Scalable Yet Lightweight ML Framework

import h2o
from h2o.estimators.glm import  H2OGeneralizedLinearEstimator

h2o.init(max_mem_size="256M")
data=h20.H20Frame({'x':[1,2,3,4],'y':[2,4,6,8]})
model=H2OGeneralizedLinearEstimator(family="gaussian")
model.train(x=['x'],y='y',training_frame=data)
print(model.predict(data).head())

#source code --> clcoding.com 

Output:
Checking whether there is an H2O instance running at http://localhost:54321.....

Read More