Develop Reference

Java StringToNUMBER - return 0 if the string contains anything other than digits and an initial "-" for negative numbers

I have to implement the following function in Java: public int stringToNumber(String input) without using Integer or any other class or method that parses the string. I have to loop over the characters of the string.
I attempted created a class that uses a loop to convert String to Integer.
Now, I am trying to figure out how I can return 0 if the string contains anything other than digits and an initial "-" for negative numbers.
Also I am trying to return 0 if the number is too large or too small for an int (Integer.MIN_SIZE to Integer.MAX_SIZE or -2^31 to 2^31 - 1).
Below is the code that I have so far.... Any help would be greatly appreciated
public class StringToNumber {
public static void main(String[] args) {
StringToNumber stn = new StringToNumber();
for (String arg : args) {
int number = stn.stringToNumber(arg);
System.out.format("Input number: %s, parsed number: %d %n", arg, number);
}
}
public int stringToNumber(String stn) {
int number = 0, factor = 1;
for (int n = stn.length()-1; n >= 0; n--) {
number += (stn.charAt(n) - '0') * factor;
factor *= 10;
}
return number;
}
}

Check if below code is working for you
public int stringToNumber(String stn) {
int number = 0, factor = 1;
int negative = 0;
if(stn.charAt(0)=='-') {
negative =1;
}
for (int n = negative; n < stn.length(); n++) {
int digit = stn.charAt(n)-'0';
if(digit<0 || digit>9)
return 0;
if((negative==0) && (Integer.MAX_VALUE-digit)/10 <number)
return 0;
else if ((negative==1) && (Integer.MAX_VALUE-digit+1)/10 <number)
return 0;
number = number*10+ (stn.charAt(n)-'0');
}
if(negative == 1) {
return -1*number;
}
return number;
}

Perhaps the best way to handle this would be to use Integer#parseInt(), which takes a string input and either returns an integer result or throws an exception if the input cannot be coerced to an integer:
public int stringToNumber(String stn) {
int result;
try {
result = Integer.parseInt(stn);
}
catch (NumberFormatException e) {
System.out.println("String input cannot be converted to integer: " + stn);
result = 0; // return 0 as the failure value
}
return result;
}

Find Max Number in String of Numbers

I have run into an interesting problem and wanted to know if anyone had any leads on how to solve it. When given a string of numbers, I want to find the highest number. So if the string is "2836", then the output should be 8, if the string is "12345" then the output should be 5 and so on. Here is the method I am working on:
public static void main(String[] args) {
max("215");
}
public static void max(String number) {
if (number.isEmpty()) {
System.out.println("The string is empty");
System.exit(0);
}
int compCount = 1;
int max = number.charAt(0);
int compare = number.charAt(compCount);
for (int i = 0; i < number.length(); i++) {
if (max > compare) {
compCount++;
} else if (compare > max) {
max = compare;
} else {
System.out.print(max);
}
}
System.out.print(max);
}
When this code executes it gives me 50 and I want 5

Well, you have a lot of wrong stuff going on. Firstly, you never change compare, Second, you take the int in ascii, and don't convert it to its Integer representation. Thirdly, you need only one if statement. All combined, it gives
int max = Character.getNumericValue(number.charAt(0));
for (int i = 1; i < number.length(); i++) {
int compare = Character.getNumericValue(number.charAt(i));
if (max < compare) {
max = compare;
}
}
return max;
I've used Character#getNumericValue to convert the char to int

Since ASCII codes of digits are sorted in ascending order you can easily do it with Java 8 like this:
public static void max(String number) {
if (number == null || number.isEmpty()) {
return;
}
int max = number.chars().max().getAsInt();
System.out.println(Character.getNumericValue((char) max));
}
If your input can has mix of digits and other symbols you also able to handle it:
public static void max(String number) {
if (number == null || number.isEmpty()) {
return;
}
OptionalInt max = number.chars().filter(Character::isDigit).max();
if (max.isPresent()) {
System.out.println(Character.getNumericValue((char) max.getAsInt()));
} else {
System.err.println("Provided string doesn't contain digits");
}
}

