代写SI 100B、代做Python设计程序

日期：2024-10-31 09:12

SI 100B Programming Assignment 2

SI 100B TA Team

October 23, 2024

1

Notice

• This homework is due 10:00 AM October 30, Wednesday, please start early.

• The problems should be solved individually. You should submit solutions for all problems to the online

judge (OJ) system, which will give a score for each submission automatically.

• You may discuss course material, programming languages, general techniques, and share test cases with

others.

• You’re encouraged to ask any question about problem description, environment setup, error informa tion, grammar, functions, methods etc., or post general ideas at Piazza. It can help others too!

• However, you may NOT read, possess, copy, or submit any part of other’s solution. You may not ask

others to directly debug your program or provide specific lines of solution. You should not access an other person’s account. Also, do not offer such help, and protect your account and code. Giving or

receiving inappropriate help is plagiarism, an infringement of academic integrity.

• You are not allowed to write your solution directly by or based on code generated by AI tools.

• Good luck and have fun!

2

1 UNFORTUNATE STOCKHOLDER

1 Unfortunate Stockholder

“I really hate green,” the poor man sighed, looking down, and found his beloved Alexandra Nikolaevna

Petrovskaya lying on the floor, stiff and cold. With her gone, his nearly hairless head now has one less hair.

A month ago, he was still a rich man, with positive daily profit from his investments. However, without

him noticing, some of his stocks had been falling for several days, and then suddenly hit the lower limit.

Quicker than he could take any actions, his other stocks also began falling.

Because he had so many stocks, he only checked the total profit every day.“Oh God! How I wish I had a

tool that can tell me the details of my stocks!”

1.1 Task

As it happens, you know how to use python, and you will kindly fulfill his wish by writing a python

program to give the details of his stocks. You will be given a list of numbers, representing the profit of his

stocks, and a series of queries. For each query, you should perform the corresponding operation and print the

result.

1.2 Input/Output Specification

1.2.1 Input

The first line contains a string of float numbers, representing the profit of the stocks.

The second line contains a single positive integer n, indicating the number of queries.

Each of the following n lines contains a query, with details shown in the Table below. All queries will be

given in one of the formats

• query, operation

• query, operation, start_index, end_index, step

query, operation, start_index, end_index, step means querying on the profit of a subset of the stocks ob tained by performing slicing operation. It is guaranteed that start_index, end_index and step are all integers.

If the subset of the stocks to be queried is empty, print Querying on empty list! (with a single space

at the end of the output) and do nothing else.

1.2.2 Output

n lines, each line the result of the query.

3

1.2 Input/Output Specification 1 UNFORTUNATE STOCKHOLDER

Query Operation Example Input Result

find

min find, min the min profit amongst all stocks

find, min, 1, 3, 1 the min profit amongst the sliced subset of stocks

max

find, max the max profit amongst all stocks

find, max, 5, 9, 2 the max profit amongst the sliced subset of stocks

index

a single index, 10 the profit of the stock with index i

positive integer i

slice index, slice, 2, 3, 1 the list of profits of the sliced subset of stocks

compute

avg

compute, avg the average profit of all stocks

compute, avg, 5, 12, 3 the average profit of the sliced subset of stocks

all compute, all the total profit of all stocks

compute, all, 6, 3, 2 the total profit of the sliced subset of stocks

reorder

asc

reorder, asc the reordered list of profits

of all stocks in ascending order

reorder, asc, 7, 30, 1 the list of profits with the profits of the

sliced stocks reordered in ascending order

desc

reorder, desc the reordered list of profits

of all stocks in descending order

reorder, desc, 3, 4, 2 the list of profits with the profits of the

sliced stocks reordered in descending order

rev

reorder, rev the reordered list of profits

of all stocks in reverse order

reorder, rev, 9, 3, 3 the list of profits with the profits of the

sliced stocks reordered in reverse order

1.2.3 Example

1. Input

1 4 5 3 4 2 5 −2 −3 0 2

5

find, min

find, max, 0, 3, 1

compute, avg, 2, 12, 1

reorder, rev

