This commit is contained in:
me
@@ -0,0 +1,42 @@
|
||||
// SumBigIntegerOctal.java
|
||||
|
||||
import java.math.BigInteger;
|
||||
|
||||
public class SumBigIntegerOctal {
|
||||
|
||||
public static void main(String[] args) {
|
||||
BigInteger sum = new BigInteger("0");
|
||||
for (String argument : args) {
|
||||
StringBuilder number = new StringBuilder();
|
||||
for (char c : argument.toCharArray()) {
|
||||
if (!Character.isWhitespace(c)) {
|
||||
number.append(c);
|
||||
} else {
|
||||
sum = sum.add(parseNumber(number));
|
||||
number = new StringBuilder();
|
||||
}
|
||||
}
|
||||
|
||||
sum = sum.add(parseNumber(number));
|
||||
}
|
||||
|
||||
System.out.println(sum);
|
||||
}
|
||||
|
||||
static BigInteger parseNumber(StringBuilder number) {
|
||||
if (!number.isEmpty()) {
|
||||
String numberString = number.toString();
|
||||
int numberStringLength = numberString.length();
|
||||
if (numberString.endsWith("o") || numberString.endsWith("O")) {
|
||||
return new BigInteger(
|
||||
number.substring(0, numberStringLength - 1),
|
||||
8
|
||||
);
|
||||
} else {
|
||||
return new BigInteger(numberString);
|
||||
}
|
||||
} else {
|
||||
return BigInteger.ZERO;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,228 @@
|
||||
---
|
||||
title: SumBigIntegerOctal
|
||||
weight: 6
|
||||
---
|
||||
|
||||
# Task
|
||||
|
||||
- Input data fits into [`BigInteger`](https://docs.oracle.com/javase/8/docs/api/java/math/BigInteger.html) data type.
|
||||
- Octal numbers ends with `o`.
|
||||
- Class should be named `SumBigIntegerOctal`.
|
||||
|
||||
## Solution
|
||||
|
||||
Let's change our `parseNumber` method code from `SumLongOctal` modification. Here's what it looked like
|
||||
|
||||
```java
|
||||
static long parseNumber(StringBuilder number) {
|
||||
if (!number.isEmpty()) {
|
||||
String numberString = number.toString();
|
||||
int numberStringLength = numberString.length();
|
||||
if (numberString.endsWith("o") || numberString.endsWith("O")) {
|
||||
return new BigInteger(
|
||||
number.substring(0, numberStringLength - 1),
|
||||
8
|
||||
).longValue();
|
||||
} else {
|
||||
return Long.parseLong(numberString);
|
||||
}
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
First of all let's change the output type of our method to `BigInteger`.
|
||||
|
||||
```java
|
||||
static BigInteger parseNumber(StringBuilder number) {...}
|
||||
```
|
||||
|
||||
Also in case of an empty number we can't just `return 0` anymore because it doesn't have `BigInteger` data type. Instead we are going to return [`BigInteger.ZERO`](https://docs.oracle.com/javase/8/docs/api/java/math/BigInteger.html#ZERO).
|
||||
|
||||
Here we can get rid of `.longValue()` because we just need straight `BigInteger` type.
|
||||
|
||||
```java
|
||||
return new BigInteger(number.substring(0, numberStringLength - 1), 8); // .longValue();
|
||||
```
|
||||
|
||||
Also we change this
|
||||
|
||||
```java
|
||||
return Long.parseLong(numberString);
|
||||
```
|
||||
|
||||
to this
|
||||
|
||||
```java
|
||||
return new BigInteger(numberString);
|
||||
```
|
||||
|
||||
for the same reason. So the `parseNumber` will look like this
|
||||
|
||||
```java
|
||||
static BigInteger parseNumber(StringBuilder number) {
|
||||
if (!number.isEmpty()) {
|
||||
String numberString = number.toString();
|
||||
int numberStringLength = numberString.length();
|
||||
if (numberString.endsWith("o") || numberString.endsWith("O")) {
|
||||
return new BigInteger(
|
||||
number.substring(0, numberStringLength - 1),
|
||||
8
|
||||
);
|
||||
} else {
|
||||
return new BigInteger(numberString);
|
||||
}
|
||||
} else {
|
||||
return BigInteger.ZERO;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Let's rework our `main` method as well. Here's what it looks like now
|
||||
|
||||
```java
|
||||
public static void main(String[] args) {
|
||||
int sum = 0;
|
||||
for (String argument : args) {
|
||||
StringBuilder number = new StringBuilder();
|
||||
for (char c : argument.toCharArray()) {
|
||||
if (!Character.isWhitespace(c)) {
|
||||
number.append(c);
|
||||
} else {
|
||||
sum += parseNumber(number);
|
||||
number = new StringBuilder();
|
||||
}
|
||||
}
|
||||
|
||||
sum += parseNumber(number);
|
||||
}
|
||||
|
||||
System.out.println(sum);
|
||||
}
|
||||
```
|
||||
|
||||
First of all, let's change the data type of `sum` to `BigInteger` like this
|
||||
|
||||
```java
|
||||
BigInteger sum = new BigInteger("0");
|
||||
```
|
||||
|
||||
> [!IMPORTANT]
|
||||
> Notice, we can't just do `new BigInteger()` (without any arguments) like we did with `StringBuilder`. We need to put the initial value as an argument like [`new BigInteger(String val)`](https://docs.oracle.com/javase/8/docs/api/java/math/BigInteger.html#BigInteger-java.lang.String-).
|
||||
|
||||
So in this stage our code will look like this
|
||||
|
||||
```java
|
||||
// SumBigIntegerOctal.java
|
||||
|
||||
import java.math.BigInteger;
|
||||
|
||||
public class SumBigIntegerOctal {
|
||||
|
||||
public static void main(String[] args) {
|
||||
BigInteger sum = new BigInteger("0");
|
||||
for (String argument : args) {
|
||||
StringBuilder number = new StringBuilder();
|
||||
for (char c : argument.toCharArray()) {
|
||||
if (!Character.isWhitespace(c)) {
|
||||
number.append(c);
|
||||
} else {
|
||||
sum += parseNumber(number);
|
||||
number = new StringBuilder();
|
||||
}
|
||||
}
|
||||
|
||||
sum += parseNumber(number);
|
||||
}
|
||||
|
||||
System.out.println(sum);
|
||||
}
|
||||
|
||||
static BigInteger parseNumber(StringBuilder number) {
|
||||
if (!number.isEmpty()) {
|
||||
String numberString = number.toString();
|
||||
int numberStringLength = numberString.length();
|
||||
if (numberString.endsWith("o") || numberString.endsWith("O")) {
|
||||
return new BigInteger(
|
||||
number.substring(0, numberStringLength - 1),
|
||||
8
|
||||
);
|
||||
} else {
|
||||
return new BigInteger(numberString);
|
||||
}
|
||||
} else {
|
||||
return BigInteger.ZERO;
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
And let's try to compile this
|
||||
|
||||
```bash
|
||||
$ javac SumBigIntegerOctal.java
|
||||
SumBigIntegerOctal.java:15: error: bad operand types for binary operator '+'
|
||||
sum += parseNumber(number);
|
||||
^
|
||||
first type: BigInteger
|
||||
second type: BigInteger
|
||||
SumBigIntegerOctal.java:20: error: bad operand types for binary operator '+'
|
||||
sum += parseNumber(number);
|
||||
^
|
||||
first type: BigInteger
|
||||
second type: BigInteger
|
||||
2 errors
|
||||
```
|
||||
|
||||
> [!NOTE]
|
||||
> We can't use `+` operand with `BigInteger` data type. Instead we need to use [`BigInteger.add(BigInteger val)`](https://docs.oracle.com/javase/8/docs/api/java/math/BigInteger.html#add-java.math.BigInteger-).
|
||||
|
||||
So we will modify like so
|
||||
|
||||
```java
|
||||
// SumBigIntegerOctal.java
|
||||
|
||||
import java.math.BigInteger;
|
||||
|
||||
public class SumBigIntegerOctal {
|
||||
|
||||
public static void main(String[] args) {
|
||||
BigInteger sum = new BigInteger("0");
|
||||
for (String argument : args) {
|
||||
StringBuilder number = new StringBuilder();
|
||||
for (char c : argument.toCharArray()) {
|
||||
if (!Character.isWhitespace(c)) {
|
||||
number.append(c);
|
||||
} else {
|
||||
sum = sum.add(parseNumber(number));
|
||||
number = new StringBuilder();
|
||||
}
|
||||
}
|
||||
|
||||
sum = sum.add(parseNumber(number));
|
||||
}
|
||||
|
||||
System.out.println(sum);
|
||||
}
|
||||
|
||||
static BigInteger parseNumber(StringBuilder number) {
|
||||
if (!number.isEmpty()) {
|
||||
String numberString = number.toString();
|
||||
int numberStringLength = numberString.length();
|
||||
if (numberString.endsWith("o") || numberString.endsWith("O")) {
|
||||
return new BigInteger(
|
||||
number.substring(0, numberStringLength - 1),
|
||||
8
|
||||
);
|
||||
} else {
|
||||
return new BigInteger(numberString);
|
||||
}
|
||||
} else {
|
||||
return BigInteger.ZERO;
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
And this code will pass all the tests!
|
||||
@@ -0,0 +1,41 @@
|
||||
// SumDoubleHex.java
|
||||
|
||||
public class SumDoubleHex {
|
||||
|
||||
public static void main(String[] args) {
|
||||
double sum = 0;
|
||||
for (String argument : args) {
|
||||
StringBuilder number = new StringBuilder();
|
||||
for (char c : argument.toCharArray()) {
|
||||
if (!Character.isWhitespace(c)) {
|
||||
number.append(c);
|
||||
} else {
|
||||
sum += parseNumber(number);
|
||||
number = new StringBuilder();
|
||||
}
|
||||
}
|
||||
|
||||
sum += parseNumber(number);
|
||||
}
|
||||
|
||||
System.out.println(sum);
|
||||
}
|
||||
|
||||
static double parseNumber(StringBuilder number) {
|
||||
if (!number.isEmpty()) {
|
||||
String numberString = number.toString();
|
||||
if (
|
||||
numberString.startsWith("0x") || numberString.startsWith("0X")
|
||||
) {
|
||||
if (numberString.contains(".")) {
|
||||
return Double.parseDouble(numberString);
|
||||
}
|
||||
return Long.parseLong(numberString.substring(2), 16);
|
||||
} else {
|
||||
return Double.parseDouble(numberString);
|
||||
}
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
134
content/courses/prog-intro/homeworks/sum/SumDoubleHex/_index.md
Normal file
134
content/courses/prog-intro/homeworks/sum/SumDoubleHex/_index.md
Normal file
@@ -0,0 +1,134 @@
|
||||
---
|
||||
title: SumDoubleHex
|
||||
weight: 6
|
||||
---
|
||||
|
||||
# Task
|
||||
|
||||
- Input data are 64-bit floating point numbers
|
||||
- There are decimal and hexadecimal numbers in the input
|
||||
- Hexadecimal numbers has `0x` prefix, for example `0xa.bp2` equals `(10 + 11/16)·4 = 42.75`
|
||||
- Input is case-insensitive
|
||||
- Class should be named `SumDoubleHex`
|
||||
|
||||
## Solution
|
||||
|
||||
Let's change our `SumHex` `parseNumber` method modification code. Currently it looks like this
|
||||
|
||||
```java
|
||||
static long parseNumber(StringBuilder number) {
|
||||
if (!number.isEmpty()) {
|
||||
String numberString = number.toString();
|
||||
if (
|
||||
numberString.startsWith("0x") || numberString.startsWith("0X")
|
||||
) {
|
||||
return Long.parseLong(numberString.substring(2), 16);
|
||||
} else {
|
||||
return Integer.parseInt(numberString);
|
||||
}
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Let's change it a little bit
|
||||
|
||||
```java
|
||||
static double parseNumber(StringBuilder number) { // long -> double
|
||||
if (!number.isEmpty()) {
|
||||
String numberString = number.toString();
|
||||
if (
|
||||
numberString.startsWith("0x") || numberString.startsWith("0X")
|
||||
) {
|
||||
if (/* there is a dot (.) inside a number */) {
|
||||
return Double.parseDouble(numberString);
|
||||
}
|
||||
return Long.parseLong(numberString.substring(2), 16);
|
||||
} else {
|
||||
return Double.parseDouble(numberString); // Integer.parseInt(...) -> Double.parseDouble(...)
|
||||
}
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
> [!NOTE]
|
||||
> Notice, that we pass only one argument into [`Double.parseDouble()`](https://docs.oracle.com/javase/8/docs/api/java/lang/Double.html#parseDouble-java.lang.String-) method, because `parseDouble`'s parser recognizes `0x` pattern itself.
|
||||
|
||||
Aside of obvious analogical changes, we need to somehow understand if the number contains a dot (`.`). We can do so by using [`String.contains(CharSequence s)`](https://docs.oracle.com/javase/8/docs/api/java/lang/String.html#contains-java.lang.CharSequence-). Which checks if the `s` is present in the string.
|
||||
|
||||
|
||||
> [!NOTE]
|
||||
> In the defenition of the `contains` method there is [`CharSequence`](https://docs.oracle.com/javase/8/docs/api/java/lang/CharSequence.html) data type. `String` data type fits into `CharSequence` data type as it is declared in the documentation.
|
||||
|
||||
So our `parseNumber` method code will look like this
|
||||
|
||||
```java
|
||||
static double parseNumber(StringBuilder number) {
|
||||
if (!number.isEmpty()) {
|
||||
String numberString = number.toString();
|
||||
if (
|
||||
numberString.startsWith("0x") || numberString.startsWith("0X")
|
||||
) {
|
||||
if (numberString.contains(".")) {
|
||||
return Double.parseDouble(numberString);
|
||||
}
|
||||
return Long.parseLong(numberString.substring(2), 16);
|
||||
} else {
|
||||
return Double.parseDouble(numberString);
|
||||
}
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
And after changing `sum`'s data type to `double` in `main` method we get
|
||||
|
||||
```java
|
||||
// SumDoubleHex.java
|
||||
|
||||
public class SumDoubleHex {
|
||||
|
||||
public static void main(String[] args) {
|
||||
double sum = 0;
|
||||
for (String argument : args) {
|
||||
StringBuilder number = new StringBuilder();
|
||||
for (char c : argument.toCharArray()) {
|
||||
if (!Character.isWhitespace(c)) {
|
||||
number.append(c);
|
||||
} else {
|
||||
sum += parseNumber(number);
|
||||
number = new StringBuilder();
|
||||
}
|
||||
}
|
||||
|
||||
sum += parseNumber(number);
|
||||
}
|
||||
|
||||
System.out.println(sum);
|
||||
}
|
||||
|
||||
static double parseNumber(StringBuilder number) {
|
||||
if (!number.isEmpty()) {
|
||||
String numberString = number.toString();
|
||||
if (
|
||||
numberString.startsWith("0x") || numberString.startsWith("0X")
|
||||
) {
|
||||
if (numberString.contains(".")) {
|
||||
return Double.parseDouble(numberString);
|
||||
}
|
||||
return Long.parseLong(numberString.substring(2), 16);
|
||||
} else {
|
||||
return Double.parseDouble(numberString);
|
||||
}
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
This code will work and pass all the tests!
|
||||
@@ -0,0 +1,4 @@
|
||||
---
|
||||
title: Summing Up
|
||||
weight: 6
|
||||
---
|
||||
Reference in New Issue
Block a user