commit 86f9da1a4e94364d96e5bc2bee4230ccc87049b4 Author: Arti Zirk Date: Fri Sep 25 08:44:56 2015 +0300 something diff --git a/.classpath b/.classpath new file mode 100644 index 0000000..fceb480 --- /dev/null +++ b/.classpath @@ -0,0 +1,6 @@ + + + + + + diff --git a/.project b/.project new file mode 100644 index 0000000..7228162 --- /dev/null +++ b/.project @@ -0,0 +1,17 @@ + + + Praktikumid + + + + + + org.eclipse.jdt.core.javabuilder + + + + + + org.eclipse.jdt.core.javanature + + diff --git a/.settings/org.eclipse.jdt.core.prefs b/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 0000000..3a21537 --- /dev/null +++ b/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,11 @@ +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled +org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8 +org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve +org.eclipse.jdt.core.compiler.compliance=1.8 +org.eclipse.jdt.core.compiler.debug.lineNumber=generate +org.eclipse.jdt.core.compiler.debug.localVariable=generate +org.eclipse.jdt.core.compiler.debug.sourceFile=generate +org.eclipse.jdt.core.compiler.problem.assertIdentifier=error +org.eclipse.jdt.core.compiler.problem.enumIdentifier=error +org.eclipse.jdt.core.compiler.source=1.8 diff --git a/bin/lib/TextIO.class b/bin/lib/TextIO.class new file mode 100644 index 0000000..b051ac0 Binary files /dev/null and b/bin/lib/TextIO.class differ diff --git a/bin/praktikum2/Grupeerija.class b/bin/praktikum2/Grupeerija.class new file mode 100644 index 0000000..01b52ea Binary files /dev/null and b/bin/praktikum2/Grupeerija.class differ diff --git a/bin/praktikum2/Korrutaja.class b/bin/praktikum2/Korrutaja.class new file mode 100644 index 0000000..5e042ae Binary files /dev/null and b/bin/praktikum2/Korrutaja.class differ diff --git a/bin/praktikum2/NimePikkus.class b/bin/praktikum2/NimePikkus.class new file mode 100644 index 0000000..4191786 Binary files /dev/null and b/bin/praktikum2/NimePikkus.class differ diff --git a/bin/praktikum2/Tere.class b/bin/praktikum2/Tere.class new file mode 100644 index 0000000..8039680 Binary files /dev/null and b/bin/praktikum2/Tere.class differ diff --git a/bin/praktikum3/CumLaude.class b/bin/praktikum3/CumLaude.class new file mode 100644 index 0000000..98b3612 Binary files /dev/null and b/bin/praktikum3/CumLaude.class differ diff --git a/bin/praktikum3/ParooliSisestus.class b/bin/praktikum3/ParooliSisestus.class new file mode 100644 index 0000000..c45c7a9 Binary files /dev/null and b/bin/praktikum3/ParooliSisestus.class differ diff --git a/bin/praktikum3/Tehisintellekt.class b/bin/praktikum3/Tehisintellekt.class new file mode 100644 index 0000000..34b0a0d Binary files /dev/null and b/bin/praktikum3/Tehisintellekt.class differ diff --git a/bin/praktikum4/numbrid0246.class b/bin/praktikum4/numbrid0246.class new file mode 100644 index 0000000..c4c186a Binary files /dev/null and b/bin/praktikum4/numbrid0246.class differ diff --git a/bin/praktikum4/numbrid110.class b/bin/praktikum4/numbrid110.class new file mode 100644 index 0000000..3cf5f1a Binary files /dev/null and b/bin/praktikum4/numbrid110.class differ diff --git a/bin/praktikum4/numbrid302734.class b/bin/praktikum4/numbrid302734.class new file mode 100644 index 0000000..b49e746 Binary files /dev/null and b/bin/praktikum4/numbrid302734.class differ diff --git a/bin/praktikum4/table1.class b/bin/praktikum4/table1.class new file mode 100644 index 0000000..03c8262 Binary files /dev/null and b/bin/praktikum4/table1.class differ diff --git a/bin/praktikum4/table2.class b/bin/praktikum4/table2.class new file mode 100644 index 0000000..923e244 Binary files /dev/null and b/bin/praktikum4/table2.class differ diff --git a/src/lib/TextIO.java b/src/lib/TextIO.java new file mode 100644 index 0000000..81177fb --- /dev/null +++ b/src/lib/TextIO.java @@ -0,0 +1,1008 @@ +package lib; + +import java.io.*; +import java.util.IllegalFormatException; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import javax.swing.JFileChooser; +import javax.swing.JOptionPane; + +/** + * TextIO provides a set of static methods for reading and writing text. By default, it reads + * from standard input and writes to standard output, but it is possible to redirect the input + * and output to files or to other input and output streams. When the standard input and output + * streams are being used, the input methods will not produce an error; instead, the user is + * repeatedly prompted for input until a legal input is entered. (If standard input has been + * changed externally, as by file redirection on the command line, this is not a reasonable + * behavior; to handle this case, TextIO will give up after 10 consecutive illegal inputs and + * will throw an IllegalArgumentException.) For the most part, any other + * error will be translated into an IllegalArguementException. + *

For writing to standard output, the output methods in this class pretty much + * duplicate the functionality of System.out, and System.out can be used interchangeably with them. + *

This class does not use optimal Java programming practices. It is designed specifically to be easily + * usable even by a beginning programmer who has not yet learned about objects and exceptions. Therefore, + * everything is in a single source file that compiles into a single class file, all the methods are + * static methods, and none of the methods throw exceptions that would require try...catch statements. + * Also for this reason, all exceptions are converted into IllegalArgumentExceptions, even when this + * exception type doesn't really make sense. + *

This class requires Java 5.0 or higher. (A previous version of TextIO required only Java 1.1; + * this version should work with any source code that used the previous version, but it has some new + * features, including the type of formatted output that was introduced in Java 5 and the ability to + * use files and streams.) + */ +public class TextIO { + + /* Modified November 2007 to empty the TextIO input buffer when switching from one + * input source to another. This fixes a bug that allows input from the previous input + * source to be read after the new source has been selected. + */ + + /** + * The value returned by the peek() method when the input is at end-of-file. + * (The value of this constant is (char)0xFFFF.) + */ + public final static char EOF = (char)0xFFFF; + + /** + * The value returned by the peek() method when the input is at end-of-line. + * The value of this constant is the character '\n'. + */ + public final static char EOLN = '\n'; // The value returned by peek() when at end-of-line. + + + /** + * After this method is called, input will be read from standard input (as it + * is in the default state). If a file or stream was previously the input source, that file + * or stream is closed. + */ + public static void readStandardInput() { + if (readingStandardInput) + return; + try { + in.close(); + } + catch (Exception e) { + } + emptyBuffer(); // Added November 2007 + in = standardInput; + inputFileName = null; + readingStandardInput = true; + inputErrorCount = 0; + } + + /** + * After this method is called, input will be read from inputStream, provided it + * is non-null. If inputStream is null, then this method has the same effect + * as calling readStandardInput(); that is, future input will come from the + * standard input stream. + */ + public static void readStream(InputStream inputStream) { + if (inputStream == null) + readStandardInput(); + else + readStream(new InputStreamReader(inputStream)); + } + + /** + * After this method is called, input will be read from inputStream, provided it + * is non-null. If inputStream is null, then this method has the same effect + * as calling readStandardInput(); that is, future input will come from the + * standard input stream. + */ + public static void readStream(Reader inputStream) { + if (inputStream == null) + readStandardInput(); + else { + if ( inputStream instanceof BufferedReader) + in = (BufferedReader)inputStream; + else + in = new BufferedReader(inputStream); + emptyBuffer(); // Added November 2007 + inputFileName = null; + readingStandardInput = false; + inputErrorCount = 0; + } + } + + /** + * Opens a file with a specified name for input. If the file name is null, this has + * the same effect as calling readStandardInput(); that is, input will be read from standard + * input. If an + * error occurs while trying to open the file, an exception of type IllegalArgumentException + * is thrown, and the input source is not changed. If the file is opened + * successfully, then after this method is called, all of the input routines will read + * from the file, instead of from standard input. + */ + public static void readFile(String fileName) { + if (fileName == null) // Go back to reading standard input + readStandardInput(); + else { + BufferedReader newin; + try { + newin = new BufferedReader( new FileReader(fileName) ); + } + catch (Exception e) { + throw new IllegalArgumentException("Can't open file \"" + fileName + "\" for input.\n" + + "(Error :" + e + ")"); + } + if (! readingStandardInput) { // close current input stream + try { + in.close(); + } + catch (Exception e) { + } + } + emptyBuffer(); // Added November 2007 + in = newin; + readingStandardInput = false; + inputErrorCount = 0; + inputFileName = fileName; + } + } + + /** + * Puts a GUI file-selection dialog box on the screen in which the user can select + * an input file. If the user cancels the dialog instead of selecting a file, it is + * not considered an error, but the return value of the subroutine is false. + * If the user does select a file, but there is an error while trying to open the + * file, then an exception of type IllegalArgumentException is thrown. Finally, if + * the user selects a file and it is successfully opened, then the return value of the + * subroutine is true, and the input routines will read from the file, instead of + * from standard input. If the user cancels, or if any error occurs, then the + * previous input source is not changed. + *

NOTE: Calling this method starts a GUI user interface thread, which can continue + * to run even if the thread that runs the main program ends. If you use this method + * in a non-GUI program, it might be necessary to call System.exit(0) at the end of the main() + * routine to shut down the Java virtual machine completely. + */ + public static boolean readUserSelectedFile() { + if (fileDialog == null) + fileDialog = new JFileChooser(); + fileDialog.setDialogTitle("Select File for Input"); + int option = fileDialog.showOpenDialog(null); + if (option != JFileChooser.APPROVE_OPTION) + return false; + File selectedFile = fileDialog.getSelectedFile(); + BufferedReader newin; + try { + newin = new BufferedReader( new FileReader(selectedFile) ); + } + catch (Exception e) { + throw new IllegalArgumentException("Can't open file \"" + selectedFile.getName() + "\" for input.\n" + + "(Error :" + e + ")"); + } + if (!readingStandardInput) { // close current file + try { + in.close(); + } + catch (Exception e) { + } + } + emptyBuffer(); // Added November 2007 + in = newin; + inputFileName = selectedFile.getName(); + readingStandardInput = false; + inputErrorCount = 0; + return true; + } + + /** + * After this method is called, output will be written to standard output (as it + * is in the default state). If a file or stream was previously open for output, it + * will be closed. + */ + public static void writeStandardOutput() { + if (writingStandardOutput) + return; + try { + out.close(); + } + catch (Exception e) { + } + outputFileName = null; + outputErrorCount = 0; + out = standardOutput; + writingStandardOutput = true; + } + + + /** + * After this method is called, output will be sent to outputStream, provided it + * is non-null. If outputStream is null, then this method has the same effect + * as calling writeStandardOutput(); that is, future output will be sent to the + * standard output stream. + */ + public static void writeStream(OutputStream outputStream) { + if (outputStream == null) + writeStandardOutput(); + else + writeStream(new PrintWriter(outputStream)); + } + + /** + * After this method is called, output will be sent to outputStream, provided it + * is non-null. If outputStream is null, then this method has the same effect + * as calling writeStandardOutput(); that is, future output will be sent to the + * standard output stream. + */ + public static void writeStream(PrintWriter outputStream) { + if (outputStream == null) + writeStandardOutput(); + else { + out = outputStream; + outputFileName = null; + outputErrorCount = 0; + writingStandardOutput = false; + } + } + + + /** + * Opens a file with a specified name for output. If the file name is null, this has + * the same effect as calling writeStandardOutput(); that is, output will be sent to standard + * output. If an + * error occurs while trying to open the file, an exception of type IllegalArgumentException + * is thrown. If the file is opened successfully, then after this method is called, + * all of the output routines will write to the file, instead of to standard output. + * If an error occurs, the output destination is not changed. + *

NOTE: Calling this method starts a GUI user interface thread, which can continue + * to run even if the thread that runs the main program ends. If you use this method + * in a non-GUI program, it might be necessary to call System.exit(0) at the end of the main() + * routine to shut down the Java virtual machine completely. + */ + public static void writeFile(String fileName) { + if (fileName == null) // Go back to reading standard output + writeStandardOutput(); + else { + PrintWriter newout; + try { + newout = new PrintWriter(new FileWriter(fileName)); + } + catch (Exception e) { + throw new IllegalArgumentException("Can't open file \"" + fileName + "\" for output.\n" + + "(Error :" + e + ")"); + } + if (!writingStandardOutput) { + try { + out.close(); + } + catch (Exception e) { + } + } + out = newout; + writingStandardOutput = false; + outputFileName = fileName; + outputErrorCount = 0; + } + } + + /** + * Puts a GUI file-selection dialog box on the screen in which the user can select + * an output file. If the user cancels the dialog instead of selecting a file, it is + * not considered an error, but the return value of the subroutine is false. + * If the user does select a file, but there is an error while trying to open the + * file, then an exception of type IllegalArgumentException is thrown. Finally, if + * the user selects a file and it is successfully opened, then the return value of the + * subroutine is true, and the output routines will write to the file, instead of + * to standard output. If the user cancels, or if an error occurs, then the current + * output destination is not changed. + */ + public static boolean writeUserSelectedFile() { + if (fileDialog == null) + fileDialog = new JFileChooser(); + fileDialog.setDialogTitle("Select File for Output"); + File selectedFile; + while (true) { + int option = fileDialog.showSaveDialog(null); + if (option != JFileChooser.APPROVE_OPTION) + return false; // user canceled + selectedFile = fileDialog.getSelectedFile(); + if (selectedFile.exists()) { + int response = JOptionPane.showConfirmDialog(null, + "The file \"" + selectedFile.getName() + "\" already exists. Do you want to replace it?", + "Replace existing file?", + JOptionPane.YES_NO_OPTION, JOptionPane.WARNING_MESSAGE); + if (response == JOptionPane.YES_OPTION) + break; + } + else { + break; + } + } + PrintWriter newout; + try { + newout = new PrintWriter(new FileWriter(selectedFile)); + } + catch (Exception e) { + throw new IllegalArgumentException("Can't open file \"" + selectedFile.getName() + "\" for output.\n" + + "(Error :" + e + ")"); + } + if (!writingStandardOutput) { + try { + out.close(); + } + catch (Exception e) { + } + } + out = newout; + writingStandardOutput = false; + outputFileName = selectedFile.getName(); + outputErrorCount = 0; + return true; + } + + + /** + * If TextIO is currently reading from a file, then the return value is the name of the file. + * If the class is reading from standard input or from a stream, then the return value is null. + */ + public static String getInputFileName() { + return inputFileName; + } + + + /** + * If TextIO is currently writing to a file, then the return value is the name of the file. + * If the class is writing to standard output or to a stream, then the return value is null. + */ + public static String getOutputFileName() { + return outputFileName; + } + + + // *************************** Output Methods ********************************* + + /** + * Write a single value to the current output destination, using the default format + * and no extra spaces. This method will handle any type of parameter, even one + * whose type is one of the primitive types. + */ + public static void put(Object x) { + out.print(x); + out.flush(); + if (out.checkError()) + outputError("Error while writing output."); + } + + /** + * Write a single value to the current output destination, using the default format + * and outputting at least minChars characters (with extra spaces added before the + * output value if necessary). This method will handle any type of parameter, even one + * whose type is one of the primitive types. + * @param x The value to be output, which can be of any type. + * @param minChars The minimum number of characters to use for the output. If x requires fewer + * then this number of characters, then extra spaces are added to the front of x to bring + * the total up to minChars. If minChars is less than or equal to zero, then x will be printed + * in the minimum number of spaces possible. + */ + public static void put(Object x, int minChars) { + if (minChars <= 0) + out.print(x); + else + out.printf("%" + minChars + "s", x); + out.flush(); + if (out.checkError()) + outputError("Error while writing output."); + } + + /** + * This is equivalent to put(x), followed by an end-of-line. + */ + public static void putln(Object x) { + out.println(x); + out.flush(); + if (out.checkError()) + outputError("Error while writing output."); + } + + /** + * This is equivalent to put(x,minChars), followed by an end-of-line. + */ + public static void putln(Object x, int minChars) { + put(x,minChars); + out.println(); + out.flush(); + if (out.checkError()) + outputError("Error while writing output."); + } + + /** + * Write an end-of-line character to the current output destination. + */ + public static void putln() { + out.println(); + out.flush(); + if (out.checkError()) + outputError("Error while writing output."); + } + + /** + * Writes formatted output values to the current output destination. This method has the + * same function as System.out.printf(); the details of formatted output are not discussed + * here. The first parameter is a string that describes the format of the output. There + * can be any number of additional parameters; these specify the values to be output and + * can be of any type. This method will throw an IllegalArgumentException if the + * format string is null or if the format string is illegal for the values that are being + * output. + */ + public static void putf(String format, Object... items) { + if (format == null) + throw new IllegalArgumentException("Null format string in TextIO.putf() method."); + try { + out.printf(format,items); + } + catch (IllegalFormatException e) { + throw new IllegalArgumentException("Illegal format string in TextIO.putf() method."); + } + out.flush(); + if (out.checkError()) + outputError("Error while writing output."); + } + + // *************************** Input Methods ********************************* + + /** + * Test whether the next character in the current input source is an end-of-line. Note that + * this method does NOT skip whitespace before testing for end-of-line -- if you want to do + * that, call skipBlanks() first. + */ + public static boolean eoln() { + return peek() == '\n'; + } + + /** + * Test whether the next character in the current input source is an end-of-file. Note that + * this method does NOT skip whitespace before testing for end-of-line -- if you want to do + * that, call skipBlanks() or skipWhitespace() first. + */ + public static boolean eof() { + return peek() == EOF; + } + + /** + * Reads the next character from the current input source. The character can be a whitespace + * character; compare this to the getChar() method, which skips over whitespace and returns the + * next non-whitespace character. An end-of-line is always returned as the character '\n', even + * when the actual end-of-line in the input source is something else, such as '\r' or "\r\n". + * This method will throw an IllegalArgumentException if the input is at end-of-file (which will + * not ordinarily happen if reading from standard input). + */ + public static char getAnyChar() { + return readChar(); + } + + /** + * Returns the next character in the current input source, without actually removing that + * character from the input. The character can be a whitespace character and can be the + * end-of-file character (specified by the constant TextIO.EOF).An end-of-line is always returned + * as the character '\n', even when the actual end-of-line in the input source is something else, + * such as '\r' or "\r\n". This method never causes an error. + */ + public static char peek() { + return lookChar(); + } + + /** + * Skips over any whitespace characters, except for end-of-lines. After this method is called, + * the next input character is either an end-of-line, an end-of-file, or a non-whitespace character. + * This method never causes an error. (Ordinarily, end-of-file is not possible when reading from + * standard input.) + */ + public static void skipBlanks() { + char ch=lookChar(); + while (ch != EOF && ch != '\n' && Character.isWhitespace(ch)) { + readChar(); + ch = lookChar(); + } + } + + /** + * Skips over any whitespace characters, including for end-of-lines. After this method is called, + * the next input character is either an end-of-file or a non-whitespace character. + * This method never causes an error. (Ordinarily, end-of-file is not possible when reading from + * standard input.) + */ + private static void skipWhitespace() { + char ch=lookChar(); + while (ch != EOF && Character.isWhitespace(ch)) { + readChar(); + if (ch == '\n' && readingStandardInput && writingStandardOutput) { + out.print("? "); + out.flush(); + } + ch = lookChar(); + } + } + + /** + * Skips whitespace characters and then reads a value of type byte from input, discarding the rest of + * the current line of input (including the next end-of-line character, if any). When using standard IO, + * this will not produce an error; the user will be prompted repeatedly for input until a legal value + * is input. In other cases, an IllegalArgumentException will be thrown if a legal value is not found. + */ + public static byte getlnByte() { + byte x=getByte(); + emptyBuffer(); + return x; + } + + /** + * Skips whitespace characters and then reads a value of type short from input, discarding the rest of + * the current line of input (including the next end-of-line character, if any). When using standard IO, + * this will not produce an error; the user will be prompted repeatedly for input until a legal value + * is input. In other cases, an IllegalArgumentException will be thrown if a legal value is not found. + */ + public static short getlnShort() { + short x=getShort(); + emptyBuffer(); + return x; + } + + /** + * Skips whitespace characters and then reads a value of type int from input, discarding the rest of + * the current line of input (including the next end-of-line character, if any). When using standard IO, + * this will not produce an error; the user will be prompted repeatedly for input until a legal value + * is input. In other cases, an IllegalArgumentException will be thrown if a legal value is not found. + */ + public static int getlnInt() { + int x=getInt(); + emptyBuffer(); + return x; + } + + /** + * Skips whitespace characters and then reads a value of type long from input, discarding the rest of + * the current line of input (including the next end-of-line character, if any). When using standard IO, + * this will not produce an error; the user will be prompted repeatedly for input until a legal value + * is input. In other cases, an IllegalArgumentException will be thrown if a legal value is not found. + */ + public static long getlnLong() { + long x=getLong(); + emptyBuffer(); + return x; + } + + /** + * Skips whitespace characters and then reads a value of type float from input, discarding the rest of + * the current line of input (including the next end-of-line character, if any). When using standard IO, + * this will not produce an error; the user will be prompted repeatedly for input until a legal value + * is input. In other cases, an IllegalArgumentException will be thrown if a legal value is not found. + */ + public static float getlnFloat() { + float x=getFloat(); + emptyBuffer(); + return x; + } + + /** + * Skips whitespace characters and then reads a value of type double from input, discarding the rest of + * the current line of input (including the next end-of-line character, if any). When using standard IO, + * this will not produce an error; the user will be prompted repeatedly for input until a legal value + * is input. In other cases, an IllegalArgumentException will be thrown if a legal value is not found. + */ + public static double getlnDouble() { + double x=getDouble(); + emptyBuffer(); + return x; + } + + /** + * Skips whitespace characters and then reads a value of type char from input, discarding the rest of + * the current line of input (including the next end-of-line character, if any). Note that the value + * that is returned will be a non-whitespace character; compare this with the getAnyChar() method. + * When using standard IO, this will not produce an error. In other cases, an error can occur if + * an end-of-file is encountered. + */ + public static char getlnChar() { + char x=getChar(); + emptyBuffer(); + return x; + } + + /** + * Skips whitespace characters and then reads a value of type boolean from input, discarding the rest of + * the current line of input (including the next end-of-line character, if any). When using standard IO, + * this will not produce an error; the user will be prompted repeatedly for input until a legal value + * is input. In other cases, an IllegalArgumentException will be thrown if a legal value is not found. + *

Legal inputs for a boolean input are: true, t, yes, y, 1, false, f, no, n, and 0; letters can be + * either upper case or lower case. One "word" of input is read, using the getWord() method, and it + * must be one of these; note that the "word" must be terminated by a whitespace character (or end-of-file). + */ + public static boolean getlnBoolean() { + boolean x=getBoolean(); + emptyBuffer(); + return x; + } + + /** + * Skips whitespace characters and then reads one "word" from input, discarding the rest of + * the current line of input (including the next end-of-line character, if any). A word is defined as + * a sequence of non-whitespace characters (not just letters!). When using standard IO, + * this will not produce an error. In other cases, an IllegalArgumentException will be thrown + * if an end-of-file is encountered. + */ + public static String getlnWord() { + String x=getWord(); + emptyBuffer(); + return x; + } + + /** + * This is identical to getln(). + */ + public static String getlnString() { + return getln(); + } + + /** + * Reads all the characters from the current input source, up to the next end-of-line. The end-of-line + * is read but is not included in the return value. Any other whitespace characters on the line are retained, + * even if they occur at the start of input. The return value will be an empty string if there are + * no characters before the end-of-line. When using standard IO, this will not produce an error. + * In other cases, an IllegalArgumentException will be thrown if an end-of-file is encountered. + */ + public static String getln() { + StringBuffer s = new StringBuffer(100); + char ch = readChar(); + while (ch != '\n') { + s.append(ch); + ch = readChar(); + } + return s.toString(); + } + + /** + * Skips whitespace characters and then reads a value of type byte from input. Any additional characters on + * the current line of input are retained, and will be read by the next input operation. When using standard IO, + * this will not produce an error; the user will be prompted repeatedly for input until a legal value + * is input. In other cases, an IllegalArgumentException will be thrown if a legal value is not found. + */ + public static byte getByte() { + return (byte)readInteger(-128L,127L); + } + + /** + * Skips whitespace characters and then reads a value of type short from input. Any additional characters on + * the current line of input are retained, and will be read by the next input operation. When using standard IO, + * this will not produce an error; the user will be prompted repeatedly for input until a legal value + * is input. In other cases, an IllegalArgumentException will be thrown if a legal value is not found. + */ + public static short getShort() { + return (short)readInteger(-32768L,32767L); + } + + /** + * Skips whitespace characters and then reads a value of type int from input. Any additional characters on + * the current line of input are retained, and will be read by the next input operation. When using standard IO, + * this will not produce an error; the user will be prompted repeatedly for input until a legal value + * is input. In other cases, an IllegalArgumentException will be thrown if a legal value is not found. + */ + public static int getInt() { + return (int)readInteger(Integer.MIN_VALUE, Integer.MAX_VALUE); + } + + /** + * Skips whitespace characters and then reads a value of type long from input. Any additional characters on + * the current line of input are retained, and will be read by the next input operation. When using standard IO, + * this will not produce an error; the user will be prompted repeatedly for input until a legal value + * is input. In other cases, an IllegalArgumentException will be thrown if a legal value is not found. + */ + public static long getLong() { + return readInteger(Long.MIN_VALUE, Long.MAX_VALUE); + } + + /** + * Skips whitespace characters and then reads a single non-whitespace character from input. Any additional characters on + * the current line of input are retained, and will be read by the next input operation. When using standard IO, + * this will not produce an error. In other cases, an IllegalArgumentException will be thrown if an end-of-file + * is encountered. + */ + public static char getChar() { + skipWhitespace(); + return readChar(); + } + + /** + * Skips whitespace characters and then reads a value of type float from input. Any additional characters on + * the current line of input are retained, and will be read by the next input operation. When using standard IO, + * this will not produce an error; the user will be prompted repeatedly for input until a legal value + * is input. In other cases, an IllegalArgumentException will be thrown if a legal value is not found. + */ + public static float getFloat() { + float x = 0.0F; + while (true) { + String str = readRealString(); + if (str == null) { + errorMessage("Floating point number not found.", + "Real number in the range " + (-Float.MAX_VALUE) + " to " + Float.MAX_VALUE); + } + else { + try { + x = Float.parseFloat(str); + } + catch (NumberFormatException e) { + errorMessage("Illegal floating point input, " + str + ".", + "Real number in the range " + (-Float.MAX_VALUE) + " to " + Float.MAX_VALUE); + continue; + } + if (Float.isInfinite(x)) { + errorMessage("Floating point input outside of legal range, " + str + ".", + "Real number in the range " + (-Float.MAX_VALUE) + " to " + Float.MAX_VALUE); + continue; + } + break; + } + } + inputErrorCount = 0; + return x; + } + + /** + * Skips whitespace characters and then reads a value of type double from input. Any additional characters on + * the current line of input are retained, and will be read by the next input operation. When using standard IO, + * this will not produce an error; the user will be prompted repeatedly for input until a legal value + * is input. In other cases, an IllegalArgumentException will be thrown if a legal value is not found. + */ + public static double getDouble() { + double x = 0.0; + while (true) { + String str = readRealString(); + if (str == null) { + errorMessage("Floating point number not found.", + "Real number in the range " + (-Double.MAX_VALUE) + " to " + Double.MAX_VALUE); + } + else { + try { + x = Double.parseDouble(str); + } + catch (NumberFormatException e) { + errorMessage("Illegal floating point input, " + str + ".", + "Real number in the range " + (-Double.MAX_VALUE) + " to " + Double.MAX_VALUE); + continue; + } + if (Double.isInfinite(x)) { + errorMessage("Floating point input outside of legal range, " + str + ".", + "Real number in the range " + (-Double.MAX_VALUE) + " to " + Double.MAX_VALUE); + continue; + } + break; + } + } + inputErrorCount = 0; + return x; + } + + /** + * Skips whitespace characters and then reads one "word" from input. Any additional characters on + * the current line of input are retained, and will be read by the next input operation. A word is defined as + * a sequence of non-whitespace characters (not just letters!). When using standard IO, + * this will not produce an error. In other cases, an IllegalArgumentException will be thrown + * if an end-of-file is encountered. + */ + public static String getWord() { + skipWhitespace(); + StringBuffer str = new StringBuffer(50); + char ch = lookChar(); + while (ch == EOF || !Character.isWhitespace(ch)) { + str.append(readChar()); + ch = lookChar(); + } + return str.toString(); + } + + /** + * Skips whitespace characters and then reads a value of type boolean from input. Any additional characters on + * the current line of input are retained, and will be read by the next input operation. When using standard IO, + * this will not produce an error; the user will be prompted repeatedly for input until a legal value + * is input. In other cases, an IllegalArgumentException will be thrown if a legal value is not found. + *

Legal inputs for a boolean input are: true, t, yes, y, 1, false, f, no, n, and 0; letters can be + * either upper case or lower case. One "word" of input is read, using the getWord() method, and it + * must be one of these; note that the "word" must be terminated by a whitespace character (or end-of-file). + */ + public static boolean getBoolean() { + boolean ans = false; + while (true) { + String s = getWord(); + if ( s.equalsIgnoreCase("true") || s.equalsIgnoreCase("t") || + s.equalsIgnoreCase("yes") || s.equalsIgnoreCase("y") || + s.equals("1") ) { + ans = true; + break; + } + else if ( s.equalsIgnoreCase("false") || s.equalsIgnoreCase("f") || + s.equalsIgnoreCase("no") || s.equalsIgnoreCase("n") || + s.equals("0") ) { + ans = false; + break; + } + else + errorMessage("Illegal boolean input value.", + "one of: true, false, t, f, yes, no, y, n, 0, or 1"); + } + inputErrorCount = 0; + return ans; + } + + // ***************** Everything beyond this point is private implementation detail ******************* + + private static String inputFileName; // Name of file that is the current input source, or null if the source is not a file. + private static String outputFileName; // Name of file that is the current output destination, or null if the destination is not a file. + + private static JFileChooser fileDialog; // Dialog used by readUserSelectedFile() and writeUserSelectedFile() + + private final static BufferedReader standardInput = new BufferedReader(new InputStreamReader(System.in)); // wraps standard input stream + private final static PrintWriter standardOutput = new PrintWriter(System.out); // wraps standard output stream + + private static BufferedReader in = standardInput; // Stream that data is read from; the current input source. + private static PrintWriter out = standardOutput; // Stream that data is written to; the current output destination. + + private static boolean readingStandardInput = true; + private static boolean writingStandardOutput = true; + + private static int inputErrorCount; // Number of consecutive errors on standard input; reset to 0 when a successful read occurs. + private static int outputErrorCount; // Number of errors on standard output since it was selected as the output destination. + + private static Matcher integerMatcher; // Used for reading integer numbers; created from the integer Regex Pattern. + private static Matcher floatMatcher; // Used for reading floating point numbers; created from the floatRegex Pattern. + private final static Pattern integerRegex = Pattern.compile("(\\+|-)?[0-9]+"); + private final static Pattern floatRegex = Pattern.compile("(\\+|-)?(([0-9]+(\\.[0-9]*)?)|(\\.[0-9]+))((e|E)(\\+|-)?[0-9]+)?"); + + private static String buffer = null; // One line read from input. + private static int pos = 0; // Position of next char in input line that has not yet been processed. + + private static String readRealString() { // read chars from input following syntax of real numbers + skipWhitespace(); + if (lookChar() == EOF) + return null; + if (floatMatcher == null) + floatMatcher = floatRegex.matcher(buffer); + floatMatcher.region(pos,buffer.length()); + if (floatMatcher.lookingAt()) { + String str = floatMatcher.group(); + pos = floatMatcher.end(); + return str; + } + else + return null; + } + + private static String readIntegerString() { // read chars from input following syntax of integers + skipWhitespace(); + if (lookChar() == EOF) + return null; + if (integerMatcher == null) + integerMatcher = integerRegex.matcher(buffer); + integerMatcher.region(pos,buffer.length()); + if (integerMatcher.lookingAt()) { + String str = integerMatcher.group(); + pos = integerMatcher.end(); + return str; + } + else + return null; + } + + private static long readInteger(long min, long max) { // read long integer, limited to specified range + long x=0; + while (true) { + String s = readIntegerString(); + if (s == null){ + errorMessage("Integer value not found in input.", + "Integer in the range " + min + " to " + max); + } + else { + String str = s.toString(); + try { + x = Long.parseLong(str); + } + catch (NumberFormatException e) { + errorMessage("Illegal integer input, " + str + ".", + "Integer in the range " + min + " to " + max); + continue; + } + if (x < min || x > max) { + errorMessage("Integer input outside of legal range, " + str + ".", + "Integer in the range " + min + " to " + max); + continue; + } + break; + } + } + inputErrorCount = 0; + return x; + } + + + private static void errorMessage(String message, String expecting) { // Report error on input. + if (readingStandardInput && writingStandardOutput) { + // inform user of error and force user to re-enter. + out.println(); + out.print(" *** Error in input: " + message + "\n"); + out.print(" *** Expecting: " + expecting + "\n"); + out.print(" *** Discarding Input: "); + if (lookChar() == '\n') + out.print("(end-of-line)\n\n"); + else { + while (lookChar() != '\n') // Discard and echo remaining chars on the current line of input. + out.print(readChar()); + out.print("\n\n"); + } + out.print("Please re-enter: "); + out.flush(); + readChar(); // discard the end-of-line character + inputErrorCount++; + if (inputErrorCount >= 10) + throw new IllegalArgumentException("Too many input consecutive input errors on standard input."); + } + else if (inputFileName != null) + throw new IllegalArgumentException("Error while reading from file \"" + inputFileName + "\":\n" + + message + "\nExpecting " + expecting); + else + throw new IllegalArgumentException("Error while reading from inptu stream:\n" + + message + "\nExpecting " + expecting); + } + + private static char lookChar() { // return next character from input + if (buffer == null || pos > buffer.length()) + fillBuffer(); + if (buffer == null) + return EOF; + else if (pos == buffer.length()) + return '\n'; + else + return buffer.charAt(pos); + } + + private static char readChar() { // return and discard next character from input + char ch = lookChar(); + if (buffer == null) { + if (readingStandardInput) + throw new IllegalArgumentException("Attempt to read past end-of-file in standard input???"); + else + throw new IllegalArgumentException("Attempt to read past end-of-file in file \"" + inputFileName + "\"."); + } + pos++; + return ch; + } + + private static void fillBuffer() { // Wait for user to type a line and press return, + try { + buffer = in.readLine(); + } + catch (Exception e) { + if (readingStandardInput) + throw new IllegalArgumentException("Error while reading standard input???"); + else if (inputFileName != null) + throw new IllegalArgumentException("Error while attempting to read from file \"" + inputFileName + "\"."); + else + throw new IllegalArgumentException("Errow while attempting to read form an input stream."); + } + pos = 0; + floatMatcher = null; + integerMatcher = null; + } + + private static void emptyBuffer() { // discard the rest of the current line of input + buffer = null; + } + + private static void outputError(String message) { // Report an error on output. + if (writingStandardOutput) { + System.err.println("Error occurred in TextIO while writing to standard output!!"); + outputErrorCount++; + if (outputErrorCount >= 10) { + outputErrorCount = 0; + throw new IllegalArgumentException("Too many errors while writing to standard output."); + } + } + else if (outputFileName != null){ + throw new IllegalArgumentException("Error occurred while writing to file \"" + + outputFileName+ "\":\n " + message); + } + else { + throw new IllegalArgumentException("Error occurred while writing to output stream:\n " + message); + } + } + +} // end of class TextIO diff --git a/src/praktikum2/Grupeerija.java b/src/praktikum2/Grupeerija.java new file mode 100644 index 0000000..fca3c18 --- /dev/null +++ b/src/praktikum2/Grupeerija.java @@ -0,0 +1,21 @@ +package praktikum2; + +public class Grupeerija { + + public static void main(String[] args) { + System.out.printf("Sisesta inimeste arv: "); + int inimeste_arv = lib.TextIO.getlnInt(); + + System.out.printf("Sisesta grupi suurus: "); + int grupi_suurus = lib.TextIO.getlnInt(); + + int gruppide_arv = inimeste_arv / grupi_suurus; + int inimeste_jääk = inimeste_arv % grupi_suurus; + + System.out.printf("Kui %d inimest jagada gruppidesse kus igas grupi on %d inimest\n", + inimeste_arv, grupi_suurus); + System.out.printf("Siis oleks kokku %d gruppi ja üle jääks %d inimest", + gruppide_arv, inimeste_jääk); + } + +} diff --git a/src/praktikum2/Korrutaja.java b/src/praktikum2/Korrutaja.java new file mode 100644 index 0000000..9e96a00 --- /dev/null +++ b/src/praktikum2/Korrutaja.java @@ -0,0 +1,31 @@ +package praktikum2; + +public class Korrutaja { + + public static void main(String[] args) { + System.out.printf("Sisesta esimene arv: "); + int arv1 = lib.TextIO.getlnInt(); + + System.out.printf("Sisesta teine arv: "); + int arv2 = lib.TextIO.getlnInt(); + + System.out.println("Arvude " + arv1 + " ja " + arv2 + " korrutis on " + arv1*arv2); + } +} + +// +// █████ ▒██▒ ██▒ ▒██ ▒██▒ +// █████ ▓██▓ ██▓ ▓██ ▓██▓ +// ██ ████ ▒██ ██▒ ████ +// ██ ████ ▒██ ██▒ ████ +// ██ ▒█▓▓█▒ ██ ░██ ▒█▓▓█▒ +// ██ ▓█▒▒█▓ ██▒▒██ ▓█▒▒█▓ +// ██ ██ ██ ██▒▒██ ██ ██ +// ██ ██████ ▒████▒ ██████ +// ██ ░██████░ ░████░ ░██████░ +//█▒ ▒██ ▒██ ██▒ ████ ▒██ ██▒ +//███████▓ ███ ███ ████ ███ ███ +//░█████▒ ██▒ ▒██ ▓██▓ ██▒ ▒██ +// + + \ No newline at end of file diff --git a/src/praktikum2/NimePikkus.java b/src/praktikum2/NimePikkus.java new file mode 100644 index 0000000..00f0c1b --- /dev/null +++ b/src/praktikum2/NimePikkus.java @@ -0,0 +1,13 @@ +package praktikum2; + +public class NimePikkus { + + public static void main(String[] args) { + System.out.println("Sisesta mingi nimi ja ma ütlen sulle selle pikkuse"); + System.out.printf("Sisesta nimi: "); + String nimi = lib.TextIO.getlnString(); + int nimePikkus = nimi.length(); + System.out.println("Sisestatud nime pikkus on " + nimePikkus); + } + +} diff --git a/src/praktikum2/Tere.java b/src/praktikum2/Tere.java new file mode 100644 index 0000000..1963284 --- /dev/null +++ b/src/praktikum2/Tere.java @@ -0,0 +1,13 @@ +package praktikum2; + +import java.util.Calendar; + +public class Tere { + + public static void main(String[] args) { + int synniaasta = 1995; + int vanus = Calendar.getInstance().get(Calendar.YEAR) - synniaasta; + System.out.println ("Yo, ma olen Arti, hetkel " + vanus + " aastat vana"); + System.out.println ("Kinga numbrit peast ei mäleta hetkel...."); + } +} diff --git a/src/praktikum3/CumLaude.java b/src/praktikum3/CumLaude.java new file mode 100644 index 0000000..939b153 --- /dev/null +++ b/src/praktikum3/CumLaude.java @@ -0,0 +1,38 @@ +package praktikum3; + +public class CumLaude { + + public static void main(String[] args) { + + // Küsime kasutaja käest hindeid ujukomaarvudena + System.out.printf("Sisesta keskmine hinne: "); + double keskminehinne = lib.TextIO.getlnDouble(); + System.out.printf("Sisesta lõputöö hinne: "); + double lõputööhinne = lib.TextIO.getlnDouble(); + + // Kasutajapoolt sisestatud numbrite reeglitele vastavuse kontroll + if (keskminehinne > 5.0) { + System.out.printf("Keskmine hinne ei tohi olla üle 5, teie seisestasite %.1f %n", keskminehinne); + return; // välju main funktsioonist ja lõpeta programmi töö + } else if (lõputööhinne >5.0) { + System.out.printf("Lõputöö hinne ei tohi olla üle 5, teie seisestasite %.1f %n", lõputööhinne); + return; + } else if (keskminehinne < 0.0) { + System.out.printf("Keskmine hinne ei tohi olla üle negatiivne, teie seisestasite %.1f %n", keskminehinne); + return; + } else if (lõputööhinne < 0.0) { + System.out.printf("Lõputöö hinne ei tohi olla üle negatiivne, teie seisestasite %.1f %n", lõputööhinne); + return; + } + + // Ülessanne ise + if ((keskminehinne >= 4.5) && (lõputööhinne == 5.0)) { + System.out.println("Palju õnne, saad Cum-Laude oma diplomile"); + } else { + System.out.println("Sina kahjuks oma hinnetega Cum-Laude-t enda diplomile"); + } + + + } + +} diff --git a/src/praktikum3/ParooliSisestus.java b/src/praktikum3/ParooliSisestus.java new file mode 100644 index 0000000..fcbb3d6 --- /dev/null +++ b/src/praktikum3/ParooliSisestus.java @@ -0,0 +1,11 @@ +package praktikum3; + +public class ParooliSisestus { + + public static void main(String[] args) { + System.out.println("yo"); + + } + + +} \ No newline at end of file diff --git a/src/praktikum3/Tehisintellekt.java b/src/praktikum3/Tehisintellekt.java new file mode 100644 index 0000000..32657ad --- /dev/null +++ b/src/praktikum3/Tehisintellekt.java @@ -0,0 +1,40 @@ +package praktikum3; + +public class Tehisintellekt { + + public static void main(String[] args) { + // Küsime kasutaja käest mõned vanused + System.out.printf("Sisesta üks vanus: "); + int esimenevanus = lib.TextIO.getlnInt(); + System.out.printf("Sisesta teine vanus: "); + int teinevanus = lib.TextIO.getlnInt(); + + // Sisendi valideerimine + if ((esimenevanus < 0) || (teinevanus < 0)) { + System.out.println("Vanus ei tohi olla negatiivne"); + return; + } + + // Teeme järgnevad vanusevahe testid lihtsamaks eemaldades endest mitme erineva vanuse vahe testimise + int esimenevanusevahe = esimenevanus-teinevanus; + int teinevanusevahe = teinevanus-esimenevanus; + int vanusevahe = 0; // vanusevahe mida me hakkame testima + + if (esimenevanus < teinevanus) { + vanusevahe = teinevanusevahe; + } else { + vanusevahe = esimenevanusevahe; + } + + + if ((vanusevahe > 5) && (vanusevahe < 10)) { + System.out.println("Krõbe"); + } else if (vanusevahe >= 10) { + System.out.println("Väga krõbe"); + } else { + System.out.println("Sobib"); + } + + } + +} diff --git a/src/praktikum4/numbrid0246.java b/src/praktikum4/numbrid0246.java new file mode 100644 index 0000000..6f984f9 --- /dev/null +++ b/src/praktikum4/numbrid0246.java @@ -0,0 +1,12 @@ +package praktikum4; + +public class numbrid0246 { + + public static void main(String[] args) { + for (int x = 0; x <= 10; x += 2) { + System.out.printf("%d ", x); + } + + } + +} diff --git a/src/praktikum4/numbrid110.java b/src/praktikum4/numbrid110.java new file mode 100644 index 0000000..fc415d0 --- /dev/null +++ b/src/praktikum4/numbrid110.java @@ -0,0 +1,12 @@ +package praktikum4; + +public class numbrid110 { + + public static void main(String[] args) { + for (int x = 1; x <= 10; x++) { + System.out.printf("%d ", x); + } + + } + +} diff --git a/src/praktikum4/numbrid302734.java b/src/praktikum4/numbrid302734.java new file mode 100644 index 0000000..a96c92f --- /dev/null +++ b/src/praktikum4/numbrid302734.java @@ -0,0 +1,12 @@ +package praktikum4; + +public class numbrid302734 { + + public static void main(String[] args) { + for (int x = 30; x > 0; x -=3) { + System.out.printf("%d ", x); + } + + } + +} diff --git a/src/praktikum4/table1.java b/src/praktikum4/table1.java new file mode 100644 index 0000000..260071c --- /dev/null +++ b/src/praktikum4/table1.java @@ -0,0 +1,23 @@ +package praktikum4; + +public class table1 { + + public static void main(String[] args) { + final int x_size = 7; // table size in x direction + final int y_size = 7; // table size in y direction + + // Create the table + for (int x = 0; x <= x_size; x++) { + for (int y = 0; y <= y_size; y++) { + if (x == y) { + System.out.printf("1 "); + } else { + System.out.printf("0 "); + } + + } + //we are at the end of the line, start a new one + System.out.printf("%n"); + } + } +} diff --git a/src/praktikum4/table2.java b/src/praktikum4/table2.java new file mode 100644 index 0000000..b5d0559 --- /dev/null +++ b/src/praktikum4/table2.java @@ -0,0 +1,30 @@ +package praktikum4; + +public class table2 { + + public static void main(String[] args) { + System.out.printf("Tabeli X suurus: "); + int x_size = lib.TextIO.getlnInt(); // table size in x direction + System.out.printf("Tabeli Y suurus: "); + int y_size = lib.TextIO.getlnInt(); // table size in y direction + + // Create the table + for (int x = 0; x <= x_size; x++) { + System.out.printf("--"); + } + System.out.printf("%n"); + for (int x = 0; x <= x_size; x++) { + System.out.printf("| "); + for (int y = 0; y <= y_size; y++) { + if (x == y) { + System.out.printf("1 "); + } else { + System.out.printf("0 "); + } + + } + //we are at the end of the line, start a new one + System.out.printf("%n"); + } + } +}