Question

Why am I getting compile errors.

rowPuzzle.java:9: error: class, interface, or enum expected
public static boolean rowPuzzle(ArrayList<Integer> squares, int index, ArrayList<Boolean> visited)
^
rowPuzzle.java:16: error: class, interface, or enum expected
}

//Java Program
import java.util.*;

// rowPuzzle helper function implementation
// File: rowPuzzle.cpp

// Header files section

// function prototypes
public static boolean rowPuzzle(ArrayList<Integer> squares, int index, ArrayList<Boolean> visited)
{
// base case
// return true if the puzzle is solvable
if (index == squares.size() - 1)
{
   return true;
}

// mark the visited square
visited.set(index, true);

// shift to left side square
int leftShift = index - squares.get(index);
if (leftShift >= 0 && !visited.get(leftShift))
{
   // recursive case
   if (rowPuzzle(new ArrayList<Integer>(squares), leftShift, new ArrayList<Boolean>(visited)))
   {
       return true;
   }
}

// shift to right side square
int rightShift = index + squares.get(index);
if (rightShift < squares.size() && !visited.get(rightShift))
{
   // recursive case
   if (rowPuzzle(new ArrayList<Integer>(squares), rightShift, new ArrayList<Boolean>(visited)))
   {
       return true;
   }
}

// return false if the puzzle is unsolvable
return false;
}

// rowPuzzle function implementation

public static boolean rowPuzzle(ArrayList<Integer> squares)
{
ArrayList<Boolean> visited = new ArrayList<Boolean>(squares.size());

return rowPuzzle(new ArrayList<Integer>(squares), 0, new ArrayList<Boolean>(visited));
}

// start main function
public static void main(String[] args)
{
ArrayList<Integer> squares = new ArrayList<Integer>();
int value;

System.out.print("Enter a series of non-negative integers, end with 0:");
System.out.print("\n");
value = Integer.parseInt(ConsoleInput.readToWhiteSpace(true));

while (value != 0)
{
   squares.add(value);

   value = Integer.parseInt(ConsoleInput.readToWhiteSpace(true));
}

// call the rowPuzzle function and print the results
if (rowPuzzle(new ArrayList<Integer>(squares)))
{
   System.out.print("\nThe puzzle is solvable.");
   System.out.print("\n");
}
else
{
   System.out.print("\nThe puzzle is unsolvable.");
   System.out.print("\n");
}

}

//Helper class added by C++ to Java Converter:

package tangible;

//----------------------------------------------------------------------------------------
//   Copyright © 2006 - 2020 Tangible Software Solutions, Inc.
//   This class can be used by anyone provided that the copyright notice remains intact.
//
//   This class provides the ability to convert basic C++ 'cin' behavior.
//----------------------------------------------------------------------------------------
public final class ConsoleInput
{
   private static boolean goodLastRead = false;
   public static boolean lastReadWasGood()
   {
       return goodLastRead;
   }

   public static String readToWhiteSpace(boolean skipLeadingWhiteSpace)
   {
       String input = "";
       char nextChar;
       while (Character.isWhitespace(nextChar = (char)System.in.read()))
       {
           //accumulate leading white space if skipLeadingWhiteSpace is false:
           if (!skipLeadingWhiteSpace)
           {
               input += nextChar;
           }
       }
       //the first non white space character:
       input += nextChar;

       //accumulate characters until white space is reached:
       while (!Character.isWhitespace(nextChar = (char)System.in.read()))
       {
           input += nextChar;
       }

       goodLastRead = input.length() > 0;
       return input;
   }

   public static String scanfRead()
   {
       return scanfRead(null, -1);
   }

   public static String scanfRead(String unwantedSequence)
   {
       return scanfRead(unwantedSequence, -1);
   }

   public static String scanfRead(String unwantedSequence, int maxFieldLength)
   {
       String input = "";

       char nextChar;
       if (unwantedSequence != null)
       {
           nextChar = '\0';
           for (int charIndex = 0; charIndex < unwantedSequence.length(); charIndex++)
           {
               if (Character.isWhitespace(unwantedSequence.charAt(charIndex)))
               {
                   //ignore all subsequent white space:
                   while (Character.isWhitespace(nextChar = (char)System.in.read()))
                   {
                   }
               }
               else
               {
                   //ensure each character matches the expected character in the sequence:
                   nextChar = (char)System.in.read();
                   if (nextChar != unwantedSequence.charAt(charIndex))
                       return null;
               }
           }

           input = (new Character(nextChar)).toString();
           if (maxFieldLength == 1)
               return input;
       }

       while (!Character.isWhitespace(nextChar = (char)System.in.read()))
       {
           input += nextChar;
           if (maxFieldLength == input.length())
               return input;
       }

       return input;
   }
}

Answer 1

