We Keep Coding

How to convert int value 09 to char array as {'0','9'}?

I am working on the problem to find the next greatest number with the same set of digits.
For this I take a integer value input from the user and I want to convert to char array or int array so that I can access individual digits.
But when I take
int value=09 as the input and convert to char array it gives only 9 as it considers it to be octal value. How can I overcome this ?

it is not possible in java to take the int values with leading zeros.
so for the value with leading zeros take it in string format.
but we can insert zeros
int n=7;
String str=String.format("%04d", n); //4 denotes the size of the string
System.out.println(str); // o/p->0007

It is not possible convert a 09 int value to a String of 9 since the value 09 can not be stored in an int.
int is not capable of storing trailing zeros.
Take this sample.
int foo = Integer.valueOf("09");
System.out.println(foo);
Output
9
So to solve your problem you should get a String from the user, validate it and parse it to an Integer[].
Solution
public Integer[] parseToInteger(String number) {
return Arrays.asList(number.toCharArray())
.stream()
.map(c -> Integer.valueOf(c.toString()))
.toArray(size -> new Integer[size]);
}
Now you have an Array of Integer.

Since leading 0's are dropped from integers there is no reason to support assigning such a value to an int.
If I want to convert 9 to '9' I usually just add '0' to it.
You can also do the following:
char c = Character.forDigit(9,10);
If you have a string of characters, you can do the following:
String str = "09";
List<Character> chrs =
str.chars().mapToObj(a -> Character.valueOf((char) a))
.collect(Collectors.toList());
System.out.println(chrs);
Prints
[0,9]

You are asking how to parse a number starting with a leading zero, but I get the feeling that you are actually on the worng track given the problem you are trying to resolve. So let's take one step backward, and lets make sure I understand your problem correctly.
You say that you have to find the "next greatest number with the same set of digits". So you are playing "Scrabble" with digits, trying to find the smalest number composed with the same digits that is strictly greater to the original number. For example, given the input "09", you would output "90", and for "123", you would output "132". Is that right? Let assume so.
Now, the real challenge here is how to determine the smalest number composed with thise digits that is stricly greater to the original number. Actually, there's a few possible strategies:
Enumerate all possible permutations of those digits, then filter out those that are not strictly greater to the original number, and then, among the remaining values, find the smallest value. That would be a very innefficient strategy, requiring both disproportionate memory and processing power. Please, don't consider this seriously (that is, unless you are actually coding for a Quantum Computer ;) ).
Set a variable to the initial number, then iteratively increment that variable by one until you eventually get a number that is composed of the same digits as the original values. That one might look simple to implement, but it actually hides some complexities (i.e. determining that two numbers are composed from the same digits is not trivial, special handling would be required to avoid endless loop if the initial number is actually the greatest value that can be formed with those digits). Anyway, this strategy would also be rather innefficient, requiring considerable processing power.
Iterate over the digits themselves, and determine exactly which digits have to be swapped/reordered to get the next number. This is actually very simple to implement (I just wrote it in less that 5 minutes), but require some thinking first. The algorithm is O(n log n), where n is the length of the number (in digits). Take a sheet of paper, write example numbers in columns, and try to understand the logic behind it. This is definitely the way to go.
All three strategies have one thing in common: they all require that you work (at some point at least) with digits rather than with the number itself. In the last strategy, you actually never need the actual value itself. You are simply playing Scrabble, with digits rather than letters.
So assuming you indeed want to implement strategy 3, here is what your main method might looks like (I wont expand more on this one, comments should be far enough):
public static void main(String[] args) {
// Read input number and parse it into an array of digit
String inputText = readLineFromUser();
int[] inputDigits = parseToDigits(inputText);
// Determine the next greater number
int[] outputDigits = findNextGreaterNumber(inputDigits);
// Output the resulting value
String outputText = joinDigits(outputDigits);
println(outputText);
}
So here's the point of all this discussion: the parseToDigits method takes a String and return an array of digits (I used int here to keep things simpler, but byte would actually have been enough). So basically, you want to take the characters of the input string, and convert that array to an array of integer, with each position in the output containing the value of the corresponding digit in the input. This can be written in various ways in Java, but I think the most simple would be with a simple for loop:
public static int[] parseToDigits(String input) {
char[] chars = input.toCharArray();
int[] digits = new int[chars.length];
for (int i = 0 ; i < chars.length ; i++)
digits[i] = Character.forDigit(chars[i], 10);
return digits;
}
Note that Character.forDigit(digit, radix) returns the value of character digit in base radix; if digit is not valid for the given base, forDigit returns 0. For simplicity, I'm skipping proper validation checking here. One could consider calling Character.isDigit(digit, radix) first to determine if a digit is acceptable, throwing an exception if it is not.
As to the opposite opperation, joinDigits, it would looks like:
public static String joinDigits(int[] digits) {
char[] chars = new char[digits.length];
for (int i = 0 ; i < digits.length ; i++)
chars[i] = Character.digit(digits[i], 10);
return new String(chars);
}
Hope that helps.

