Category: Python

1. In this assignment, you are going to write codes that calculate standard weight for male and female based on his or her height.
2. The standard weight formula:
male: height (in meters) * height * 48.5 (lbs)
female: height * height * 46 (lbs)
*For those who are not familiar with meters, convert the height in feet/inches to meters on Google.
3. Conditions:
a. First, define a function. Let’s call it “std_weight”
For example, def std_weight(____,____):
b. input variables are gender and height
c. round to two decimal places for weight
d. Sample output statement: “The standard weight for 1.75m male is 148.55lbs.”
4. Once you write codes, copy and paste them onto MS word doc.
Suggestions
1. First, define a function and indicate input variables
2. Use “if” statement for male case, compute the weight based on the formula, and print out the statement. Then, use “else” statement for female case. Follow the same suit as in male case

Summative assessment to assess students’ capabilities to use OO Programming concepts (i.e., Class, Objects, Inheritance, and Association, Polymorphism, Exception Handling) for a given case study. Students submit a report and Python code and later present the work in the class.
Case study is the same as you used for Assignment Part 1: Volunteering Management System.

In this assignment, you will use the web scraping methods that were covered in class to gain competitive intelligence on used cars. As your source, please use the recommended car dealership site that was provided with the sample code for this exercise. Please also use Jupyter Notebook to run your code.
Task 4-1: Pick a car make and model of your choice. Select two different cities or locations that you are interested in getting competitive data of your selected car. Extract the prices of your selected car for each of the locations you’ve identified by using the web scraping code provided. Visualizations of your results are encouraged here. (max. 2 points)
Task 4-2: Determine the average price point for your selected car in each of the locations identified. (max. 1 point)
Task 4-3: Calculate the depreciation of the car you’ve selected across the two locations identified. Compare this value across the two locations. Note: You have to use a depreciation formula to determine the depreciation of the car. (max. 3 points)
Task 4-4: Write a competitive intelligence report describing your findings for tasks 4-1 to 4-3. Provide your recommended price for a 3-year-old car of the model you’ve selected in both cities. The recommended length of the main body of the of the report should be 3 – 4 pages, APA format. Please include all screenshots as part of your appendices. (max. 2 points)

1. Capture your own video, where upper body, head, and shoulders, are visible, and natural/realistic movements are performed. You may want to consider a video with smooth uncluttered background for easier processing.
2. Detect the head position in each frame, using an existing method; two most popular approaches are the one of Viola-Jones (see HW1) as well as Convolutional Neural Networks (you can find such pre-trained models for face detection). The position of the head will serve as a “guide” for the next step.
3. Detect and track shoulder lines either for each shoulder independently, for both shoulders with two lines, or for both shoulders with a single line. Your choice should be towards increased robustness.
4. Detect shoulder shrugging throughout the video. In your execution, the event should be clearly indicated in the corresponding frames with either text superimposed on the frames or change of color of the calculated shoulder lines. Shoulder shrugging should be performed at different “intensities”, i.e. from subtle to exaggerated.
The video you will use should have max. duration of 1 minute, and it should contain at least 8-10 events (shrugging) that should be sufficiently spaced apart in time.
SUBMIT:
(i) Matlab or Python code.
(ii) Demo (screen recording) of the execution. The head region should be marked with blobs or boxes, while the shoulders should be marked with colored line(s), and displayed superimposed on each frame of the video. (-3pts if not submitted)

goto https://pyeda.readthedocs.io/en/latest/index.html
click lines on the left panel on the page shown above:
“Boolean algebra”, “binary decision diagram”, “Boolean expressions”
where you can find sampel code for creating boolean formulas, convert them to bdds, and perform operations on them
(and, or , negation, testing for satisfiability, changing variable names (.compose() method), etc.)
in particular .smoothing() is for quantifier elimination (you need search for the syntax of it. How to search? fill out the search box on the left panel of the link shown above).
these should be almost enough for completing the project.
All details can be found in PDF.