you have to modify your max method as given below
public static void max(String number) {
if (number.isEmpty()) {
System.out.println("The string is empty");
System.exit(0);
}
int max = Integer.parseInt(number.charAt(0)+"");
for (int i = 1; i < number.length(); i++) {
int compare = Integer.parseInt(number.charAt(i)+"");
if (compare > max) {
max = compare;
}
}
System.out.print(max);
}

How could I change my code to accept double values from the user?

import java.util.Scanner;
class MyCalculator {
public static void main(String[] args){
Scanner input = new Scanner(System.in);
System.out.println("Enter a expression : ");
while(input.hasNext()){
String exp = input.next();
System.out.println(""+exp+" = "+ Calculate(exp));
}
}
//define a method to decide the operators' priority
private static int priority(char input){
switch(input){
case'(' : return 3; //parenthesis have highest priority
case')' : return 3;
case'*' : return 2; //multiplication and division have lower priority than parenthesis
case'/' : return 2;
case'+' : return 1; //plus minus have lowest operator priority
case'-' : return 1;
default : return 0;//numbers have lowest priority
}
}
//now we define our big method Calculate
public static int Calculate(String exp){
//firstly we try to check if the exp is already a number or a simple expression
//or having high level operator
//the key recursive idea is to compute inner results if there is higher level operators
//until the result is return
char[] inputs = exp.toCharArray();//we process string to char arrays for easy control
//now we check the highest level operators and the count
int highestPriority =0;
int operatorCount =0;//this value is to keep track of how many operators remaining, mostly to deal with negative number cases
for(int i=0;i<inputs.length;i++)
{
if(priority(inputs[i])>highestPriority)
{
highestPriority = priority(inputs[i]);//update highest priority if necessary
}
if(priority(inputs[i])>0)
{
++operatorCount;
}
}
//after that we process in order
if(operatorCount==0)//no operator remaining
{
return Integer.parseInt(exp);//Immediately return the result
}
else if(highestPriority==1){//-+ remaining
//we firstly deal with the negative numbers
if(operatorCount==1 && inputs[0]=='-')//if only operator is the leading minus operator
{
return Integer.parseInt(exp);
}
//otherwise, we need to find the operatorand compute result
int opePosition = -1;//set as -1 as non set
boolean ifPlusSign = true;//this is to know if plus or minus sign
for(int i=0;i<inputs.length;i++)
{
//notice we may encounter the case of -1-1, thus the leading minus sign should be ignored
if(inputs[i]== '+' || (inputs[i]=='-' && i!=0))// we differenciate here because we need know if plus or minus sign
{
opePosition = i;
ifPlusSign = inputs[i] == '+'?true:false;
break;
}
}
//after we identify the opePosition, we need find start/end of left and right operand
int leftOperandStart = 0;
int rightOperandEnd = opePosition+1;
//we need to deal with negative value cases
if(inputs[rightOperandEnd]=='-')
{
rightOperandEnd++;
}
while(rightOperandEnd<inputs.length && priority(inputs[rightOperandEnd])<1)
{
rightOperandEnd++;
}
int leftOperand = Integer.parseInt(exp.substring(0, opePosition));
int rightOperand = Integer.parseInt(exp.substring(opePosition+1, rightOperandEnd));
int innerResult = 0;
if(ifPlusSign)
{
innerResult = leftOperand+rightOperand;
}
else
{
innerResult = leftOperand - rightOperand;
}
return Calculate(""+ innerResult+ exp.substring(rightOperandEnd));
}
else if(highestPriority==2)
{
// */ remaining
/*if(operatorCount==1 && inputs[0]=='-'){
return Integer.parseInt(exp);
}*/
int opePosition = -1;
boolean ifMultiplySign = true;//this is to know if plus or minus sign
for(int i=0;i<inputs.length;i++)
{
if(inputs[i]== '*' || (inputs[i]=='/' && i!=0))
{
opePosition = i;
ifMultiplySign = inputs[i] == '+'?true:false;
break;
}
}
int leftOperandStart = opePosition-1;
while(leftOperandStart>=0 && priority(inputs[leftOperandStart])<1)
{
leftOperandStart--;
}
int rightOperandEnd = opePosition+1;
if(inputs[rightOperandEnd]=='-')
{
rightOperandEnd++;
}
while( rightOperandEnd<inputs.length && priority(inputs[rightOperandEnd])<1)
{
rightOperandEnd++;
}
int leftOperand = Integer.parseInt(exp.substring(leftOperandStart+1, opePosition));
int rightOperand = Integer.parseInt(exp.substring(opePosition+1, rightOperandEnd));
int innerResult = 0;
if(ifMultiplySign)innerResult = leftOperand * rightOperand;
else innerResult = leftOperand / rightOperand;
return Calculate(exp.substring(0, leftOperandStart+1)+innerResult+exp.substring(rightOperandEnd));
}
else
{
int parOpen = -1;
int parEnd = -1;
int parOpenEndiff = 0;
for(int i=0;i<inputs.length;i++)
{
if(inputs[i]=='(')
{
parOpen=parOpen<0?i:parOpen;
parOpenEndiff++;
}
else if(inputs[i]==')')
{
parOpenEndiff--;
if(parOpenEndiff==0)
{
parEnd = i;
break;
}
}
}
int innerResult = Calculate(exp.substring(parOpen+1,parEnd));
return Calculate(exp.substring(0, parOpen)+innerResult+exp.substring(parEnd+1));
}
}
}
How could I change my code to accept double value from the user ? (actually this program works fine with int values ).please could you help me to customize the program for double values also .....