reorder, asc, 1, 6, 1

Output

−3.0

5.0

1.7777777777777777

[2.0, 0.0, −3.0, −2.0, 5.0, 2.0, 4.0, 3.0, 5.0, 4.0, 1.0]

[2.0, −3.0, −2.0, 0.0, 2.0, 5.0, 4.0, 3.0, 5.0, 4.0, 1.0]

4

1.3 Hint 2 AVERAGE RUNNING SPEED

2. Input

1 2 3 4 5 6

5

index, 5

index, slice, 1, 4, 2

compute, all

reorder, desc, 6, 3, −1

find, max, 2, 4, 1

Output

6.0

[2.0, 4.0]

21.0

[1.0, 2.0, 3.0, 4.0, 5.0, 6.0]

4.0

1.3 Hint

After each reorder query, the list is reordered (i.e., it is mutated), as shown in the examples.

2 Average Running Speed

As part of promoting a healthy lifestyle, the university has introduced a running App. The App generates

data points consecutively containing the student’s positions and timestamps during their running sessions.

The App helps generate useful statistics, such as distance covered and average speed. And students can freely

select specific data points for customized analysis.

2.1 Task

You are tasked with writing a program to process data points of a running session and then evaluate

a runner’s performance. Your program receives n data points at the beginning. The i-th data point Pi =

(xi

, yi

, ti), where xi and yi are the runner’s 2D coordinates, ti

is the timestamp measured in seconds. For

simplicity, we assume that runners travels along a straight path between two adjacent points, so the distance

between two adjacent data points is estimated using the Euclidean distance formula:

D(Pk, Pk−1) = √

(xk−xk−1)

2 + (yk−yk−1)

2

5

2.2 Input/Output Specification 2 AVERAGE RUNNING SPEED

Firstly, you need to estimate the average speed V of the entire session, note that the session starts at P0 and

ends at Pn−1:

V =

∑n

k=1 D(Pk, Pk−1)

tn−1 − t0

Then the runner will freely select m subsections, with the i-th subsection represented by the indices of two

data points, starti and endi

. And the runner wants to know what the average running speed is for each

subsection, i.e., the average speed V i running through Pstarti

, Pstarti+1, . . . , Pendi−1, Pendi

2.2 Input/Output Specification

2.2.1 Input

The first line contains a single integer n, the number of data points in the running session (2 ≤ n ≤ 100).

The next n lines of data points contains three integers each: xi

, yi

, ti

, where xi and yi

is the runner’s

coordinate (−100 ≤ xi

, yi ≤ 100), ti

is the timestamp at the i-th data point (0 ≤ t0 < t1 < t2 . . . < tn−1 ≤

103

).

The next line contains a single integer m, the number of the selected subsections.

The next m lines contains two values each: starti

, endi

, which represents the indices of start point and

end point of the i-th subsection (0 ≤ starti < endi < n).

2.2.2 Output

The first line is the average speed V of the entire session. And the next m lines: each line contains the

average speed V i for the i-th subsection. V and V i should be formatted to three decimal places.

2.2.3 Example

1. Input

4

1 2 1

7 3 5

4 8 12

2 1 18

1

1 3

Output

1.129

1.009

6

3 I OR E

2. Input

5

48 8 2

−83 −85 4

60 14 11

−37 −37 19

−15 −31 20

2

3 4

0 2

Output

25.943

22.804

37.176

3 I or E

Myers–Briggs Type Indicator (MBTI) is a assessment particularly popular in social occasions. There is

one dimension: energy orientation, which is divided into introversion and extraversion—— extraverted person

obtains energy from social interactions, while introverted person obtains energy from self-reflection.

However, a person’s energy orientation is not fixed. For example, a person who is initially classified as

introverted may turn out to be extraverted under some circumstances.

3.1 Task

In this scenario, a meeting consists of participants of three initial orientations: “E”, “I”, and “i”. You are

given a seating arrangement represented as an n × m matrix where n is the number of rows. And each seat

position indicates the energy orientation of a participant (E, I, or i). Your task is to print out the final energy

