Assignment Difficulty Overview
- First Assignment: 9 foundational Java problems covering conditional statements and loops, designed to build core programming skills for novices. Implementation is straightforward, focusing on aplpying basic language concepts.
- Second Assignment: 3 problems with a significant difficulty jump, emphasizing string processing, ASCII conversion, and binary data parsing.
- Third Assignment: A major difficulty increase requiring object-oriented design for geometric entities (points, lines, triangles). Challenges include regex usage and class implementation, with only the first problem successfully completed.
First PTA Assignment Analysis
Consists of 9 beginner-focused tasks targeting core Java basics like conditionals and loops. Each problem requires direct application of learned concepts, with no complex design needed. The primary goal is to reinforce foundational knowledge through simple implementation.
Second PTA Assignment Analysis
Comprises 3 advanced problems with notable complexity increases:
1. Letter-to-Number Conversion
Problem Statement: Convert each letter in a case-insensitive string to its 1-based position in the alphabet (e.g., "AbbcD" → "12234"). Non-alphabetic input is invalid, outputting "Wrong Format".
Input Format: A string of English letters (case-insensitive). Invalid input includes non-alphabetic characters. Output Format: A string of digit positions, or "Wrong Format" for invalid input.
Sample Input:
AbbcD
Sample Output:
12234
Invalid Input Sample:
c3u
Invalid Output:
Wrong Format
Rewritten Code:
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String inputStr = scanner.next();
boolean isValid = true;
StringBuilder result = new StringBuilder();
for (char c : inputStr.toCharArray()) {
if (!Character.isLetter(c)) {
isValid = false;
break;
}
char lowerC = Character.toLowerCase(c);
int position = lowerC - 'a' + 1;
result.append(position);
}
System.out.println(isValid ? result : "Wrong Format");
scanner.close();
}
}
Analysis: This task requires input validation and character mapping. Using Character.isLetter() simplifies range checks, while StringBuilder ensures efficient string concatenation. The key focus is handling case insensitivity and invalid input gracefully.
2. Serial Port Binary Data Parsing
Problem Statement: Simulate a serial port receiver processing binary frames with the structure: 1 start bit (0), 8 data bits, 1 odd parity bit, 1 stop bit (1). Idle state is continuous '1's. Extract valid data or output appropriate error messages.
Input Format: A binary string of 0s and 1s. Output Format: Valid data lines prefixed with index and colon. Error messages include:
- "null data" for input <11 bits or all '1's
- "validate error" for invalid stop bit
- "parity check error" for failed odd parity check
- "validate error" if both stop bit and parity are invalid
Sample Input:
1111011101011111111111
Sample Output:
1:11101011
Rewritten Code:
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String inputData = scanner.next();
int dataIndex = 1;
if (inputData.length() < 11 || inputData.matches("^1+$")) {
System.out.println("null data");
scanner.close();
return;
}
int i = 0;
while (i <= inputData.length() - 11) {
if (inputData.charAt(i) == '0') {
System.out.print(dataIndex + ":");
dataIndex++;
boolean stopBitValid = inputData.charAt(i + 10) == '1';
if (!stopBitValid) {
System.out.println("validate error");
i += 11;
continue;
}
String dataBits = inputData.substring(i + 1, i + 9);
int oneCount = 0;
for (char c : dataBits.toCharArray()) {
if (c == '1') oneCount++;
}
char parityBit = inputData.charAt(i + 9);
boolean parityValid = (oneCount + (parityBit - '0')) % 2 == 1;
System.out.println(parityValid ? dataBits : "parity check error");
i += 11;
} else {
i++;
}
}
scanner.close();
}
}
Analysis: The main challenges include frame identification, stop bit validation, and odd parity calculation. Key steps involve iterating through the binary stream to locate start bits, validating frame structure, and performing parity checks to ensure data integrity.
3. Student ID Extraction and Validation
Problem Statement: Student IDs follow an 8-digit format: 2-digit grade + 2-digit college + 2-digit class + 2-digit serial number. Extract the last 4 digits (class + serial) for students in classes 202017 and 202061 from a concatenated input string. Invalid input (non-digit or length not divisible by 8) outputs "Wrong Format".
Input Format: A concatenated string of valid student IDs (no separators). Output Format: Space-separated last 4 digits of target class students.
Sample Input:
2020610120201702202051132020110320201706
Sample Output:
6101 1702 1706
Rewritten Code:
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String inputStr = scanner.next();
StringBuilder result = new StringBuilder();
if (inputStr.length() % 8 != 0 || !inputStr.matches("^\\d+$")) {
System.out.println("Wrong Format");
scanner.close();
return;
}
for (int i = 0; i < inputStr.length(); i += 8) {
String classPrefix = inputStr.substring(i, i + 6);
if (classPrefix.equals("202017") || classPrefix.equals("202061")) {
if (result.length() > 0) result.append(" ");
result.append(inputStr.substring(i + 4, i + 8));
}
}
System.out.println(result);
scanner.close();
}
}
Analysis: This task requires input validation (length and digit check) and targeted substring extraction. Using StringBuilder ensures efficient output construction, and modular checks simplify input validation and target class identification.
Third PTA Assignment Analysis
Focuses on object-oriented design for geometric calculations, with tasks including point distance, line length, and triengle validation. Only the first problem was successfully implemented due to challenges with regex and class design for lines and triangles.
1. Point Distance Calculation
Problem Statement: Calculate the Euclidean distance between two points. Input format is "x1,y1 x2,y2" (supports signed doubles). Output appropriate error messages for invalid format or excess points.
Input Format: Two points in coordinate format, e.g., "0,0 1,1" or "+2.5,-3.1 0.9,4.2". Output Format: Calculated distance or error message:
- "Wrong Format" for invalid coordinate syntax
- "wrong number of points" for more than two points
Sample Input:
0,0 1,1
Sample Output:
1.4142135623730951
Rewritten Code:
import java.util.Scanner;
import java.util.regex.Pattern;
public class Main {
private static final Pattern COORD_PATTERN = Pattern.compile("^[+-]?(0|(0\\.\\d+)?|[1-9]\\d*(\\.\\d+)?)$");
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String inputLine = scanner.nextLine().trim();
String[] pointStrings = inputLine.split("\\s+");
if (pointStrings.length != 2) {
System.out.println("wrong number of points");
scanner.close();
return;
}
double[][] points = new double[2][2];
for (int i = 0; i < 2; i++) {
String[] coords = pointStrings[i].split(",");
if (coords.length != 2 || !COORD_PATTERN.matcher(coords[0]).matches() || !COORD_PATTERN.matcher(coords[1]).matches()) {
System.out.println("Wrong Format");
scanner.close();
return;
}
points[i][0] = Double.parseDouble(coords[0]);
points[i][1] = Double.parseDouble(coords[1]);
}
double xDiff = points[0][0] - points[1][0];
double yDiff = points[0][1] - points[1][1];
System.out.println(Math.sqrt(xDiff * xDiff + yDiff * yDiff));
scanner.close();
}
}
Analysis: This task involves input parsing, regex-based validation, and geometric calculation. Key challenges include validating coordinate formats (supporting signed integers and doubles) and correctly splitting input into points. The solution uses regex for robust validation and procedural implemantation, highlighting the need to transition to object-oriented design (e.g., a Point class) for more complex geometric tasks.