Last requirement not met, have no idea why. Help please .

Level 41 , Gdansk, Poland

8 December 2020, 14:45

Integers are: from -2147483648 to 2147483647

Level 41

9 December 2020, 08:38

Hi Misiu, that is not the point because it pases the Integer task. It does not pass the "In all other cases" task and I don't quite know what that means

Level 41

9 December 2020, 08:38

If I write "-555000000000000000000000000000000000000000000000000000000000000000000000000000000 " it prints it is a string, which is the correct answer, because like you said. But if I write " This is a String. Value: -555000000000000000000000000000000000000000000000000000000000000000000000000000000 " nothing happens.

Level 36 , Germany

9 December 2020, 12:40

useful

For me it gives the desired output. However I do not think that is the problem. Eg. 0 gives This is an Integer. Value: 0 This is a String. Value: 0 I think the problem is the isNumeric method. I did not really check what it is doing and you probably neither. So it is out of your control. Just see the output for zero. Also 1e-10 doesn't get recognized as double. Keep it simple... to find out if the string is a double or int you just need to check for a double (double includes ints) -> Double.parseDouble() will do the entire work for you. Then you can do as suggested from CodeGym and look for a dot in the string. If there is none, you have an int. Or you parse for an int instead. Should work as well. Then the code frame could look similar to:

String theNumber = "5.2";
try {
    Double.parseDouble(theNumber);

    //instead of this inner try block you could do as CodeGym suggest an look for a dot
    //if (!theNumber.contains(".")) //more checks here;
    try {
        Integer.parseInt(theNumber);
        System.out.println("has to be an int, output it here or do some more int number checking");
    } catch (NumberFormatException e) {
        System.out.println("Double, not a integer... output the double here");
    }
} catch (NumberFormatException e) {
    System.out.println("String, not a double... output the string here");
}

Level 41 , Gdansk, Poland

9 December 2020, 12:51

Nothing? Eee... Prints all the string by print(String) This is a String. Value: This is a String. Value: -555000000000000000000000000000000000000000000000000000000000000000000000000000000 Line 86: Move this line to other place. Line 71: "For each value (except "exit"), call the print method."

Level 41

10 December 2020, 09:05

OK, so I managed to rewrite the code to a much simpler more elegant version thanks to your input but I am still not meeting the last criteria. Indeed, entering 1E-10 prints out as string but I have no idea what I could do to change that.

package com.codegym.task.task15.task1519;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.regex.Pattern;

/*
Different methods for different types

*/

public class Solution {
   static String nrInput = "";

   public static void main(String[] args) throws IOException {
        //write your code here
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        while(true) {
            nrInput = reader.readLine();

            if (nrInput.equals("exit")) {
                print(nrInput);
                break;
            }

            try{
                Double.parseDouble(nrInput);
                if (nrInput.contains(".")) print(Double.parseDouble(nrInput));
                else if ((Double.parseDouble(nrInput) <= 0 || Double.parseDouble(nrInput) >= 128))
                    print(Integer.parseInt(nrInput));
                else if ((Integer.parseInt(nrInput) > 0 && Integer.parseInt(nrInput) < 128))
                    print(Short.parseShort(nrInput));
            } catch (NumberFormatException e) {print(nrInput);}
        }
   }

    public static void print(Double value) {
        System.out.println("This is a Double. Value: " + value);
    }

    public static void print(String value) {
        System.out.println("This is a String. Value: " + value);
    }

    public static void print(short value) {
        System.out.println("This is a short. Value: " + value);
    }

    public static void print(Integer value) {
        System.out.println("This is an Integer. Value: " + value);
    }
}

Level 41

10 December 2020, 09:06

Sorry, Misiu, but I don't quite understand your feedback, I will try to go with Nouser's suggestions. Thank you, anyway!

Level 36 , Germany

10 December 2020, 11:19

solution

