Primitive Data Types - Computer Science

The parenthesis indicate which operations need to be completed first. J or'd with k gives an answer of 6. Remember that these boolean operations are done by using the binary representtion of the numbers. 6 in binary is 110 and 0 in binary is 000. 6 anded with 2 is 2.

When evaluated with x == true, y == false, z == false_,_ the equation comes out to be

All other combinations of values produce false.

The function "bigger" defined before main returns a value of type bool and takes in two integer inputs. It compares the first value to the second. If it it greater, it returns true. Otherwise, it returns false. In main, a new variable test is called, and it is of type bool as well. This automatically eliminates 3 out of the 5 possibilities.

"test" is defined as the opposite of the outcome of the bigger function with the two inputs are 10 and 7. 10 is bigger than 7, so the function returns true. Since test is the opposite of that, it is false.

In a regular number system, also known as decimal, the position furtherest to the right is , then one over to the left would be , then . These are the ones, tens and hundreds place. Binary is a base 2 number system. Therefore, the digit to the furthest right is , then to the left , then , and so on.

Explanation

1000011 The bolded number has a value of 1

1000011 The bolded number has a value of 2

1000011 The bolded number has a value of 64

The positions that are marked true (as 1) in the binary number 1000011 corresponds to the numbers 64, 2, and 1 which added up equals 67

Step By Step

• To convert the number 67 to binary, first find the digit place number that has the largest number possible that is less than or equal to 67. In this case it would be the position holding .
• The number for 64 is 1000000
• To get 67, we need to add 3
• Again, find the digit place number that has the largest number possible less than or equal to 3. In this case, it would be
• The number for 66 (64 + 2) is 1000010
• To get from 66 to 67, repeat the steps from before.
• The number for 67 (66 + 1) is 1000011

In Swift, every variable must be declared with var before the name of the variable. This automatically knocks out two of the answers. After we eliminate those two, we see var variable and var variable: Bool. var variable would be a correct answer if the prompt had not asked for an unwrapped boolean. var variable: Bool performs the unwrapping by declaring the variable to be a boolean specifically.

In Swift, all methods must first say what they are. They are functions, so they are prefixed with func. Next, methods must have a name. In this case, we named it method. All methods need to specify parameters, even if there are no parameters. So, method() i.e. no parameters. Finally, we wanted to return a boolean. So we set the return type using -> Bool.

The easiest way to work through this code is to comment on its parts. See the comments below in bold.

double a = 4.5, d = 4;

int b = 10,c=5;

/*

a / b: This is a division that will maintain the decimal portion (since it has a double involved in it). 4.5 / 10 will evaluate to 0.45.

c / d: Since this has both an int and a double, it will evaluate to a double. That means that it will maintain its decimal portion as well. It is: 5 / 4 or 1.25.

d % c: Since d is 4, this kind of remainder division works just like having two integers for the modulus. 4 % 5 is just 4. (It is 0 remainder 4.)

Thus, the expression is: 0.45 + 1.25 - 4, which is -2.3.

*/

double e = a / b + c / d - d % c;

When the code is executed it will produce a type error with the variable string in line 9. The variable string is trying to concatenate a string and an integer from the z array. To make the code executable, we would need to make the integer from the z array a string. We would do this by simply wrapping it in the method str(), which converts it into a string. After making the change, the following code will execute correctly.

1: x=\[\]

2: y=\[\]

3: z=\[\]

4: for i in range(10):

5: x.append(i)

6: y.append(x\[i\]+2*x\[i\])

7: z.append(x\[i\]+y\[i\]**2)

8: print(z)

9: string="The fourth element of z is"+str(z\[3\])

10: print(string)

A float is represented by 4 bytes (32 bits). It's comprised of 1 sign bit, 8 exponent bits, and 23 mantissa bits. An example of a floating point number in binary would be 11111111111111111111111111111111. The breakdown would be [1](sign bit) [11111111](exponent bits) [11111111111111111111111](mantissa bits). All in all, that equals 32 bits.

In Java, the byte is the only 8 bit data type. The short and char are 16 bits in size. There are no 48 bit data types, as everything is in a power of 2. The double and long are 64 bits in size.

Because floats have half the number of bits as doubles, it isn't as precise, so shouldn't be used when lots of precision is needed. It's better suited for when there are memory size concerns.

Breanna should use int because she would be counting whole numbers.