I’m doing a research and the objective of this research is to explore and compare model-less LLM-Based Planning (which directly generate as executable programs, without relying on any planning-domain model) and model-based LLM-driven task planning (which uses LLM to generates planning-domain models and then uses classical planners to generate plans). Both approaches have so far been demonstrated on simple problems. My work aims to experiment and compare them on more complex robot task scenarios, hoping to learn new valuable lessons on their respective virtues and limitations.
In Model-based LLM approach I will use this paper: Leveraging Pre-trained Large Language Models to Construct and Utilize World Models for Model-based Task Planning
The experiment part is to take code generated in Model-based LLM approach paper (The paper that I attached) which contains a planning domain in form of PPDL and make executable commands for each action in gazebo and make visuals in moveit.
those executable commands must be capable of using a ur5e robot to stack square boxes in a big container. Therefore, the environment scenario consists of 5 square boxes of different colors, big container box, and ur5e robot.
Note: the code for PPDL has been provided in a paper
https://guansuns.github.io/pages/llm-dm
https://we.tl/t-5KnlG11c5H
For the executable commands, it’s python . That means from PDDL to python. This executable commands are responsible for the movement of ur5e robot. For example To enable pick and place and other commands for stacking. But when it comes to defining the environment and models, it’s different since in Gazebo it’s not Python as far as I know. I don’t know if it makes sense in a way
Customer files

Jana Center:
to know more about Jana Center, please visit their website https://jana-sa.org/
Attached is sample paper, and dataset for further analysis (analysis shall be through python)
for the project objectives and the questions, below is one recommendation, you can as analyst change and adjust as needed.
Project objectives:
To identify and analyze the patterns and factors influencing loan disbursement and repayment among individuals in different regions of Saudi Arabia. This analysis aims to understand how demographic and socio-economic variables such as age, nationality, marital status, academic qualification, family income, number of dependents, and the sector of the loan influence the loan amount disbursed, the repayment rate, and the timing of loan disbursement.
Specific Questions to Address:
What are the demographic and socio-economic characteristics of individuals who apply for and receive loans in different regions of Saudi Arabia?
How does the loan disbursement amount vary across different sectors (e.g., cooking, salon businesses, makeup services) and demographic groups?
What factors contribute to a 100% repayment rate, and how can these insights inform strategies to improve loan repayment rates across all sectors?
Is there a relationship between the loan period, the amount disbursed, and the repayment rate?
How do external factors, such as the time of year or economic conditions, impact loan disbursement and repayment patterns?
PROJECT GENERAL GUIDELINES:
Singles-spaced.
1.5-2 pages max excluding references
Font size 11.
Two columns page setup.
References should be listed in an acceptable format (for example APA style).
Use headings and sub-headings styles.
Organizes the report in a logical and coherent manner.
Demonstrates effective communication skills with clear and concise writing.
Uses appropriate visualizations and diagrams to support the analysis.
Presents the technical details in a way that is understandable to a non-technical audience.
Provides appropriate citations and references to support claims and findings
Section1: Introduction & Problem Identification (2 pages)
Clearly defines the business problem or question to be addressed.
Describes the relevance and significance of the problem in the business context.
Provides a clear objective or goal for the project.
Identifies the target audience or stakeholders for the analysis.
Demonstrates a clear understanding of the data required to address the problem.
Section2: Background/Review of the Literature (2 pages)
Conducts a comprehensive review of relevant literature, theories, and frameworks related to the problem. (minimum 14)
Identifies and explains the key concepts and variables related to the problem.
Shows an understanding of existing research or similar projects in the field.
Analyzes and presents any existing data sources or datasets relevant to the problem.
Section3: Methodology (2 pages)
Clearly defines the methodology or approach used to address the problem.
Explains the rationale behind the chosen methodology (e.g., descriptive analytics, predictive analytics, prescriptive analytics).
Describes the data collection process and data preprocessing techniques used.
Discusses any assumptions or limitations of the chosen methodology.
Section4: Analysis and Findings
Performs appropriate data exploration and preprocessing techniques to gain insights from and prepare the data for analysis.
Applies relevant statistical or machine learning techniques to analyze the data.
Presents the analysis results in a clear and structured manner (e.g., data visualizations, summary statistics).
Provides a thorough interpretation and explanation of the analysis findings.
Evaluates the accuracy and reliability of the analysis results.
Section5: Discussion and Insights (2 pages)
Interprets the analysis results in the context of the business problem.
Identifies and discusses any patterns, trends, or relationships discovered.
Provides meaningful insights and recommendations based on the analysis findings using business language.
Relates the insights to the original problem statement and project objectives.
Considers any ethical, legal, or social implications of the analysis findings.
Section6: References
Accurately cites all the sources used in the project, following a consistent citation style (i.e., APA style).
Provides in-text citations where appropriate to support claims and findings.

