BHSawesome2 AP CSA Java 2025+

!((a <= b) && (b < 0))

public int mystery(int m)
{
  if (m == 1)
  {
      return 3;
  } else
  {
      return 3 * mystery(m - 1);
  }
}

I.   An array that is in reverse order (from largest to smallest).
II.  An array that is in sorted order already (from smallest to largest).
III. An array that is in random order (not already sorted).

int max = 5;

//Loop I
for (int i = 0; i < max; i++)
{
   System.out.print(i);
}


//Loop II
int j = 0;
while (j < max)
{
   System.out.print(j);
   j++;
}


//Loop III
int k = 0;
for (int i = max; i > 0; i--)
{
   System.out.print(i);
}

int value = 15;
while (value < 30)
{
    value++;
    System.out.println(value);
}

public int solution(int limit)
{
  int s = 0;

  for (int outside = 1; outside <= limit; outside++)
  {
      for (int middle = 1; middle <= limit; middle++)
      {
          for (int inside = 1; inside <= limit; inside++)
          {
              s++;
          }
      }
  }
  return s;
}

// Code block I
for (count = 0; count <= n; count++)
{
    System.out.println(count);
}

//Code block II
count = 0;
while (count <= n)
{
    count = count + 1;
    System.out.println(count);
}

 public class Animal
 {
  /* Some code */
 }

 public class Cat extends Animal
 {
    /* Some code */
 }

I. Cat inherits the constructors of Animal
II. Cat cannot add new methods and private instance variables that Animal does not have.
III. Cat can override existing public methods of Animal

for (int i = 0; i <= k; i++)
{
   if (arr[i] < someValue)
   {
     System.out.print("HELLO")
   }
}

public void stringRecursion(String s)
{

  if (s.length() < 16)
  {
    System.out.println(s);
  }
  stringRecursion(s + "*");
}

public class A
{
  public void method1() { };
}

public class B extends A
{
    // Instance variables and other methods not shown

    public void method1()
    {
      /* implementation not shown */
    }
}

public class C extends B
{
  //Instance variables and other methods not shown

  public void method2(C o)
  {
     /* implementation not shown */
  }

  public static void main(String[] args)
  {
    C objectC = new C();
    B objectB = new B();
    // Missing code
  }
}

I objectC.method1();
II objectB.method2(objectC);
III objectC.method2(objectB);

I ArrayList<String> stringList = new List<String>();
II ArrayList<int> intList = new ArrayList<int>();
III ArrayList<String> stringList = new ArrayList<String>();

/* assume that matrix has the following values */
7654
3210
4567
0123

public static void printMatrix(int[][] matrix)
{
  for (int i = 0; i < matrix.length; i++)
  {

    for (int t = 0; t < i; t++)
    {
      System.out.print(matrix[i][t]);
    }
    System.out.println();
  }
}

Possible output:

I.
7654
3210
4567
0123

II.
7
32
456
0123

III.
3
45
012

IV.
7
3
4
0

randomList.add(5);
randomList.add(7);
int randomNum = randomList.get(2);
randomList.remove(2);
randomList.add(randomNum, 4);
randomList.set(1, 8);

String str = "fedcba";
int counter = 0;
while(counter < str.length() - 1)
{
  System.out.print(str.substring(counter + 1, counter + 2));
  counter++;
}

public class B
{

    public int myValue;

    public B()
    {
        myValue = 0;
    }

    public B(int x)
    {
        myValue = x;
    }
}

public class C extends B
{

    public C()
    {
        super(0);
    }
}

public static void test(String str, int y)
{
   str = str + "bow";
   y = y * 2;
}

I. Insertion sort requires more storage space than mergesort.
II. Insertion sort is only more efficient than mergesort in the case that we have a very small and nearly sorted array.
III. Insertion sort is almost always less efficient than mergesort.

  private int[][] matrix;

  /* matrix looks like this initially
  1 3 5 7
  2 4 6 8
  3 5 7 9
  */

  public void alter(int c)
  {
    for (int i = 0; i < matrix.length; i++)
    {
      for (int j = c + 1; j < matrix[0].length; j++)
      {
        matrix[i][j - 1] = matrix[i][j];
      }
    }
  }


I. 1 7 7 7
   2 8 8 8
   3 9 9 9

II. 1 5 7
    2 6 8
    3 7 9

III. 1 3 5 7
     3 5 7 9

IV. 1 3 5 7
    3 5 7 9
    3 5 7 9

V. 1 5 7 7
   2 6 8 8
   3 7 9 9