String exp = input.next(); --> double exp = input.nextDouble();
Or:
String exp = input.next();
double value = Double.parseDouble(exp);
Do double value = Double.parseDouble(exp); in switch default case.

Luhn Check program in Java not calculating correctly

I created this Luhn Check (or Mod 10 check) in Java and the Even and Odd sums aren't adding up correctly and I can't figure out why. It worked when I wrote that one section out separately and it seemed to work fine. As a whole program with all the other Methods it doesn't work. Anyone have any ideas?
Entering the number 4388576018410707 should be valid.
import java.util.Scanner;
import java.io.*;
public class combineAll {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("Enter a credit card number: ");
long userInput = input.nextLong();
int getSize=getSize(userInput); //Run getSize() Method.
Integer z = (int) (long) getPrefix(userInput, getSize); //Run getPrefix() Method.
if (prefixMatch(userInput, z)== true) { //Run prefixMatch() Method.
long n=sumbOfDoubleEvenPlace(userInput); //Run sumbOfDoubleEvenPlace() Method.
long m=sumOfOddPlace(userInput); //Run sumOfOddPlace() Method.
System.out.println("Total Even: " +n);
System.out.println("Total Odd: " +m);
long v=n+m;
if (isValid(v)==true) {
System.out.println("Valid");
} else if (isValid(v)==false){
System.out.println("Invalid");
}
} else {
System.out.println("Invalid");
}
} //End main
//Return the number of digits in d
public static int getSize(long d) {
String str = Long.toString(d);
int x = str.length();
return x;
}
//Return the first k number of digits from number. If the number of digits in number is less than k, return number
public static long getPrefix(long number, int k) {
int z=0;
if (k>=13 && k<=16) {
String str = Long.toString(number);
String g = str.substring(0,1);
String h = str.substring(0,2);
int d=Integer.parseInt(g);
int q=Integer.parseInt(h);
if (d==4 || d==5 ||d==6) {
z=d;
} else if (q==37) {
z=q;
}
} else {
z=-1;
}
return z;
}
//Return true if the digit d is a prefix for number
public static boolean prefixMatch(long number, int d) {
if (d==4 || d==5 || d==6 || d==37) {
return true;
} else {
return false;
}
}
//Get the result from step 2
public static int sumbOfDoubleEvenPlace(long number) {
long a=number;
int d=0; //Adds each individual numbers.
while (a>0) {
long b=0;
long c=0; //Equals the Mod of UserInput.
a=a/10;
c=a%10;
System.out.println("even: " +c);
b=c*2;
if (b>=10) {
Integer digit = (int) (long) b;
d+=getDigit(digit); //Run getDigit() Method.
} else {
Integer digit = (int) (long) b;
d+=b;
}
a=a/10; //Advance decimal one space to the left.
}
return d;
}
//Return sum of odd-place digits in number
public static int sumOfOddPlace(long number) {
long a=number;
int d=0; //Adds each individual numbers.
while (a>0) {
long b=0;
long c=0; //Equals the Mod of UserInput.
c=a%10;
System.out.println("odd: " +c); //Print for debugging.
b=c*2;
if (b>=10) {
Integer digit = (int) (long) b;
d+=getDigit(digit); //Run getDigit() Method.
} else {
Integer digit = (int) (long) b;
d+=b;
}
a=a/10; //Advance decimal one space to the left.
a=a/10;
}
return d;
}
//Return this number if it is a single digit, otherwise return the sum of the two digits
public static int getDigit(int number) {
int d=0;
int x=0;
int y=number;
while (y>0) {
x+=y%10;
y=y/10;
}
return x;
}
//Return true if the card number is valid
public static boolean isValid(long number) {
long c=number%10;
if (c==0) {
return true;
} else {
return false;
}
}
}

