Just starting learning java today and can't seem to figure this out. I am following the tutorial on learnjavaonline.org which teaches you a few things and then asks you to write a code to do a specific thing, it then checks the output to see if its correct. The thing is, if its not correct, it doesn't say why, or give you an example of the correct code.
It wants me to output a string saying "H3110 w0r1d 2.0 true" using all of the primitives
i came up with this
public class Main {
public static void main(String[] args) {
char h = 'H';
byte three = 3;
short one = 1;
boolean t = true;
double ten = 10;
float two = (float) 2.0;
long won = 1;
int zero = 0;
String output = h + three + one + ten + " " + "w" + zero + "r" + won + "d " + two + " " + t;
System.out.println(output);
}
}
but it outputs 86.0 w0r1d 2.0 true
how can i make it so it doesn't add all the integers, but displays them consecutively?
The problem with this line:
String output = h + three + one + ten + " " + "w" + zero + "r" + won + "d " + two + " " + t;
is that operations are performed left to right, so it first sums h + three (which evaluates to an int) and then one and then ten. Up to that point you have a numerical value (an int) that then will be "summed" to a String. Try something like this:
String output = "" + h + three + one + ten + " " + "w" + zero + "r" + won + "d " + two + " " + t;
In this second case your expression will start with a String object, evaluating the rest of the operations as Strings.
You of course could use "" at the beginning or any other value that evaluates to String, like String.valueOf(h). In this last case you wouldn't need to use String.valueOf() for the other operands, as the first one is already a String.
You can either convert your numbers into a string using the toString or valueOf methods of the wrapper classes (guess you are not there yet), or just stuff all your primitives into the printline without the String output.
system.out.println(h + three + one + ten + " " + "w" + zero + "r" + won + "d " + two + " " + t);
All you need to look for is that there is a String in the printline statement. Meaning if you only want to print our number based datatype you can use system.out.println("" + youNumberVariable).
There would also be the option to add an empty string at the beginning of your declaration of output output = "" + theRest; to force all following values into the string like it does in the printline statement.
Most of it is not very pretty coding but will completly suffice for the learning process.
An easy and ugly way to do this would be to use String.valueOf for each numerical value.
As in:
String output = h + String.valueOf(three); // + etc...
Edit
morgano's approach is perfectly valid as well - +1 for that.
On a more general topic, you might want to use String.concat for String concatenation, or even better, a StringBuilder object.
This SO page contains a lot of info you can use on the matter.
I would use String.valueOf to explicitly cast each numeric value to String before being added. Like so:
String output = h + String.valueOf( three ) + String.valueOf( one ) + String.valueOf( ten ) + " " + "w" + String.valueOf( zero ) + "r" + String.valueOf( won ) + "d " + String.valueOf( two ) + " " + t;
The trick is to get the compiler to interpret + as string concatenation (which then silently convert the numbers to strings) instead of adding two numbers. This mean that one of the two arguments to + must be a string, and not - as your first three arguments - numbers (and yes, a char is a number).
It is not typical in code in the wild to want numbers to be directly adjacent to each other, but have a space between them, like:
String output = h + " " + three + " " + one + " " + ten + " " + "w" + zero + "r" + won + "d " + two + " " + t;
If you really want to have no spaces, then just let the first argument be the empty string:
String output = "" + h ....
You could also just change h from char to String.
The result you're getting is because, essentially, you're doing arithmetical operations on numeric variable before printing them when relying on implicit casting.
Even the Char is a numeral! H has the value 72 in the ascii table, so you are basically instructing the Java program to print the result of:
72 + 3 + 1 + 10.0 (which is equal to 86.0)
String concatenation with mixed inputs of numerals and symbols like this can be problematic since implicit casting is in play.
In order to make sure stuff is as you want, without using explicit casting, maybe use either strings between each numeric value, like this:
char h = 'H'; // This is a numeral! Capital H has value 72 in Ascii table
byte three = 3;
short one = 1;
boolean t = true; // not a numeral
double ten = 10;
float two = (float) 2.0;
long lOne = 1;
int zero = 0;
System.out.println(h + "" + three + "" + one + "" + (int) ten + " w"
+ zero + "r" + lOne + "d " + two + " " + t );
Note how I needed to cast ten to the int-type, to lose the decimal...
Above example is however not a good example of using string concatenations!
For a proper solution, and this is maybe more aimed at people with more experience, is to try using String formatting, like this:
System.out.println(String.format("%s%s%s%s w%sr%sd %s %s", h, three, one,
(int) ten, zero, lOne, two, t));
Another way is to use message formatting like this, maybe not the best choice for this assignment since the float will be printed as an integer. Also needs to import java.text.MessageFormat
// please note: the double and the float won't print decimals!
// note: import java.text.MessageFormat for this
System.out.println(MessageFormat.format("{0}{1}{2}{3} w{4}r{5}d {6} {7}", h,
three, one, (int) ten, zero, lOne, two, t));
More examples from the Ascii table.
public class Main {
public static void main(String[] args) {
int b = 3110;
int d = 0;
String e = "orld";
double f = 2;
boolean g = true;
System.out.println("H" + b + " " + "w" + d + e + " " + f + " " + g);
}
}
Related
I know that it is a horrible question to ask at this forum since I do know the rules but at the moment I just do not know what the issue is here. So for anyone that has some spare time I would be very thankful if it could be answered. I tried to carry out the Euler Project exercise number 13: Work out the first ten digits of the sum of the following one-hundred 50-digit numbers.
I know the logic that I have used behind it is not the best and later I managed to solve the problem using another method, but it still bothers me until today why does the following code not work:
import java.util.ArrayList;
public class LargeSum {
public static ArrayList<String> addAll(ArrayList<ArrayList<Integer>> listOfResults) {
ArrayList<String> result = new ArrayList<String>();
int singlesum = 0;
int remainder = 0;
for (int i = 49; i >= 0; i--) {
System.out.println(remainder + "to rem");
singlesum += remainder;
for (ArrayList<Integer> list : listOfResults) {
System.out.println(list.get(i));
singlesum += list.get(i);
}
String lastChar = String.valueOf(singlesum);
singlesum = 0;
result.add(String.valueOf(lastChar.charAt(lastChar.length() - 1)));
remainder = 0;
if (lastChar.length() > 1) {
remainder = Integer.parseInt(lastChar.substring(0, lastChar.length() - 1));
}
}
if (remainder > 0)
result.add(String.valueOf(remainder));
return result;
}
public static ArrayList<ArrayList<Integer>> createLists() {
ArrayList<ArrayList<Integer>> results = new ArrayList<ArrayList<Integer>>();
String c =
"37107287533902102798797998220837590246510135740250"
+ "46376937677490009712648124896970078050417018260538"
+ "74324986199524741059474233309513058123726617309629"
+ "91942213363574161572522430563301811072406154908250"
+ "23067588207539346171171980310421047513778063246676"
+ "89261670696623633820136378418383684178734361726757"
+ "28112879812849979408065481931592621691275889832738"
+ "44274228917432520321923589422876796487670272189318"
+ "47451445736001306439091167216856844588711603153276"
+ "70386486105843025439939619828917593665686757934951"
+ "62176457141856560629502157223196586755079324193331"
+ "64906352462741904929101432445813822663347944758178"
+ "92575867718337217661963751590579239728245598838407"
+ "58203565325359399008402633568948830189458628227828"
+ "80181199384826282014278194139940567587151170094390"
+ "35398664372827112653829987240784473053190104293586"
+ "86515506006295864861532075273371959191420517255829"
+ "71693888707715466499115593487603532921714970056938"
+ "54370070576826684624621495650076471787294438377604"
+ "53282654108756828443191190634694037855217779295145"
+ "36123272525000296071075082563815656710885258350721"
+ "45876576172410976447339110607218265236877223636045"
+ "17423706905851860660448207621209813287860733969412"
+ "81142660418086830619328460811191061556940512689692"
+ "51934325451728388641918047049293215058642563049483"
+ "62467221648435076201727918039944693004732956340691"
+ "15732444386908125794514089057706229429197107928209"
+ "55037687525678773091862540744969844508330393682126"
+ "18336384825330154686196124348767681297534375946515"
+ "80386287592878490201521685554828717201219257766954"
+ "78182833757993103614740356856449095527097864797581"
+ "16726320100436897842553539920931837441497806860984"
+ "48403098129077791799088218795327364475675590848030"
+ "87086987551392711854517078544161852424320693150332"
+ "59959406895756536782107074926966537676326235447210"
+ "69793950679652694742597709739166693763042633987085"
+ "41052684708299085211399427365734116182760315001271"
+ "65378607361501080857009149939512557028198746004375"
+ "35829035317434717326932123578154982629742552737307"
+ "94953759765105305946966067683156574377167401875275"
+ "88902802571733229619176668713819931811048770190271"
+ "25267680276078003013678680992525463401061632866526"
+ "36270218540497705585629946580636237993140746255962"
+ "24074486908231174977792365466257246923322810917141"
+ "91430288197103288597806669760892938638285025333403"
+ "34413065578016127815921815005561868836468420090470"
+ "23053081172816430487623791969842487255036638784583"
+ "11487696932154902810424020138335124462181441773470"
+ "63783299490636259666498587618221225225512486764533"
+ "67720186971698544312419572409913959008952310058822"
+ "95548255300263520781532296796249481641953868218774"
+ "76085327132285723110424803456124867697064507995236"
+ "37774242535411291684276865538926205024910326572967"
+ "23701913275725675285653248258265463092207058596522"
+ "29798860272258331913126375147341994889534765745501"
+ "18495701454879288984856827726077713721403798879715"
+ "38298203783031473527721580348144513491373226651381"
+ "34829543829199918180278916522431027392251122869539"
+ "40957953066405232632538044100059654939159879593635"
+ "29746152185502371307642255121183693803580388584903"
+ "41698116222072977186158236678424689157993532961922"
+ "62467957194401269043877107275048102390895523597457"
+ "23189706772547915061505504953922979530901129967519"
+ "86188088225875314529584099251203829009407770775672"
+ "11306739708304724483816533873502340845647058077308"
+ "82959174767140363198008187129011875491310547126581"
+ "97623331044818386269515456334926366572897563400500"
+ "42846280183517070527831839425882145521227251250327"
+ "55121603546981200581762165212827652751691296897789"
+ "32238195734329339946437501907836945765883352399886"
+ "75506164965184775180738168837861091527357929701337"
+ "62177842752192623401942399639168044983993173312731"
+ "32924185707147349566916674687634660915035914677504"
+ "99518671430235219628894890102423325116913619626622"
+ "73267460800591547471830798392868535206946944540724"
+ "76841822524674417161514036427982273348055556214818"
+ "97142617910342598647204516893989422179826088076852"
+ "87783646182799346313767754307809363333018982642090"
+ "10848802521674670883215120185883543223812876952786"
+ "71329612474782464538636993009049310363619763878039"
+ "62184073572399794223406235393808339651327408011116"
+ "66627891981488087797941876876144230030984490851411"
+ "60661826293682836764744779239180335110989069790714"
+ "85786944089552990653640447425576083659976645795096"
+ "66024396409905389607120198219976047599490197230297"
+ "64913982680032973156037120041377903785566085089252"
+ "16730939319872750275468906903707539413042652315011"
+ "94809377245048795150954100921645863754710598436791"
+ "78639167021187492431995700641917969777599028300699"
+ "15368713711936614952811305876380278410754449733078"
+ "40789923115535562561142322423255033685442488917353"
+ "44889911501440648020369068063960672322193204149535"
+ "41503128880339536053299340368006977710650566631954"
+ "81234880673210146739058568557934581403627822703280"
+ "82616570773948327592232845941706525094512325230608"
+ "22918802058777319719839450180888072429661980811197"
+ "77158542502016545090413245809786882778948721859617"
+ "72107838435069186155435662884062257473692284509516"
+ "20849603980134001723930671666823555245252804609722";
for (int i = 0; i < 4950; i += 50) {
ArrayList<Integer> strings = new ArrayList<Integer>();
for (int j = i; j <= i + 49; j++) {
strings.add(Integer.parseInt(String.valueOf(c.charAt(j))));
}
results.add(strings);
}
return results;
}
public static void main(String[] args) {
ArrayList<ArrayList<Integer>> results = createLists();
System.out.println(addAll(results));
}
}
The array should give me the number from the back one by one each digit of the number yet I do not get the answer to the question. I investigated this many times for smaller numbers (where it worked) and for only two numbers (and it worked) yet I cannot get the answer to the question (I always get another number as result not the designated Result: 5537376230).
Thanks to everybody that looks at the code.
Best regards,
Rob
I believe the main source of the issue lies in the fact that you hardcoded a lot of numerical values and thus can not really verify correctness in the middle steps. Especially bad idea is using single String instead of the array of String[] for your source data.
Anyway, if you re-check the task you may find that the last numbers are:
...
72107838435069186155435662884062257473692284509516
20849603980134001723930671666823555245252804609722
53503534226472524250874054075591789781264330331690
while in your code you have:
+ "72107838435069186155435662884062257473692284509516"
+ "20849603980134001723930671666823555245252804609722";
So you just missed the last number and that spoils the result.
Sidenotes:
you don't really handle the top digits (your "top" digit is "55") properly which is a result of a lot of hardcoding but you probably already know that.
In java there is a BigInteger class that can solves this task easily. It is OK to write your own code for learning but for the real world task you should use a standard library unless you have a good reason not to use it.
In the case where you have a remainder left over, you add it to result as a string. But the digits in your results are reversed, so you also need to reverse the digits of the remainder.
It also looks like you've got an off-by-one error in the construction of your numbers. i < 4950 should be i < 5000 I think, since the 100th number starts at index 99 * 50 = 4950.
Generate by use of the operator + a string, that the values in the variable in the given ones on top
Order includes, in each case apart by ",". give the string with System out println (...).
Remove the quotes " and call toString()
str = hexValue.toString() + ", " + octValue.toString() + ", " + l.toString() + ", " + var1.toString() + ", " + var2.toString() + ", " + var3.toString() + ", " + var4.toString() + ", " + c.toString();
now notice that this will give you the decimal values.. if you want the hex, octal, etc, that's a different question.
Suppose we have the following variables:
int age = 5;
String name = "Mohammad";
double weight = 68.4;
If we want to print them out joined in a string with one statement we can say:
System.out.println("My name is " + name + ", I am " + age + " years old, " + " I once caught a fish that weighs " + weight +"kg");
In Java, using the + operator you can concatenate strings.
Note: age, name, and weight are all of different types, but when you put the + operator with a String, java automatically convert that variable to a string and then concatenates it with the rest of the string. Hence, if you wish to perform some kind of operation then concatenate, then you should make use of parentheses ():
System.out.println("Two Plus Five is = " + (2 + 5));
I would like to concatenate a few variables into a string variable but I am unable to get it to work. When I compile it says "not a statement" and "; expected."
float a = 1;
float b = 2;
String resW;
My purpose is to concatenate "a" and "b" and assign it to resW.
resW = a " + " b;
My ultimate goal is to use resW as such...
System.out.println(resW);
bufferedWriter.write(resW);
It should save to a file in the format of "1 + 2". I don't understand how to do this properly or if this is even possible.
String resW = a + " + " + b;
try this..
resW = a + " + " + b;
Use a plus sign to concatenate Strings.
It should allow an autoconversion from float to String, but if it doesn't, you can change the floats to Floats, and do:
resW = a.toString() + " + " + b.toString();
Instead of using resW, you could try this:
public class QuickTester {
public static void main(String[] args) {
float a = 1;
float b = 2;
System.out.println(String.format("%.0f + %.0f", a, b));
System.out.println(String.format("%.2f + %.2f", a, b));
System.out.println(String.format("%.5f + %.5f", a, b));
}
}
Output:
1 + 2
1.00 + 2.00
1.00000 + 2.00000
Note:
If you insist, you could do something like String resW = String.format(...);
String#format can help you 'beautify' your resulting string, allowing you to specify the number of decimal places, alignment, etc
This is my coding so far - instructor asked me to create a program that creates triangles and specifies them.Here are the actual instructions for clarity:
*Write a program that creates sets of random triangle sides using integer values between 3 and 13. The user will specify how many triangles they would like created by entering an integer value between 1 and 10 (you may assume that they will enter an integer in this range).
For each triangle the user has requested, your program should:
Generate a set of 3 random integers between 3 and 13.
Display the 3 numbers
Decide if the numbers represent the sides of a valid triangle. (For example, 5, 5, and 13 do NOT create a triangle).
--- If the numbers do not represent a valid triangle, display an appropriate error message.
--- If the numbers are valid, the program should determine, and display, the
a) side classification of the triangle – equilateral, isosceles, or scalene, and
b) the angle classification of the triangle – right, acute, or obtuse*
// I need to figure out what to use in the while loop. I haven't written all of the coding yet, but there is an empty while loop (which im trying to use to calculate the userInput x apple and orange (yes I did use fruits as ints)
// Writing all coding here:
// Declaring maximum and minimum values for user input:
int maxValue = 13;
int minValue = 3;
userInteger = (int) (maxValue * Math.random()) + minValue;
userInteger2 = (int) (maxValue * Math.random()) + minValue;
userInteger3 = (int) (maxValue * Math.random()) + minValue;
String banana = (userInput.getText());
{
while()
outcomeLabel.setText("Your numbers are: " + userInteger + ", " + userInteger2 + " and " + userInteger3 + "." +
"\n" + "The number of triangles requested is" + banana + "so the result is");
}
int apple = (userInteger + userInteger2);
int orange = (userInteger3);
{
if (apple == orange)
outcomeLabel.setText("Your numbers are: " + userInteger + ", " + userInteger2 + " and " + userInteger3 + "." +
"\n" + "The number of triangles requested is" + banana + "\n" + "The numbers make a triangle.");
else
outcomeLabel.setText("Your numbers are: " + userInteger + ", " + userInteger2 + " and " + userInteger3 + "." +
"\n" + "The number of triangles requested is" + banana + "\n" + "The numbers do not make a triangle - try again.");
}
{
if(userInteger == userInteger2 && userInteger == userInteger3)
outcomeLabel.setText("Your numbers are: " + userInteger + ", " + userInteger2 + " and " + userInteger3 + "." +
"\n" + "The number of triangles requested is" + banana + "\n" + "The numbers make a triangle." + "\n" + "This triangle is an equilateral triangle.");
}
{
if (userInteger == userInteger2) {
}
}
}
From the look of your code, your while loop might not be in the right place... Ignoring the while loop, your code just generates a single set of three numbers and prints whether they would make a triangle, right? So where would you put the while loop to do this single action multiple times? In the middle of the provided code doesn't make too much sense...
A few other things: I don't believe your code to determine whether the generated sides can make a triangle works. What happens if userInteger = userInteger2 = 5, and userInteger3 = 4? And if you want to generate a number of triangles with the number provided by the user, you need some way to convert the inputted String into an integer. For that, checkout the Integer.parseInt() method: http://docs.oracle.com/javase/7/docs/api/java/lang/Integer.html#parseInt(java.lang.String)
Finally, you probably want to check out the Java tutorials: http://docs.oracle.com/javase/tutorial/java/index.html
I don't believe your code would work as expected when you first run it. Blocks of code inside plain braces in your class are called "initialization blocks", and are run at object creation every time your class is instantiated. What you probably want is to place everything into a method, which will allow you to run the code on command as many times as you want.
So I have this project to do, that I need to read a text file named Input, and I'm doing it like this:
public static void textParser() {
File inputFile = new File("Input.txt");
try {
BufferedReader br = new BufferedReader(new FileReader(inputFile));
String inputsText;
while ((inputsText = br.readLine()) != null) {
System.out.println(inputsText);
}
br.close();
} catch (Exception e) {
e.printStackTrace();
}
}
and it works. Inside of Input.txt, it shows:
6
10 + 4
12 - 3
1000 / 50
9 * 64
2^5
90 % 8
1 + 1
6 * 4
The first line (6) will always be the amount of equations to-do, can be different than 6.
Then I have to do how many equations the first line says to, how would I go on doing that? Thanks!
You need to write a parser. Without doing your homework for you this is the pseudo-code that should be sufficient:
for line in ReadFile()
{
for token in split(line,expression)
{
if token is digit
digits.enqueue(token)
if token is symbol
symbols.enqueue(token)
}
for element in digits,symbols:
applySymbol(firstDigit,secondDigit,symbol)
}
I've solved this problem a couple times in different languages. Look into the Shunting-yard algorithm
Basically you push and pop operators and operands onto a priority queue. You're basically converting infix to post-fix. Once your equation is in post-fix notation its much easier to solve.
If you don't have order of precedence to worry about the problem is much simpler but can still be solved by the same approach.
Edit:
We humans use in fix notation:
3 + 5 - 1
The operators are between the operands.
In Post fix notation looks like this:
3 5 + 1 -
The operators appear after the operands. Equations written this way are easy to evaluate. You just push operands onto a stack, then evaluate the last 2 using the next operator. So here, you'd push 3, and 5 onto a stack. Then you encounter + operator, so you add 3 and 5, get 8. Push 8 onto stack. now you read 1. Push 1 onto stack. Now you read -. Subtract 8 from 1. You get an answer of 7.
The shunting yard algorithm tells you how to convert between infix to post fix.
Good luck!
An option would be using ANTLR to generate a parser, this tutorial pretty much covers what you're trying to do
First you need to store them in a array of strings
Then get the first element in the array and convert it to an integer.
Based on the integer value the loop has to be iterated. so loop is formed. now you need to start reading the string array from the next index.
For doing the arithmetic operations first you need to have an array of 4 chars '+','-','*','%'
split the string based on the char array. this you can do it as a separate function. since for everytime it needs to get called. for performance i am saying.
Then you will get the two values parsed and their operator which splits them.
now you can perform the arithmetic operations.
thats it you got the required.
I have finally figured it out a different way that works, here is how I'm doing it:
public static void textParser() {
File inputFile = new File("Input.txt");
try {
Scanner scanner = new Scanner(inputFile);
int numberOfQuestions = Integer.parseInt(scanner.next());
for (int i = 1; i <= numberOfQuestions; i++) {
int firstInt = Integer.parseInt(scanner.next());
String operationSign = scanner.next();
int secondInt = Integer.parseInt(scanner.next());
if (operationSign.contains("+")) {
int answer = firstInt + secondInt;
System.out.println("Equation " + i + " : " + firstInt
+ " + " + secondInt + " = " + answer);
} else if (operationSign.contains("-")) {
int answer = firstInt - secondInt;
System.out.println("Equation " + i + " : " + firstInt
+ " - " + secondInt + " = " + answer);
} else if (operationSign.contains("/")) {
int answer = firstInt / secondInt;
System.out.println("Equation " + i + " : " + firstInt
+ " / " + secondInt + " = " + answer);
} else if (operationSign.contains("*")) {
int answer = firstInt * secondInt;
System.out.println("Equation " + i + " : " + firstInt
+ " * " + secondInt + " = " + answer);
} else if (operationSign.contains("%")) {
int answer = firstInt % secondInt;
System.out.println("Equation " + i + " : " + firstInt
+ " % " + secondInt + " = " + answer);
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
Thank you to everyone for helping!