Nathan however, should use double because he will be adding up how many grapes he eats and divide by the number of days in the week.

In Swift, all methods must first say what they are. They are functions, so they are prefixed with func. Next, methods must have a name. In this case, we named it method. All methods need to specify parameters, even if there are no parameters. So, method() i.e. no parameters. Finally, we wanted to return a Double. So we set the return type using -> Double.

The ternary operator works as follows:

(condition to be checked) ? (value to return if true) : (value to return if false)

The answer is purposely logically incorrect to force you to consider the structure of the code. While 2016 is obviously a leap year where February should have 29 days, the ternary operator used is set to return 28 days if true and 29 if false. So in this case, febDays will be 28.

Begin by getting a general idea of the loop logic being executed. For each execution of the first loop, you are assigning a boolean to the vals array. Now, you could rewrite the code a little to make the math easier:

a\[i\] - 1 > 4

really is the same as:

a\[i\] > 5

Now, the only values for which this is true are:

8 and 6 (the first and the 7th values in a).

Now, looking at the second loop, the value s will be "Duns Scotus" for every value that is true in vals. This is because the if statement checks for !vals\[i\]. Thus, the first and the seventh values alone will be "Duns Scotus". Everything else will be "Mithrandir".

Consider each condition:

The first if statement has: a > 12 && b < -14 && c < d

While it is true that 14 > 12 and -15 < -14, it is not true that 11 < 22. Therefore, the conjunction of all of these cannot be true. For &&, all of the expressions must be true.

Next, consider: d - 20 < b

This is really: 11 - 20 < -15 or -9 < -15. This is not true either.

Next, consider: a + 12 >= c

This is really: 12 + 12 >= 22 or 24 >= 22. This is true. Therefore, your output is "This is vexing......"!

The easiest way to begin is by looking at the general form of the first if statement. Notice that it is made up of three expressions that have a boolean AND between them. This means that if any of those members is false, the whole thing will be false. Well, consider the very first term:

s2.charAt(4) == ' '

This is asking about the fifth character in the string s2. (Remember, the index starts at 0.) Well, this is true for s but not for s2, which has 'e' for its fifth member. Thus, we know that the first if must be false.

Now, to the second:

s2.charAt(5) == 's'

This also is not true, for the sixth character in s2 is ' '.

The third if is also false. j + 12 is equal to 0!

However, it is indeed the case that (45 - 20 < 100) is true. Therefore, the fourth if statement will execute, giving you the output:

Where will the group be having lunch tomorrow?

First of all, note that your loop will run for values from 0 to 9, inclusive.

Now, the first condition is relatively easy:

i % 2 == 0

This is true when the number i is even. When it is divisible by 2, the remainder will be 0. (Recall that the modulus gives you the remainder.)

Now, the next two else conditions will execute only for odd numbers. The first one can be rewritten:

i > 6 && i % 3 == 1

This means that we need all of the numbers from 7 to 9 that have a remainder of 1 when divided by 3. This only applies to i = 7. This will be the eighth line output. Therefore, you know that you will have alternating lines saying, "This is my favorite case!" All of the other ones will be "Well, at least it is something...", except for the eighth line, which will be "There once was a pool in the back yard!"

Let us consider each conditional in turn. When we reach one that is true, we know our output.

First Conditional: i < 15 && j >= -4

Recall that you must have both of these true in order for the whole expression to be true. Well, while it is the case that , it is not true that . Thus, this conditional is false.

Second Conditional: !(i < 100 && k > 4)

For this, you must first attempt the expression in parentheses. Both of these are true. However, !(true) is false. (It makes sense in English: "That is not true!" This means, "That is false!")

Third Conditional: !(i == 3 && k == 4)

Well, here, we know that both 12 == 3 and 103 == 4 are both false. Therefore, the expression is !(false). Therefore, it is true! This is your output.

Let's consider the cases in order until we find our matching true expression.

Conditional 1: i > 34 || c < 'B'

All we need is for one of these to be true for the whole expression to be true (given the nature of the logical OR represented by ||. However, neither of these are true.

Conditional 2: s.charAt(9) == c

If you carefully count the letters in the String s, you will see that index 9 (i.e. the tenth character) is M. Therefore, this is equal to c. Thus, you know that your program will output I read William of Ockham yesterday!

The "!" symbol means not. Therefore, 7 does not equal 14 is true.