Comparing integers and determining similarity

OK so I am writing a program that compares the number entered by a user to a computer generated number. Each number is 3 digits. What I'd like to know how to do is compare these integers. So for example if the last two digits of the three digit numbers are the same it will run a block of code. I'm not completely sure how to go about this. Any youtube videos or any links would be much appreciated. I would rather understand than get an answer to my code.

The fastet way would be: Convert the Integer to a String and then split the string at each char. Then you have an Char Array with each digit and you can compare them like whatever you want.
int number = 324;
String number_string = String.valueOf(number); //converts integer to string
char[] digits = number_string.toCharArray(); //converts string to char array
if(digits[2] == 4){ //checks if 3rd digit of the char array is 4
//do something
}

You can get last two digit by modulo(%) operator.when you modulo three digit number by 100 it return last two digit and compare these digit in if condition like,
int num=154; //number of three digit
int rem=num%100;//modulo by 100 return remainder
if(rem==54){ //checking condition
//code
}
else{
//code
}

I suppose that the number entered is a String so first you want to convert it to an integer.
String value = .... <whatever read from the user>
int number = Integer.parseInt(value)
Then, if you like to get information on some of the digits, use modulus, ie:
number%10
will give you the most right integer (ie 127%10 is 7)
number%100
will give you 2 digits (ie 626%100 is 26)

Java reading .txt file to array