The code is a little hard to follow. Based on the algorithm description form Wikipedia the implementation should be much simpler.
Here is other implementation following the description from Wikipedia.
public class Cards {
/**
* Checks if the card is valid
*
* #param card
* {#link String} card number
* #return result {#link boolean} true of false
*/
public static boolean luhnCheck(String card) {
if (card == null)
return false;
char checkDigit = card.charAt(card.length() - 1);
String digit = calculateCheckDigit(card.substring(0, card.length() - 1));
return checkDigit == digit.charAt(0);
}
/**
* Calculates the last digits for the card number received as parameter
*
* #param card
* {#link String} number
* #return {#link String} the check digit
*/
public static String calculateCheckDigit(String card) {
if (card == null)
return null;
String digit;
/* convert to array of int for simplicity */
int[] digits = new int[card.length()];
for (int i = 0; i < card.length(); i++) {
digits[i] = Character.getNumericValue(card.charAt(i));
}
/* double every other starting from right - jumping from 2 in 2 */
for (int i = digits.length - 1; i >= 0; i -= 2) {
digits[i] += digits[i];
/* taking the sum of digits grater than 10 - simple trick by substract 9 */
if (digits[i] >= 10) {
digits[i] = digits[i] - 9;
}
}
int sum = 0;
for (int i = 0; i < digits.length; i++) {
sum += digits[i];
}
/* multiply by 9 step */
sum = sum * 9;
/* convert to string to be easier to take the last digit */
digit = sum + "";
return digit.substring(digit.length() - 1);
}
public static void main(String[] args) {
String pan = "4388576018410707";
System.out.println("Validate pan number '" + pan + "': " + luhnCheck(pan2));
}
}

Uva's 3n+1 problem