In the first code you haven't declare the code inside class so it will through error

rowPuzzle.java:9: error: class, interface, or enum expected
public static boolean rowPuzzle(ArrayList<Integer> squares, int index, ArrayList<Boolean> visited)
^
rowPuzzle.java:16: error: class, interface, or enum expected
}

So, you need make some class I took the class name as Main class and done some modification

Code:

import java.io.IOException;
import java.util.ArrayList;

public class Main {

// rowPuzzle helper function implementation
// File: rowPuzzle.cpp

// Header files section

    // function prototypes
    public static boolean rowPuzzle(ArrayList<Integer> squares, int index, ArrayList<Boolean> visited)
    {
// base case
// return true if the puzzle is solvable
        if (index == squares.size() - 1)
        {
            return true;
        }

// mark the visited square
        visited.set(index, true);

// shift to left side square
        int leftShift = index - squares.get(index);
        if (leftShift >= 0 && !visited.get(leftShift))
        {
            // recursive case
            if (rowPuzzle(new ArrayList<Integer>(squares), leftShift, new ArrayList<Boolean>(visited)))
            {
                return true;
            }
        }

// shift to right side square
        int rightShift = index + squares.get(index);
        if (rightShift < squares.size() && !visited.get(rightShift))
        {
            // recursive case
            if (rowPuzzle(new ArrayList<Integer>(squares), rightShift, new ArrayList<Boolean>(visited)))
            {
                return true;
            }
        }

// return false if the puzzle is unsolvable
        return false;
    }

// rowPuzzle function implementation

    public static boolean rowPuzzle(ArrayList<Integer> squares)
    {
        ArrayList<Boolean> visited = new ArrayList<Boolean>(squares.size());

        return rowPuzzle(new ArrayList<Integer>(squares), 0, new ArrayList<Boolean>(visited));
    }

    // start main function
    public static void main(String[] args) throws IOException {
        ArrayList<Integer> squares = new ArrayList<Integer>();
        int value;

        System.out.print("Enter a series of non-negative integers, end with 0:");
        System.out.print("\n");
        value = Integer.parseInt(ConsoleInput.readToWhiteSpace(true));

        while (value != 0)
        {
            squares.add(value);

            value = Integer.parseInt(ConsoleInput.readToWhiteSpace(true));
        }

// call the rowPuzzle function and print the results
        if (rowPuzzle(new ArrayList<Integer>(squares)))
        {
            System.out.print("\nThe puzzle is solvable.");
            System.out.print("\n");
        }
        else
        {
            System.out.print("\nThe puzzle is unsolvable.");
            System.out.print("\n");
        }

    }
}

import java.io.IOException;

public final class ConsoleInput
{
    private static boolean goodLastRead = false;
    public static boolean lastReadWasGood()
    {
        return goodLastRead;
    }

    public static String readToWhiteSpace(boolean skipLeadingWhiteSpace) throws IOException {
        String input = "";
        char nextChar;
        while (Character.isWhitespace(nextChar = (char)System.in.read()))
        {
            //accumulate leading white space if skipLeadingWhiteSpace is false:
            if (!skipLeadingWhiteSpace)
            {
                input += nextChar;
            }
        }
        //the first non white space character:
        input += nextChar;

        //accumulate characters until white space is reached:
        while (!Character.isWhitespace(nextChar = (char)System.in.read()))
        {
            input += nextChar;
        }

        goodLastRead = input.length() > 0;
        return input;
    }

    public static String scanfRead() throws IOException {
        return scanfRead(null, -1);
    }

    public static String scanfRead(String unwantedSequence) throws IOException {
        return scanfRead(unwantedSequence, -1);
    }

    public static String scanfRead(String unwantedSequence, int maxFieldLength) throws IOException {
        String input = "";

        char nextChar;
        if (unwantedSequence != null)
        {
            nextChar = '\0';
            for (int charIndex = 0; charIndex < unwantedSequence.length(); charIndex++)
            {
                if (Character.isWhitespace(unwantedSequence.charAt(charIndex)))
                {
                    //ignore all subsequent white space:
                    while (Character.isWhitespace(nextChar = (char)System.in.read()))
                    {
                    }
                }
                else
                {
                    //ensure each character matches the expected character in the sequence:
                    nextChar = (char)System.in.read();
                    if (nextChar != unwantedSequence.charAt(charIndex))
                        return null;
                }
            }

            input = (new Character(nextChar)).toString();
            if (maxFieldLength == 1)
                return input;
        }

        while (!Character.isWhitespace(nextChar = (char)System.in.read()))
        {
            input += nextChar;
            if (maxFieldLength == input.length())
                return input;
        }

        return input;
    }
}

You need to import the package in which which package you are implementing the both the class.

I have resolved the complier error.

If it is not working let me know. It is working fine in my IDE.