I've been trying to workout this excersise all day, but not having any luck. Thanks in advance for any help.
Here's the problem
The approach you are to implement is to store each integer in an array
of digits, with one digit per array element. We will be using arrays
of length 50, so we will be able to store integers up to 50 digits
long. We have to be careful in how we store these digits. Consider,
for example, storing the numbers 38423 and 27. If we store these at
the “front” of the array with the leading digit of each number in
index 0 of the array, then when we go to add these numbers together,
we’re likely to add them like this:
38423
27
To simulate this right-shifting of values, we will store each value as
a sequence of exactly 50 digits, but we’ll allow the number to have
leading 0’s. For example, the problem above is converted into:
0000000000000000000038423
0000000000000000000000027
Now the columns line up properly and we have plenty of space at the
front in case we have even longer numbers to add to these.
The data for your program will be stored in a file called sum.txt.
Each line of the input file will have a different addition problem for
you to solve. Each line will have one or more integers to be added
together. Take a look at the input file at the end of this write-up
and the output you are supposed to produce. Notice that you produce a
line of output for each input line showing the addition problem you
are solving and its answer. Your output should also indicate at the
end how many lines of input were processed. You must exactly reproduce
this output.
You should use the techniques described in chapter 6 to open a file,
to read it line by line, and to process the contents of each line. In
reading these numbers, you won’t be able to read them as ints or longs
because many of them are too large to be stored in an int or long. So
you’ll have to read them as String values using calls on the method
next(). Your first task, then, will be to convert a String of digits
into an array of 50 digits. As described above, you’ll want to shift
the number to the right and include leading 0’s in front. The String
method charAt and the method Character.getNumericValue will be helpful
for solving this part of the problem.
You are to add up each line of numbers, which means that you’ll have
to write some code that allows you to add together two of these
numbers or to add one of them to another. This is something you
learned in Elementary School to add starting from the right, keeping
track of whether there is a digit to carry from one column to the
next. Your challenge here is to take a process that you are familiar
with and to write code that performs the corresponding task.
Your program also must write out these numbers. In doing so, it should
not print any leading 0’s. Even though it is convenient to store the
number internally with leading 0’s, a person reading your output would
rather see these numbers without any leading 0’s.
You can assume that the input file has numbers that have 50 or fewer
digits and that the answer is always 50 digits or fewer. Notice,
however, that you have to deal with the possibility that an individual
number might be 0 or the answer might be 0. There will be no negative
integers in the input file.
You should solve this problem using arrays that are exactly 50 digits
long. Certain bugs can be solved by stretching the array to something
like 51 digits, but it shouldn’t be necessary to do that and you would
lose style points if your arrays require more than 50 digits.
The choice of 50 for the number of digits is arbitrary (a magic
number), so you should introduce a class constant that you use
throughout that would make it easy to modify your code to operate with
a different number of digits.
Consider the input file as an example of the kind of problems your
program must solve. We might use a more complex input file for actual
grading.
The Java class libraries include classes called BigInteger and
BigDecimal that use a strategy similar to what we are asking you to
implement in this program. You are not allowed to solve this problem
using BigInteger or BigDecimal. You must solve it using arrays of
digits.
Your program should be stored in a file called Sum.java.
Input file sum.txt
82384
204 435
22 31 12
999 483
28350 28345 39823 95689 234856 3482 55328 934803
7849323789 22398496 8940 32489 859320
729348690234239 542890432323 534322343298
3948692348692348693486235 5834938349234856234863423
999999999999999999999999 432432 58903 34
82934 49802390432 8554389 4789432789 0 48372934287
0
0 0 0
7482343 0 4879023 0 8943242
3333333333 4723 3333333333 6642 3333333333
Output that should be produced
82384 = 82384
204 + 435 = 639
22 + 31 + 12 = 65
999 + 483 = 1482
28350 + 28345 + 39823 + 95689 + 234856 + 3482 + 55328 + 934803 = 1420676
7849323789 + 22398496 + 8940 + 32489 + 859320 = 7872623034
729348690234239 + 542890432323 + 534322343298 = 730425903009860
3948692348692348693486235 + 5834938349234856234863423 = 9783630697927204928349658
999999999999999999999999 + 432432 + 58903 + 34 = 1000000000000000000491368
82934 + 49802390432 + 8554389 + 4789432789 + 0 + 48372934287 = 102973394831
0 = 0
0 + 0 + 0 = 0
7482343 + 0 + 4879023 + 0 + 8943242 = 21304608
3333333333 + 4723 + 3333333333 + 6642 + 3333333333 = 10000011364
Total lines = 14
My code thus far
public class Sum {
public static void main(String args[]) throws FileNotFoundException{
File file = new File("sum.txt");
Scanner scanner = new Scanner(file);
String[] myInts = new String[50];
int mySpot = 0;
while(scanner.hasNext()){
myInts[mySpot] = scanner.next();
mySpot++;
}
for(int i = 0; i < myInts.length; i++){
}
System.out.println(Character.getNumericValue(myInts[0]));
System.out.println(Arrays.toString(myInts));
}
}

When all else fails read the instructions:
"The approach you are to implement is to store each integer in an array of digits, with one digit per array element. We will be using arrays of length 50, so we will be able to store integers up to 50 digits long."
Tells me that this line:
String[] myInts = new String[50];
Has some significant problems.
Tip 1: Don't call it myInts when it's an array of String objects. Things are hard enough already.
Tip 2: Understand that new String[50] is not going to give you a string sized to 50 characters. It's going to give you space to store references to 50 string objects.
Tip 3: Understand that each line of your input can be solved separately so there is no need to remember anything from the lines you've solved before.
Tip 4: Read one line at a time into String line;
Tip 5: After reading a line solve the display problem in two parts: left side and right side of ='s.
Tip 6: Left side: display the line with spaces replaced with space + space. line.replace(" "," + ");
Tip 7: Right side: use line.split(" ") to split line on space, loop the split array of strings, each of these strings is what you'll be converting to int arrays.
Tip 8: "convert a String of digits into an array of 50 digits" <- Life will be easier if you write a method that does this. Take a String. Return an int[]. private int[] makeIntArray(String num) Take care of the "right shifting/leading zero" problem here.
Tip 9: int and long aren't big enough to hold the bigger numbers so break the number String down to Strings of digits before converting to int[].
Tip 10: Read Splitting words into letters in Java
Tip 11: Read Split string into array of character strings
Tip 12: Once you have single characters you can use Integer.parseInt(singleCharString[index--]) if you broke it down to an array of strings or Character.digit( chr[index--], 10); if you broke it down to an array of characters.
Tip 13: "write some code that allows you to add together two of these numbers or to add one of them to another." Read that carefully and it tells you that you really need to declare two vars. int[] sum = new sum[SIZE]; and int[] next = new next[SIZE]; where size is private final static int SIZE = 50;
Tip 14: adding two of these int[] numbers to produce a new int[] would be another good time to make a method. int[] sum(int[] op1, int[] op2)
Tip 15: Since all our int[]'s are right shifted already and always 50 long start a loop with i at 49 and count down. result[i-1] = (op1[i] + op2[i] + carry) % 10; and carry = (op1[i] + op2[i] + carry) / 10 will come in handy. Make sure to stop the loop at 1 or [i-1] will go index out of bounds on you.
Tip 16: Test, Test, and Test again. Make small changes then test. Small change, test. Don't just type and pray. Use the debugger if you like but personally I prefer to check values like this System.out.println("line: " + line);//TODO remove debugging code