I'm solving Uva's 3n+1 problem and I don't get why the judge is rejecting my answer. The time limit hasn't been exceeded and the all test cases I've tried have run correctly so far.
import java.io.*;
public class NewClass{
/**
* #param args the command line arguments
*/
public static void main(String[] args) throws IOException {
int maxCounter= 0;
int input;
int lowerBound;
int upperBound;
int counter;
int numberOfCycles;
int maxCycles= 0;
int lowerInt;
BufferedReader consoleInput = new BufferedReader(new InputStreamReader(System.in));
String line = consoleInput.readLine();
String [] splitted = line.split(" ");
lowerBound = Integer.parseInt(splitted[0]);
upperBound = Integer.parseInt(splitted[1]);
int [] recentlyused = new int[1000001];
if (lowerBound > upperBound )
{
int h = upperBound;
upperBound = lowerBound;
lowerBound = h;
}
lowerInt = lowerBound;
while (lowerBound <= upperBound)
{
counter = lowerBound;
numberOfCycles = 0;
if (recentlyused[counter] == 0)
{
while ( counter != 1 )
{
if (recentlyused[counter] != 0)
{
numberOfCycles = recentlyused[counter] + numberOfCycles;
counter = 1;
}
else
{
if (counter % 2 == 0)
{
counter = counter /2;
}
else
{
counter = 3*counter + 1;
}
numberOfCycles++;
}
}
}
else
{
numberOfCycles = recentlyused[counter] + numberOfCycles;
counter = 1;
}
recentlyused[lowerBound] = numberOfCycles;
if (numberOfCycles > maxCycles)
{
maxCycles = numberOfCycles;
}
lowerBound++;
}
System.out.println(lowerInt +" "+ upperBound+ " "+ (maxCycles+1));
}
}

Are you making sure to accept the entire input? It looks like your program terminates after reading only one line, and then processing one line. You need to be able to accept the entire sample input at once.

I faced the same problem. The following changes worked for me:
Changed the class name to Main.
Removed the public modifier from the class name.
The following code gave a compilation error:
public class Optimal_Parking_11364 {
public static void main(String[] args) {
...
}
}
Whereas after the changes, the following code was accepted:
class Main {
public static void main(String[] args) {
...
}
}
This was a very very simple program. Hopefully, the same trick will also work for more complex programs.

If I understand correctly you are using a memoizing approach. You create a table where you store full results for all the elements you have already calculated so that you do not need to re-calculate results that you already know (calculated before).
The approach itself is not wrong, but there are a couple of things you must take into account. First, the input consists of a list of pairs, you are only processing the first pair. Then, you must take care of your memoizing table limits. You are assuming that all numbers you will hit fall in the range [1...1000001), but that is not true. For the input number 999999 (first odd number below the upper limit) the first operation will turn it into 3*n+1, which is way beyond the upper limit of the memoization table.
Some other things you may want to consider are halving the memoization table and only memorize odd numbers, since you can implement the divide by two operation almost free with bit operations (and checking for even-ness is also just one bit operation).

Did you make sure that the output was in the same order specified in the input. I see where you are swapping the input if the first input was higher than the second, but you also need to make sure that you don't alter the order it appears in the input when you print the results out.
ex.
Input
10 1
Output
10 1 20