>Write a function called gcd that takes parameters a and b and returns their greatest common divisordivisor
Answer:
You can implement the greatest common divisor (GCD) function using the Euclidean algorithm. Here’s how you can do it in Python:
“`python
def gcd(a, b):
while b:
a, b = b, a % b
return a
# Example usage:
num1 = 48
num2 = 18
print(“GCD of”, num1, “and”, num2, “is:”, gcd(num1, num2))
“`
In this implementation, the `gcd` function repeatedly applies the Euclidean algorithm until `b` becomes 0. The algorithm states that the GCD of two numbers `a` and `b` is the same as the GCD of `b` and the remainder of `a` divided by `b`. So, in each iteration, `a` becomes `b`, and `b` becomes `a % b`. When `b` becomes 0, `a` will be the GCD of the original `a` and `b`.

You can use Python’s NumPy library to convert a list and tuple into arrays. Here’s a simple program to demonstrate this:
“`python
import numpy as np
def convert_to_array(input_data):
if isinstance(input_data, list):
return np.array(input_data)
elif isinstance(input_data, tuple):
return np.array(input_data)
else:
raise ValueError(“Input data must be either a list or a tuple”)
# Example usage:
input_list = [1, 2, 3, 4, 5]
input_tuple = (6, 7, 8, 9, 10)
array_from_list = convert_to_array(input_list)
array_from_tuple = convert_to_array(input_tuple)
print(“Array from list:”, array_from_list)
print(“Array from tuple:”, array_from_tuple)
“`
This program defines a function `convert_to_array` that takes either a list or a tuple as input and returns the corresponding NumPy array. It checks the type of the input data and converts it accordingly. Finally, it demonstrates how to use this function with example input data.

Certainly! Let’s create Python programs to convert lists and tuples into NumPy arrays. NumPy is a powerful library for numerical computations, and it provides convenient methods for array manipulation.
Convert a List to a NumPy Array
You can use either numpy.array() or numpy.asarray() to convert a Python list into a NumPy array. Here are examples for both methods:
Using numpy.array():
Python
import numpy as np
# Example list
my_list = [3, 4, 5, 6]
# Convert list to NumPy array
array1 = np.array(my_list)
print(“List:”, my_list)
print(“Array:”, array1)
AI-generated code. Review and use carefully. More info on FAQ.
Output:
List: [3, 4, 5, 6]
Array: [3 4 5 6]
Using numpy.asarray():
Python
import numpy as np
# Example list
my_list = [1, 2, 3]
# Convert list to NumPy array
array2 = np.asarray(my_list)
print(“List:”, my_list)
print(“Array:”, array2)
AI-generated code. Review and use carefully. More info on FAQ.
Output:
List: [1, 2, 3]
Array: [1 2 3]
The key difference between numpy.array() and numpy.asarray() is that the former creates a new copy in memory, while the latter does not. Changes made to the original list will be reflected in the array created using numpy.asarray().
Convert a Tuple to a NumPy Array
Similarly, you can convert a Python tuple into a NumPy array using the same methods. Here are examples for both methods:
Using numpy.asarray() with a tuple:
Python
import numpy as np
# Example tuple
my_tuple = ([8, 4, 6], [1, 2, 3])
# Convert tuple to NumPy array
array3 = np.asarray(my_tuple)
print(“Tuple:”, my_tuple)
print(“Array:”, array3)
AI-generated code. Review and use carefully. More info on FAQ.
Output:
Tuple: ([8, 4, 6], [1, 2, 3])
Array: [[8 4 6]
[1 2 3]]
Using numpy.array() with a tuple:
Python
import numpy as np
# Example tuple
my_tuple = ([8, 4, 6], [1, 2, 3])
# Convert tuple to NumPy array
array4 = np.array(my_tuple)
print(“Tuple:”, my_tuple)
print(“Array:”, array4)
AI-generated code. Review and use carefully. More info on FAQ.
Output:
Tuple: ([8, 4, 6], [1, 2, 3])
Array: [[8 4 6]
[1 2 3]]
Remember that NumPy arrays are efficient for numerical computations and provide additional functionality compared to regular Python lists and tuples. Feel free to explore more features of NumPy for your data manipulation needs! ?