Tip #1: Initialize the array with 0. That way, when you process the file, all you have to worry about is to replace the index locations with the digits obtained from your file.
Tip #2: You have to do some repeated division by 10 and modulus operation to extract the digits from the number (or binary shift if you prefer). For example, to split the the digits from '27', you can do 27 % 10 (7) and 27 / 10 (2). The key here is to store the result as int. After all, each digit is a whole number (not a floating point number). For number of greater magnitude, you will need to discard the process digit position so that the number gets smaller. You will now when you are done when the quotient of the division is equal to zero. Therefore, you can say in pseudo-code: DIVIDE number by 10 WHILE number > 0 (something like that)
Tip #3, you will have to iterate in reverse to store the digits in the array. If the array has a length of 50, you will start with LENGTH-1 and count down to ZER0.
Tip #4: Use an array of ints not an array of Strings if the problem allows you to. Use Integer.parseInt(String s) to convert the numeric String to a primitive int.

I think the question says to read each digit into a different array of standard size while you are reading all the words into a same a same array. and it will also be good to process this line by line
something like this
Scanner scanner = new Scanner(file);
int[][] myInts = new int[wordSize][];
int mySpot = 0;
while (scanner.hasNextLine()) {
Scanner scanner1 = new Scanner(scanner.nextLine());
while (scanner1.hasNext()) {
String s = scanner1.next();
int i;
for ( i= 0; i < wordSize - s.length(); i++) {
myInts[i][mySpot] = 0;
}
i--;
for (int j=0;j < s.length(); i++,j++) {
myInts[i][mySpot] = Character.digit(s.charAt(i), 10);
}
mySpot++;
}
// do the additions here and add this line to output file
}

Converting Roman Numeral to integer value? [duplicate]

This question already has answers here:
Converting Roman Numerals To Decimal
(30 answers)
Closed 8 years ago.
I'm a new programming student and my assignment is to convert the input of a Roman Numeral to it's integer value. Here is what I have been given:
Write a program that converts a Roman number such as MCMLXXVIII to its decimal number representation. This program must have 3 methods and a main method!
Write a method that takes input from the user and passes it to a conversion method.
Write a method that yields the numeric value of each of the letters (conversion method).
Write a method that outputs the number the user entered and the converted number.
Write a main method to test the 3 methods.
HINT: Use a single dimensional array!
Convert a string as follows:
• Look at the first two characters. If the first has a larger value than the second, then simply convert the first.
• Call the conversion method again for the substring starting with the second character.
• Add both values. o If the first one has a smaller value than the second, compute the difference and add to it the conversion of the tail.
Now I am struggling trying to figure out what to do for my conversion method. Here is what I have written so far:
public static String romanInput(String number) {
Scanner numberInput = new Scanner (System.in);
System.out.print("Enter a roman numeral: ");
String userInput = numberInput.next();
return userInput;
}
public static int numberConversion(int number) {
int romanConv = 0;
char[] romanChar = {1, 5, 10, 50, 100, 500, 1000};
for (int i = 0; i < romanChar.length; i++)
}
You could see that I have already written the method that takes the input from a user. I think I did this correctly. However, I don't know what to do for this conversion method. It says to use a single dimensional array so that's what I did over here:
char[] romanChar = {1, 5, 10, 50, 100, 500, 1000};
Those are supposed to be the values of I, V, X, L, C, D, and M. I'm really just confused as where to go from there and I would appreciate it if someone can help me out.

