0% found this document useful (0 votes)
4 views

lab task mobile application development

Uploaded by

O'levels Academy
Copyright
© © All Rights Reserved
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
4 views

lab task mobile application development

Uploaded by

O'levels Academy
Copyright
© © All Rights Reserved
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 17

Lab task 5:

Question no1:

void greet({ String? name, int? age = 0, String? city = 'Unknown'}) {


print('Hello, $name! You are $age years old and live in $city.');
}
void main() {
greet(name: 'Alia', age: 25, city: 'New York');
greet(name: 'Hamza');
greet(name: 'Ali', city: 'Los Angeles');
}

Output:

Question no2:

double calculateA(double a, double b) => (a * a) + (b * b * b * b);


double calculateZ(double p, double t, double A) => (p * p) + (5 * t) + A;
void main() {

print(calculateA(3.0, 2.0));
print(calculateZ(4.0, 5.0, 3.0));

Output:
Question no3:

double calculateA(double x, double p, double Z) => (x * x) + (2 * x * x)


+ (p * Z);
double calculateZ(double a, double B, double b) => (a * a) + (4 * B * B)
- (8 * b) + (2 * a);
double calculateB(double n, double q) => (n * n) + (q * q) + 1;
void main() {

print(calculateA(3.0, 2.0, 4.0));


print(calculateA(2.0, 3.0, 5.0));
print(calculateB(4.0,5.0));

Output:

Question no4:
double calculateZ(double x, double y, double p, double q) {
double calculateN() => (p * p) + (q * q);
return (x * x) + (4 * y * y) - (8 * calculateN());
}

void main() {
print(calculateZ(3.0, 2.0, 5.0, 2.0));
}

Output:

Question no5:
void main() {
List<String> fruits = ['apples', 'bananas', 'oranges'];
var modifiedFruits = fruits.map((fruit) => '${fruit.toUpperCase()}$
{fruit.substring(1)} is delicious');
modifiedFruits.forEach((fruit) => print(fruit));

Output:

Question no6:

typedef Operation = double Function(double a, double b);


double add(double a, double b) => a + b;
double subtract(double a, double b) => a - b;
double multiply(double a, double b) => a * b;
double divide(double a, double b) {
if (b == 0) {
print("Cannot divide by zero.");
return double.nan;
}
return a / b;
}
double calculate(double a, double b, Operation operation) => operation(a,
b);

void main() {
double x = 10;
double y = 5;
print('Addition: ${calculate(x, y, add)}');
print('Subtraction: ${calculate(x, y, subtract)}');
print('Multiplication: ${calculate(x, y, multiply)}');
print('Division: ${calculate(x, y, divide)}');
}

Output:

Question no7:
void main() {
List<Map<String, String>> myArray = [
{'name': 'ali', 'age': '45'},
{'name': 'noman', 'age': '34'},
];

print('Keys and Values:');


myArray.forEach((element) {
element.forEach((key, value) {
print('$key: $value');
});
});
print('\nValues Only:');
myArray.forEach((element) {
print(element.values);
});
}

Output:

Question no8:
void main() {
var myArray1 = [3, 4, 5];
var myArray2 = [6, 7, 8];

myArray1.addAll(myArray2);

print(myArray1);
}
Output:

Question no9:
void main() {
double calculateArea(double length, double width) {

double calculatePerimeter() => 2 * (length + width);

print('Perimeter: ${calculatePerimeter()}');

return length * width;


}

double length = 5.0;


double width = 3.0;

double area = calculateArea(length, width);


print('Area: $area');
}

Output:
Question no 10:
class Employee {
int id;
String name;
int age;
Employee(this.id, this.name, this.age);
void displayDetails() {
print('ID: $id, Name: $name, Age: $age');
}
}

class Staff extends Employee {


double salary;
String hireDate;
List<Map<String, dynamic>> completedProjects;

Staff(id, String name, int age, this.salary, this.hireDate,


this.completedProjects)
: super(id, name, age);

double averagePerformanceScore() {
if (completedProjects.isEmpty) return 0.0;

double totalScore = completedProjects.fold(0.0, (sum, project) => sum


+ project['performance_score']);
return totalScore / completedProjects.length;
}
}

class Manager extends Employee {


double salary;
String position;
String department;
List<Map<String, String>> teamMembers;

Manager(int id, String name, int age, this.salary, this.position,


this.department, this.teamMembers)
: super(id, name, age);

void displayTeamMembers() {
print('Team members of Manager $name in department $department:');
teamMembers.forEach((member) {
print('ID: ${member.keys.first}, Name: ${member.values.first}');
});
}
}

Employee? searchById(List<Employee> employees, int id) {


return employees.firstWhere((employee) => employee.id == id);
}

List<Staff> listHighPerformingStaff(List<Staff> staffList) {


return staffList.where((staff) => staff.averagePerformanceScore() >
4.5).toList();
}

List<Manager> managersInDepartment(List<Manager> managers, String


department) {
return managers
.where((manager) => manager.department == department)
.toList()
..sort((a, b) => b.salary.compareTo(a.salary));
}

void main() {

List<Employee> employees = [];

Staff staff1 = Staff(1, 'Ali', 30, 50000, '2020-01-15', [


{'project_name': 'Project A', 'performance_score': 4.8},
{'project_name': 'Project B', 'performance_score': 4.6},
]);

Staff staff2 = Staff(2, 'Noman', 25, 45000, '2021-03-10', [


{'project_name': 'Project C', 'performance_score': 4.2},
{'project_name': 'Project D', 'performance_score': 4.7},
]);

Staff staff3 = Staff(3, 'Sara', 28, 55000, '2019-11-05', [


{'project_name': 'Project E', 'performance_score': 4.9},
]);

employees.add(staff1);
employees.add(staff2);
employees.add(staff3);

// Creating Manager members


Manager manager1 = Manager(4, 'John', 40, 70000, 'Team Lead', 'IT', [
{'1': 'Ali'},
{'2': 'Noman'},
]);

Manager manager2 = Manager(5, 'Jane', 35, 80000, 'Department Head',


'Finance', [
{'3': 'Sara'},
]);

employees.add(manager1);
employees.add(manager2);

// Display details of all employees


print('Employee Details:');
employees.forEach((employee) => employee.displayDetails());

// Search for an employee by ID


int searchId = 2;
Employee? foundEmployee = searchById(employees, searchId);
if (foundEmployee != null) {
print('\nFound Employee:');
foundEmployee.displayDetails();
} else {
print('\nEmployee with ID $searchId not found.');
}

// List staff members with a performance score greater than 4.5


List<Staff> highPerformingStaff =
listHighPerformingStaff(employees.whereType<Staff>().toList());
print('\nHigh Performing Staff:');
highPerformingStaff.forEach((staff) {
print('${staff.name} with average performance score: $
{staff.averagePerformanceScore()}');
});

// Display managers in a specific department sorted by salary


String departmentToCheck = 'IT';
List<Manager> itManagers =
managersInDepartment(employees.whereType<Manager>().toList(),
departmentToCheck);
print('\nManagers in $departmentToCheck department (sorted by
salary):');
itManagers.forEach((manager) {
print('${manager.name} - Salary: \$${manager.salary}');
manager.displayTeamMembers();
});
}

Output:
Question no 11:
class Vehicle {
int vehicleId;
String make;
int modelYear;

Vehicle({
required this.vehicleId,
required this.make,
required this.modelYear,
});

void displayDetails() {
print('Vehicle ID: $vehicleId, Make: $make, Model Year: $modelYear');
}
}

class Car extends Vehicle {


double mileage;
String fuelType;
List<Map<String, dynamic>> serviceRecords;

Car({
required int vehicleId,
required String make,
required int modelYear,
required this.mileage,
required this.fuelType,
required this.serviceRecords,
}) : super(vehicleId: vehicleId, make: make, modelYear: modelYear);

double totalServiceCost() {
return serviceRecords.fold(0.0, (total, record) => total +
(record['cost'] as double));
}
}

class Truck extends Vehicle {


double payloadCapacity;
int axles;
List<Map<String, String>> deliveries;

Truck({
required int vehicleId,
required String make,
required int modelYear,
required this.payloadCapacity,
required this.axles,
required this.deliveries,
}) : super(vehicleId: vehicleId, make: make, modelYear: modelYear);

void displayDeliveries() {
print('Deliveries for Truck ID: $vehicleId');
deliveries.forEach((delivery) {
delivery.forEach((deliveryId, destination) {
print('Delivery ID: $deliveryId, Destination: $destination');
});
});
}
}

Vehicle? searchVehicleById(List<Vehicle> vehicles, int vehicleId) {


return vehicles.firstWhere((vehicle) => vehicle.vehicleId ==
vehicleId);
}

List<Car> listHighMileageCars(List<Car> cars) {


return cars.where((car) => car.mileage > 100000).toList();
}

List<Truck> trucksByPayloadCapacity(List<Truck> trucks, double


payloadCapacity) {
return trucks
.where((truck) => truck.payloadCapacity == payloadCapacity)
.toList()
..sort((a, b) => b.axles.compareTo(a.axles));
}

void main() {
List<Vehicle> vehicles = [];

Car car1 = Car(


vehicleId: 1,
make: 'Toyota',
modelYear: 2015,
mileage: 120000,
fuelType: 'Petrol',
serviceRecords: [
{'service_date': DateTime(2022, 5, 1), 'cost': 200.0},
{'service_date': DateTime(2023, 5, 1), 'cost': 250.0},
],
);

Car car2 = Car(


vehicleId: 2,
make: 'Honda',
modelYear: 2018,
mileage: 90000,
fuelType: 'Diesel',
serviceRecords: [
{'service_date': DateTime(2022, 4, 1), 'cost': 150.0},
],
);

Car car3 = Car(


vehicleId: 3,
make: 'Ford',
modelYear: 2012,
mileage: 110000,
fuelType: 'Petrol',
serviceRecords: [
{'service_date': DateTime(2021, 10, 1), 'cost': 300.0},
{'service_date': DateTime(2023, 1, 1), 'cost': 350.0},
],
);

vehicles.add(car1);
vehicles.add(car2);
vehicles.add(car3);

// Create sample Trucks


Truck truck1 = Truck(
vehicleId: 4,
make: 'Volvo',
modelYear: 2015,
payloadCapacity: 20000,
axles: 2,
deliveries: [
{'1': 'City A'},
{'2': 'City B'},
],
);

Truck truck2 = Truck(


vehicleId: 5,
make: 'Mack',
modelYear: 2018,
payloadCapacity: 15000,
axles: 3,
deliveries: [
{'3': 'City C'},
],
);

Truck truck3 = Truck(


vehicleId: 6,
make: 'Kenworth',
modelYear: 2020,
payloadCapacity: 20000,
axles: 2,
deliveries: [
{'4': 'City D'},
{'5': 'City E'},
],
);

vehicles.add(truck1);
vehicles.add(truck2);
vehicles.add(truck3);

print('Vehicle Details:');
vehicles.forEach((vehicle) => vehicle.displayDetails());

int searchId = 2;
Vehicle? foundVehicle = searchVehicleById(vehicles, searchId);
if (foundVehicle != null) {
print('\nFound Vehicle:');
foundVehicle.displayDetails();
} else {
print('\nVehicle with ID $searchId not found.');
}

List<Car> highMileageCars =
listHighMileageCars(vehicles.whereType<Car>().toList());
print('\nCars with mileage greater than 100,000 km:');
highMileageCars.forEach((car) {
print('ID: ${car.vehicleId}, Make: ${car.make}, Mileage: $
{car.mileage}');
});

double specificPayload = 20000;


List<Truck> sortedTrucks =
trucksByPayloadCapacity(vehicles.whereType<Truck>().toList(),
specificPayload);
print('\nTrucks with payload capacity $specificPayload, sorted by
axles:');
sortedTrucks.forEach((truck) {
print('ID: ${truck.vehicleId}, Make: ${truck.make}, Axles: $
{truck.axles}');
truck.displayDeliveries();
});
}
Output:

You might also like