orientation in matrix format.

Participants will sit one by one, from the first row to the last row, and within each row, from left to right.

During this process, if an “i” participant is surrounded by introverted person (either “I” or “i”), they will change

their orientation to extraverted, denoted as “e”. A participant is considered surrounded by introverted person

if all their adjacent neighbors (up, down, left, right) are either I or i. If the participant is on the boundary

or corner, only the existing neighbors are considered.

There is a special case when the last participant seated: first update the previously seated participants

before considering the last one, in order to avoid potential conflicts.

7

3.2 Input/Output Specification 3 I OR E

3.2 Input/Output Specification

3.2.1 Input

The first line contains two integers n and m, representing the dimensions of the seating matrix (n × m),

(2 ≤ n, m ≤ 50). The following n lines each contain m separated characters c ∈ {E, I, i}, indicating the

energy orientation of the participants in each seat.

3.2.2 Output

You should output n lines, each containing one list, representing the final energy orientation of the par ticipants after they are seated in order.

3.2.3 Example

1. Input

3 4

E I i I

i I i i

i I I i

Output

['E', 'I', 'e', 'I']

['i', 'I', 'i', 'e']

['e', 'I', 'I', 'i']

Case Explanation: for convenience, we use a tuple (i, j) (count from 1), to represent the seat located

at the i-th row and j-th column. The orientation of the participant changed in the following order:

(a) (1, 3) changed when (2, 3) seated.

(b) (3, 1) changed when (3, 2) seated.

(c) (2, 3) changed when (3, 3) seated. Remember to update the previously seated participants before

the last one.

2. Input

5 5

E I i I E

i I i I I

I i I i E

I I i i I

i I I I i

8

4 TURTLE BLIND BOXES

Output

['E', 'I', 'e', 'I', 'E']

['i', 'I', 'i', 'I', 'I']

['I', 'e', 'I', 'i', 'E']

['I', 'I', 'e', 'i', 'I']

['e', 'I', 'I', 'I', 'e']

Case Explanation: The orientation of the participant changed in the following order:

(a) (1, 3) changed when (2, 3) seated.

(b) (3, 2) changed when (4, 2) seated.

(c) (5, 1) changed when (5, 2) seated.

(d) (4, 3) changed when (5, 3) seated.

(e) (5, 5) changed when (5, 5) seated.

4 Turtle Blind Boxes

Blind box opening games have become increasingly popular on platforms such as TikTok. In this assign ment, you will simulate a blind box opening game where the contents are small glass turtles of different colors

and patterns. The objective is to simulate the entire process of purchasing, opening, and placing these turtles

in a grid, following specific rules to either eliminate or reward the player with additional blind boxes based

on turtle combinations.

Each turtle has a color and a pattern, with the following possibilities:

• Colors: Red, Orange, Yellow, Green, Blue

• Patterns: Patterned, Unpatterned

The game uses a 3x3 grid to display the turtles, and there are several conditions that trigger rewards or elimi nations during the gameplay.

4.1 Task

You are required to write a Python program that simulates this turtle blind box game. The game follows

specific rules for rewarding the player with extra blind boxes or eliminating turtles from the grid. The detailed

task breakdown is as follows:

1. Get Blind Box Content: Each blind box contains one glass turtle with a randomly generated color and

pattern combination.

9

4.2 Input/Output Specification 4 TURTLE BLIND BOXES

2. Wish Mechanism: The player can wish for a specific color and pattern combination. If a turtle match ing the player’s wish is opened, they are immediately rewarded with one additional blind box.

3. Grid Filling: Each turtle is placed in a 3x3 grid (like a Tic-Tac-Toe board), and the turtles are placed

in the grid according to the numbered order of the cells (1 to 9), where 1 is the top-left and 9 is the

bottom-right.

4. Elimination and Reward Rules: After the grid is filled or all blind boxes have been opened, perform

the following operations in the specified order:

(a) All Different: If the grid is full and all turtles in the grid are different, remove all turtles and

reward the player with 5 additional blind boxes.

(b) Three of a Kind: If three identical turtles align horizontally, vertically, or diagonally, reward the