Read my answer to your other question. Then adapt your try-catch block in the same way (you probably can see by now that your actual code can't work). Reread my above answer, too. You can use the code frame and paste it into your solution. You'd just need to replace the println calls with your code.

Level 41 , Gdansk, Poland

10 December 2020, 13:12

solution

As you wish Andrei. My suggestions were: - comment (remove) line 71 - move line 86 a few lines up Validator doesn't care of numbers like 1e2. It takes them as a string. Only dot in number is important. My solution doesn't have any try-catch block. I used "-?\\d+(\\.\\d+)?" pattern to check if a data is a number. Then if a number contains dot. Your new code looks good, but: "2. For each value (except "exit"), call the print method"

Level 41

10 December 2020, 18:45

Thank you Nouser and Misiu, I ended up doing a combination of both. Misiu, I don't know in which kind of expression you used "-?\\d+(\\.\\d+)?" to check but I did a pattern.compile type of method. Please tell me how you used that expression.

public class Solution {
   static String nrInput = "";

    static Pattern pattern = Pattern.compile("-?\\d+(\\.\\d+)?");

    public static boolean isNumeric(String nrInput) {
        if (nrInput == null) {
            return false;
        }
        return pattern.matcher(nrInput).matches();
    }

   public static void main(String[] args) throws IOException {
        //write your code here
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        while(true) {
            nrInput = reader.readLine();

            if (nrInput.equals("exit")) {
                break;
            }

            if (isNumeric(nrInput)){
                if (nrInput.contains(".")){
                    print(Double.parseDouble(nrInput));
                }
                else if (Integer.parseInt(nrInput) <= 0 || Integer.parseInt(nrInput) >= 128)
                    print(Integer.parseInt(nrInput));
                else if ((Integer.parseInt(nrInput) > 0 && Integer.parseInt(nrInput) < 128))
                    print(Short.parseShort(nrInput));
            }
            else print((String) nrInput);
        }
   }

    public static void print(Double value) {
        System.out.println("This is a Double. Value: " + value);
    }

    public static void print(String value) {
        System.out.println("This is a String. Value: " + value);
    }

    public static void print(short value) {
        System.out.println("This is a short. Value: " + value);
    }

    public static void print(Integer value) {
        System.out.println("This is an Integer. Value: " + value);
    }
}

Level 41 , Gdansk, Poland

10 December 2020, 19:19

Super :) Nouser's posts always are interesting and helpful. Worth reading. if (string.matches("-?\\d+(\\.\\d+)?")) { ...... }

Level 41

11 December 2020, 08:05

Ah, so much simpler and nicer, haha!

Level 36 , Germany

11 December 2020, 13:26

To use regex is really cool and in a lot of cases very useful. But in my opinion its usage should be well considered and one should be aware that it is not easy to handle. If this task would have been a real world application using regex would probably have lead to problems. Try to run this code, I even haven't added scientific notation to the to check list. So it should be no problem to output the 4 double values inside the array. And when it comes to user input you have to expect everything.

String[] toCheck = new String[]{"1", "1.0", ".1", "1."};

for (String element : toCheck) {
    if (element.matches("-?\\d+(\\.\\d+)?")) {
        System.out.printf("%s is a double%n", element);
    }
}

And that's what I've learned here cause I tried also to solve a lot of task using regex. And not all task are so forgiving like that one here ;)

Level 41

11 December 2020, 13:44

Ah, ok. Very nice observation indeed. From your example .1 and 1. are not accepted, even though, in theory, they are double numbers. I would argue that one would need to use caution because including .1 and 1. as double from user input might create problems if maybe the input is something like " a.1" or "1.a" . No? Or your solution already provides a check for this type of scenario?

Level 36 , Germany

11 December 2020, 14:53

They are not just in theory doubles... try to declare them like double testDouble = .1; and you'll see that is perfectly OK. and you can also try if parseDouble will fit your use case...

List<String> toCheck = Arrays.asList(new String[]{"1", "1.0", ".1", "1.", "-1e-10", "a.1", "1.a"});
try {
    toCheck.forEach(element -> System.out.printf("%s is a double%n", Double.parseDouble(element)));
} catch (NumberFormatException ignore) {}
}

As said, using regex is fun, at least sometimes I think so. But if it'll get more complex you'll have to deal most probably with problems.