If possible Please use this Java specification : to read input lines
http://online-judge.uva.es/problemset/data/p100.java.html
I think the most important thing in UVA judge is 1) Get the output Exactly same , No Extra Lines at the end or anywhere . 2) I am assuming , Never throw exception just return or break with No output for Outside boundary parameters.
3)Output is case sensitive 4)Output Parameters should Maintain Space as shown in problem
One possible solution based on above patterns is here
https://gist.github.com/4676999
/*
Problem URL: http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=36
Home>Online Judge > submission Specifications
Sample code to read input is from : http://online-judge.uva.es/problemset/data/p100.java.html
Runtime : 1.068
*/
import java.io.*;
import java.util.*;
class Main
{
static String ReadLn (int maxLg) // utility function to read from stdin
{
byte lin[] = new byte [maxLg];
int lg = 0, car = -1;
String line = "";
try
{
while (lg < maxLg)
{
car = System.in.read();
if ((car < 0) || (car == '\n')) break;
lin [lg++] += car;
}
}
catch (IOException e)
{
return (null);
}
if ((car < 0) && (lg == 0)) return (null); // eof
return (new String (lin, 0, lg));
}
public static void main (String args[]) // entry point from OS
{
Main myWork = new Main(); // create a dinamic instance
myWork.Begin(); // the true entry point
}
void Begin()
{
String input;
StringTokenizer idata;
int a, b,max;
while ((input = Main.ReadLn (255)) != null)
{
idata = new StringTokenizer (input);
a = Integer.parseInt (idata.nextToken());
b = Integer.parseInt (idata.nextToken());
if (a<b){
max=work(a,b);
}else{
max=work(b,a);
}
System.out.println (a + " " + b + " " +max);
}
}
int work( int a , int b){
int max=0;
for ( int i=a;i<=b;i++){
int temp=process(i);
if (temp>max) max=temp;
}
return max;
}
int process (long n){
int count=1;
while(n!=1){
count++;
if (n%2==1){
n=n*3+1;
}else{
n=n>>1;
}
}
return count;
}
}

Please consider that the integers i and j must appear in the output in the same order in which they appeared in the input, so for:
10 1
You should print
10 1 20

package pandarium.java.preparing2topcoder;/*
* Main.java
* java program model for www.programming-challenges.com
*/
import java.io.*;
import java.util.*;
class Main implements Runnable{
static String ReadLn(int maxLg){ // utility function to read from stdin,
// Provided by Programming-challenges, edit for style only
byte lin[] = new byte [maxLg];
int lg = 0, car = -1;
String line = "";
try
{
while (lg < maxLg)
{
car = System.in.read();
if ((car < 0) || (car == '\n')) break;
lin [lg++] += car;
}
}
catch (IOException e)
{
return (null);
}
if ((car < 0) && (lg == 0)) return (null); // eof
return (new String (lin, 0, lg));
}
public static void main(String args[]) // entry point from OS
{
Main myWork = new Main(); // Construct the bootloader
myWork.run(); // execute
}
public void run() {
new myStuff().run();
}
}
class myStuff implements Runnable{
private String input;
private StringTokenizer idata;
private List<Integer> maxes;
public void run(){
String input;
StringTokenizer idata;
int a, b,max=Integer.MIN_VALUE;
while ((input = Main.ReadLn (255)) != null)
{
max=Integer.MIN_VALUE;
maxes=new ArrayList<Integer>();
idata = new StringTokenizer (input);
a = Integer.parseInt (idata.nextToken());
b = Integer.parseInt (idata.nextToken());
System.out.println(a + " " + b + " "+max);
}
}
private static int getCyclesCount(long counter){
int cyclesCount=0;
while (counter!=1)
{
if(counter%2==0)
counter=counter>>1;
else
counter=counter*3+1;
cyclesCount++;
}
cyclesCount++;
return cyclesCount;
}
// You can insert more classes here if you want.
}

This solution gets accepted within 0.5s. I had to remove the package modifier.
import java.util.*;
public class Main {
static Map<Integer, Integer> map = new HashMap<>();
private static int f(int N) {
if (N == 1) {
return 1;
}
if (map.containsKey(N)) {
return map.get(N);
}
if (N % 2 == 0) {
N >>= 1;
map.put(N, f(N));
return 1 + map.get(N);
} else {
N = 3*N + 1;
map.put(N, f(N) );
return 1 + map.get(N);
}
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
try {
while(scanner.hasNextLine()) {
int i = scanner.nextInt();
int j = scanner.nextInt();
int maxx = 0;
if (i <= j) {
for(int m = i; m <= j; m++) {
maxx = Math.max(Main.f(m), maxx);
}
} else {
for(int m = j; m <= i; m++) {
maxx = Math.max(Main.f(m), maxx);
}
}
System.out.println(i + " " + j + " " + maxx);
}
System.exit(0);
} catch (Exception e) {
}
}
}