player with 5 additional blind boxes. The turtles remain in the grid. If there are multiple triples at

the same time, each triple should be given 5 new blind boxes.

(c) Pairs: If two identical turtles are found, they are eliminated from the grid, and the player is

rewarded with 1 additional blind box per pair. Turtles in cells with smaller numbers (lower numbered positions in the grid) are prioritized for removal.

5. End Condition: The game ends when no more blind boxes are available, and no turtles can be elimi nated.

4.2 Input/Output Specification

4.2.1 Input

The program will accept the following four lines of input:

1. The number of initial blind boxes purchased.

2. The player’s wish for a specific turtle’s color and pattern. Use two letters separated by a space to repre sent turtle.

3. A list of randomly generated turtles, with two lines:

• The first line represents the colors of the turtles, using the first letter of each color: R (Red), O

(Orange), Y (Yellow), G (Green), B (Blue).

• The second line represents the patterns of the turtles, using the first letter of each pattern: P

(Patterned), U (Unpatterned).

10

4.2 Input/Output Specification 4 TURTLE BLIND BOXES

The color and pattern of the i-th turtle are represented by the i-th letter in the third and fourth rows. The

number of turtles provided is undetermined, but it’s guaranteed to be larger than the number required for the

simulation.

4.2.2 Output

At the end of the game, output the list of eliminated turtles in the order they were removed from the grid.

Turtles should be represented by tuples of (color, pattern). At the end of the game, the remaining turtles in the

grid should also be eliminated in the order of the numbers in the nine-square grid. You can use print(list)

directly.

4.2.3 Example

1. Input

10

R U

YOBOOBRGOGYBYRYYGBO

UUUUPUUPPPUUUUPUUPU

Output

[('O', 'U'), ('O', 'U'), ('B', 'U'), ('B', 'U'), ('O', 'P'), ('O', 'P'),

('Y', 'U'), ('Y', 'U'), ('G', 'P'), ('G', 'P'), ('R', 'U'), ('R', 'U'),

('Y', 'U'), ('Y', 'U'), ('O', 'U'), ('G', 'U'), ('B', 'P'), ('B', 'U'),

('Y', 'P')]

2. Input

12

R P

RYOYYYROBYRBGGYOGBBYOBYBRYGOROROYGORGOY

PUPPPPUUPPPUUUPPPUPUPPUUPUPUPPUUUUPUUPU

Output

[('Y', 'P'), ('Y', 'P'), ('R', 'P'), ('R', 'P'), ('Y', 'P'), ('Y', 'P'),

('G', 'U'), ('G', 'U'), ('O', 'P'), ('O', 'P'), ('B', 'U'), ('B', 'U'),

('B', 'P'), ('B', 'P'), ('Y', 'U'), ('Y', 'U'), ('B', 'U'), ('R', 'P'),

('O', 'P'), ('B', 'P'), ('G', 'P'), ('Y', 'P'), ('R', 'U'), ('O', 'U'),

('Y', 'U'), ('Y', 'U'), ('Y', 'U'), ('O', 'U'), ('O', 'U'), ('O', 'P'),

('O', 'P'), ('R', 'U'), ('R', 'U'), ('G', 'U'), ('G', 'U'), ('Y', 'U'),

('G', 'P'), ('O', 'P'), ('R', 'P')]

11

4.3 Hint 4 TURTLE BLIND BOXES

4.3 Hint

• Randomly generate test data for debugging: To test your implementation, you can generate random

turtle combinations and simulate different scenarios (e.g., many identical turtles, all different turtles) to

check if the elimination rules are applied correctly.

• Pay attention to the execution order: Make sure that the elimination rules (e.g., three of a kind,

pairs, all different) are applied in the correct sequence. Follow the order of operations as specified in

the task to ensure accurate simulation.

• Modular design: During the implementation process, keep your code modular by breaking down dif ferent functionalities (e.g., adding turtles to the grid, checking for three of a kind, eliminating pairs) into

separate functions. This will make your code easier to understand, debug, and extend.

12