The Roman numeration is non-positional, meaning that the value of the digits does not depend on their position and you can ignore the latter. Then it suffices to add the values of all digits.
There is an exception anyway: if a digit immediately precedes a digit of a higher value, then it is subtracted instead of added.
So the processing is simply:
Clear an accumulator.
Read the digits from left to right. For new every digit, convert it to its value and add it to the accumulator. In the end the accumulator contains the number value.
To handle the exception, you can use the following trick:
Use a variable that holds the value of the previous digit (initially set to the value of M);
when the current digit has a higher value than the previous, you must correct the accumulator by subtracting twice the value of the previous.
Programmatically:
( Initialize )
Prv= 1000
Acc= 0
Loop:
( Accumulate )
Cur= Lookup(Digit[i])
Acc+= Cur
( Adjust for inversions )
if Prv < Cur -> Acc-= 2 * Prv
Prv= Cur
For instance, CXIX gives
Prv Cur Acc
C 1000 100 100
X 100 10 110
I 10 1 111
X 1 10 121-2*1 = 119

If I were you, I would begin by taking one baby step at a time. For example, if the only input I have to worry about is "I", then what? That is trivial of course.
Next, if the input is "II", then what? This suggests that I need to process the input one character at a time. Both the "I"s are equal to one each, and the result is the sum of the two. That means, I must have a "result" or some such variable, initialized to zero, and then for each character from the input string (I, then I), convert that to its numeric value (1, and then 1), add them up and return the value.
This logic works well for "III" also.
But then you face your first challenge with "IV". That is not trivial, specially if you are new to such an algorithm. Let me keep it aside, with a note that that is tough so will deal with this later.
The values "V", "VI", "VII", "VIII" all work fine with the above logic.
But then again I would be stuck with "IX". Similar to "IV" above. Maybe I have an idea about these two now, but then, maybe I'll still keep both these aside for the time being.
This works fine for "X", "XI", "XII", "XIII", and then again problem with "XIV".
I'll resist the temptation to solve the problems of "IV", "IX", "XIV" so that you can try them yourself; remember these are non-trivial, at least compared to what I have written above. Try it out.
So you see, incremental addition works well, but reduction is an unresolved problem.
Hope this helps.

OutOfBounds Exception ; working with Fractions

I'm writing a program called FractionScaler that takes in a fraction from the user using Scanner, and then manipulates it. I've written a fraction class that handles all the calculations. The user is supposed to enter a fraction like this: "2/3" or "43/65" etc... This part works fine, the problem is when there is space between the integers: " 3 / 4 " or "2/ 5" etc... An "OutOfBoundsException: String index out of range: -1" occurs. Let me explain further.
//This is the user inputted fraction. i.e. "2/3" or " 3 / 4"
String frac = scan.next();
//This finds the slash separating the numerator from the denominator
int slashLocate = frac.indexOf("/");
//These are new strings that separate the user inputted string into two parts on
//either side of the "/" sign
String sNum = frac.substring(0,slashLocate); //This is from the beginning of string to the slash (exclusive)
String sDenom = frac.substring(slashLocate+1,frac.length()); //from 1 after slash to end of string
//This trims the white space off of either side of the integers
sNum = sNum.trim(); //Numerator
sDenom = sDenom.trim(); //Denominator
What I thought should be left is just two strings that look like integers, now I need to turn those strings into actual integers.
//converts string "integer" into real int
int num = Integer.parseInt(sNum);
int denom = Integer.parseInt(sDenom);
Now that I have two integers for the numerator and the denominator, I can plug them into a constructor for the fraction class I wrote.
Fraction fraction1 = new Fraction(num, denom);
I doubt this is the best way to go about this, but it is the only way I could think of. When the user inputted fraction has no spaces, EX. "2/3" or "5/6" , the program works fine.
When the user input has spaces of any kind, EX. "3 / 4" or " 3 /4" , the following error is shown:
Exception in thread "main" java.lang.StringIndexOutOfBoundsException: String index out of range: -1.
The terminal points to line 17 of my code which is this line above:
String sNum = frac.substring(0,slashLocate);
I don't know why I'm getting an out of bounds error. Can anyone else figure it out?
If something is unclear or I didn't give enough info, just say so.
Thanks very much.

Try String frac = scan.nextLine();
I think next() won't get anything after a space.

From the documentation:
A Scanner breaks its input into tokens using a delimiter pattern,
which by default matches whitespace.
That means this won't work, because when entering 2 / 3, frac will just contain the text "2":
String frac = scan.next();
//This finds the slash separating the numerator from the denominator
int slashLocate = frac.indexOf("/");