Answer:
public class SimpleSquare{
public int num;
private int square;
public SimpleSquare(int number){
num = number;
square = number * number;
}
public int getSquare(){
return square;
}
}
Explanation:
*The code is in Java.
Create a class called SimpleSquare
Declare two fields, num and square
Create a constructor that takes an integer number as a parameter, sets the num and sets the square as number * number.
Since the square is a private field, I also added the getSquare() method which returns the value of the square.
...something that the user knows.
The answer a identifying portfolio goal
Answer:
a) AL will contains 0011 1100
Explanation:
In assembly language, shifting bits in registers is a common and important practice. One of the shifting operations is the SHR AL, x where the x specifies that the bits be shifted to the right by x places.
SHR AL, 2 therefore means that the bits contained in the AL should be shifted to the right by two (2) places.
For example, if the AL contains binary 1000 1111, the SHR AL, 2 operation will cause the following to happen
Original bit => | 1 | 0 | 0 | 0 | 1 | 1 | 1 | 1 |
Shift once to the right => | 1 | 0 | 0 | 0 | 1 | 1 | 1 | 1 | (0) |
Shift once to the right => | 1 | 0 | 0 | 0 | 1 | 1 | 1 | 1 | (0) | (0) |
Notice;
(i) that there are two shifts - one at a time.
(ii) that the bits in bold face are the bits in the AL after the shift. Those that in regular face are those in the carry flag.
(iii) that the new bits added to the AL after a shift are the ones in bracket. They are always set to 0.
Answer:
The function in C++ is as follows:
int isSorted(int ar[], int n){
if (
||
){
return 1;}
if (
<
){
return 0;}
return isSorted(ar, n - 1);}
Explanation:
This defines the function
int isSorted(int ar[], int n){
This represents the base case; n = 1 or 0 will return 1 (i.e. the array is sorted)
if (
||
){
return 1;}
This checks if the current element is less than the previous array element; If yes, the array is not sorted
if (
<
){
return 0;}
This calls the function, recursively
return isSorted(ar, n - 1);
}