initHEADmaster

27 files changed, 3576 insertions, 0 deletions

diff --git a/MineSweeper.java b/MineSweeper.java
new file mode 100644
index 0000000..22b8966
--- /dev/null
+++ b/MineSweeper.java
@@ -0,0 +1,99 @@
+// Miya Natsuhara
+// CSE 122
+// 1-5-2024
+
+import java.util.*;
+
+// This program randomly-generates and displays a MineSweeper board according to the difficulty 
+// level specified by the user. 
+
+public class MineSweeper {
+    public static final int BOARD_SIZE = 15; // assume a board size board, square
+    public static final int MINE_INDICATOR = -1; 
+
+    public static void main(String[] args) {
+        int[][] board = new int[BOARD_SIZE][BOARD_SIZE];
+
+        int difficultyLevel = intro(); // introduce game and get level of difficulty (more mines -> harder)
+        int numMines = getNumMines(difficultyLevel);
+        generateMines(numMines, board); // generate coordinates for all the mines
+        updateCounts(board);  // updates the board with all the counts of mines
+        displayBoard(board);
+    }
+
+    // Prints a welcome message and prompts the user for difficulty level (between 1 and 10). 
+    // Restricts the user's response to this range and returns the result. 
+    public static int intro() {
+        Scanner console = new Scanner(System.in);
+        System.out.println("Welcome to MineSweeper!");
+        System.out.print("Please choose game difficulty (NOTE: Difficulty: 1 to 10): ");
+        int userNum = console.nextInt();
+        if (userNum > 10) {
+            userNum = 10;
+        } else if (userNum < 1) {
+            userNum = 1;
+        }
+        return userNum;
+    }
+
+    // Given a difficulty level, returns the number of mines that should be placed on the board. 
+    public static int getNumMines(int difficultyLevel) {
+        return difficultyLevel * (BOARD_SIZE / 5); // arbitrary
+    }
+
+    // Given the desired number of mines and game board, randomly places the specified number of
+    // mines throughout the board. 
+    public static void generateMines(int numMines, int[][] board) {
+        Random r = new Random();
+        for (int i = 0; i < numMines; i++) {
+            int xCoord = r.nextInt(BOARD_SIZE);
+            int yCoord = r.nextInt(BOARD_SIZE);
+            board[xCoord][yCoord] = MINE_INDICATOR;
+        }
+    }
+
+    // Given the board and a location (x, y) to check, returns the number of mines adjacent to 
+    // location (x, y). 
+    public static int placeCount(int[][] board, int x, int y) {
+        int count = 0;
+        for (int i = -1; i < 2; i++) {
+            for (int j = -1; j < 2; j++) {
+                int xCoord = x + i;
+                int yCoord = y + j;
+                boolean validSquare = xCoord >= 0 && xCoord < BOARD_SIZE && 
+                                      yCoord >= 0 && yCoord < BOARD_SIZE;
+                if (validSquare && board[xCoord][yCoord] == MINE_INDICATOR) {
+                    count++;
+                }
+            }
+        }
+        return count;
+    }
+
+    // Given the game board, places the appropriate numbers in non-mine cells throughout the
+    // board. 
+    public static void updateCounts(int[][] board) {
+        for (int i = 0; i < BOARD_SIZE; i++) {
+            for (int j = 0; j < BOARD_SIZE; j++) {
+                if (board[i][j] != MINE_INDICATOR) {
+                    board[i][j] = placeCount(board, i, j);
+                }
+            }
+        }
+    }
+
+    // Prints the board to the console, with each square's contents evenly-spaced. 
+    public static void displayBoard(int[][] board) {
+        for (int i = 0; i < BOARD_SIZE; i++) {
+            for (int j = 0; j < BOARD_SIZE; j++) {
+                if (board[i][j] == MINE_INDICATOR) {
+                    System.out.print("X ");
+                } else {
+                    System.out.print(board[i][j] + " ");
+                }
+            }
+            System.out.println();
+        }
+        System.out.println();
+    }
+}
diff --git a/Music.java b/Music.java
new file mode 100644
index 0000000..082c5b0
--- /dev/null
+++ b/Music.java
@@ -0,0 +1,132 @@
+// Nik Johnson
+// 1-7-2024
+// CSE 122
+
+import java.util.*;
+
+public class Music {
+    public static final String NOTES = "CDEFGAB";
+    public static final String SHARP = "♯";
+    public static final String FLAT = "♭";
+    
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        String[][] song = composeSong(scanner);
+        mostCommonNaturals(song);
+        System.out.println(Arrays.toString(mostCommonNaturals(song)));
+    }
+
+// "parent" method that calls helper methods getSongParams and composeMelodies
+// returns 2D array containing user-composed song
+
+    public static String[][] composeSong(Scanner scanner) {
+        
+        int[] songParams = getSongParams(scanner);
+        
+        return composeMelodies(scanner, songParams[0], songParams[1]);
+    }
+
+ // get user input on song parameters, return for use with composeMelodies
+    public static int[] getSongParams(Scanner scanner) {
+
+        System.out.print("Enter the number of melodies: ");
+        String inputNum = scanner.nextLine();
+        int numMelodies = Integer.parseInt(inputNum);
+
+        System.out.print("Enter the length of each melody: ");
+        String inputLength = scanner.nextLine();
+        int lengthMelodies = Integer.parseInt(inputLength);
+
+
+    
+        return new int[] {numMelodies, lengthMelodies};
+    }
+ // iterate through array of dimensions defined by list songParams, storing user-inputted notes as we go
+    public static String[][] composeMelodies(Scanner scanner, int numMelodies, int lengthMelodies) {
+        System.out.println("");
+
+        String[][] songArray = new String[numMelodies][lengthMelodies];
+
+        for (int n = 0; n < numMelodies; n++) {
+
+            System.out.println("Composing melody #" + (n+1));
+
+            for (int i = 0; i < lengthMelodies; i++) {
+                System.out.print("  Enter note #" + (i+1) + ": ");
+                String note = scanner.nextLine();
+                songArray[n][i] = note;
+
+            
+                if (numMelodies > 1) {
+                
+                } else if (lengthMelodies > 1) {
+                    System.out.println();
+                }
+            }
+             System.out.println();
+        }
+        return songArray;
+    }
+    
+ // parent method, use data from helper methods to assemble output array
+    public static String[] mostCommonNaturals(String[][] song) {
+        // new function
+
+        // string array thats # of melodies long -> since there will be that many notes
+
+        String[] notes = NOTES.split("");
+        
+        String[] result = new String[song.length];
+        for (int i = 0; i < result.length; i++) {
+            // get frequency list PER melody
+            int[] numNaturals = getNumNaturals(song[i]);
+            
+            // get largest frequency # in list
+
+            int largestFreq = getLargestFrequency(numNaturals);
+
+            // put note matching that largest frequency (in order of NOTES) into result array
+            // "CDEFGAB";
+            // [0, 1, 2, 1, 2, 0, 0]
+            // 2
+            // result = ["E"]
+
+            for (int n = 0; n < numNaturals.length; n++) {
+                if (numNaturals[n] == largestFreq) {
+                    result[i] = notes[n];
+                    break;
+                }
+            }
+        }
+
+
+        return result;
+    }
+
+ // look for frequency of note that appears most frequently in song
+    public static int getLargestFrequency(int[] numNaturals) {
+        int freq = 0;
+        for (int j = 0; j < numNaturals.length; j++) {
+            if (numNaturals[j] > freq) {
+                freq = numNaturals[j];
+            }
+        }
+        return freq;
+    }
+          
+    public static int[] getNumNaturals(String[] melody) {
+        int[] numNaturals = new int[NOTES.length()];
+
+        for (int n = 0; n < melody.length; n++) {
+            String note = melody[n];
+            if (note.length() == 1) {
+                int index = NOTES.indexOf(note);
+                numNaturals[index]++;
+            }
+
+        }
+        return numNaturals;
+    }
+
+
+}
diff --git a/MusicPlaylist.java b/MusicPlaylist.java
new file mode 100644
index 0000000..c25e4eb
--- /dev/null
+++ b/MusicPlaylist.java
@@ -0,0 +1,95 @@
+import java.util.*;
+
+public class MusicPlaylist {
+
+	private Queue<String> playlist;
+	private Stack<String> history;
+
+	public MusicPlaylist() {
+		playlist = new LinkedList<>();
+		history = new Stack<>();
+    }
+
+    // add song to playlist according to user input
+    // no return
+	public void addSong(String songToAdd) {
+		System.out.print("Enter song name: ");
+		playlist.add(songToAdd);
+		System.out.println("Successfully added " + songToAdd);
+		System.out.println();
+		System.out.println();
+	}
+
+    //  play song at the front of the playlist
+    //  no return
+	public void playSong() {
+		// if user attempts to play song when playlist is empty, throw exception
+		if (playlist.isEmpty()) throw new IllegalStateException();
+		String songToPlay = playlist.remove();
+		System.out.println("Playing song: " + songToPlay);
+		history.push(songToPlay);
+		System.out.println();
+		System.out.println();
+	}
+
+	// print history of played songs
+	// return unmodified history after printing it
+	public void printHistory() {
+		int size = history.size();
+		// if there is no history and user attempts to print history, throw exception
+		if (history.isEmpty()) throw new IllegalStateException();
+		String[] historyArray = new String[size];
+		if (size != 0) {
+			for (int i = (size - 1); i >= 0; i--) {
+				historyArray[i] = history.pop();
+				System.out.println("    " + historyArray[i]);
+			}
+			for (int n = 0; n < size; n++) {
+				history.push(historyArray[n]);
+			}
+		}
+		System.out.println();
+		System.out.println();
+	}
+
+	public void clearHistory() {
+		playlist.clear();
+	}
+
+	// delete from history according to user input, starting either from most recent or oldest history
+	// return modified history
+	public void deleteFromHistory(int numToDelete) {
+		int size = history.size();
+		List<String> historyArrayList = new ArrayList<>();
+		if (!history.isEmpty()) {
+			for (int i = 0; i < size; i++) {
+				historyArrayList.add(history.pop());
+			}
+		}
+		System.out.println("A positive number will delete from recent history.");
+		System.out.println("A negative number will delete from the beginning of history.");
+		System.out.print("Enter number of songs to delete: ");
+		int absNum = Math.abs(numToDelete);
+		if (absNum > size) {
+			throw new IllegalArgumentException();
+		}
+		System.out.println();
+		if (size != 0 && absNum != 0) {
+			if (absNum == size) {
+				historyArrayList.clear();
+			} else if (numToDelete < 0) {
+				int lastIndex = size - 1;
+				for (int n = lastIndex; n >= (size - absNum); n--) {
+					historyArrayList.remove(n);
+				}
+			} else if (numToDelete > 0) {
+				for (int i = 0; i < numToDelete; i++) {
+					historyArrayList.remove(0);
+				}
+			}
+		}
+		for (int n = (historyArrayList.size() - 1); n >= 0; n--) {
+			history.push(historyArrayList.get(n));
+		}
+	}
+	}
diff --git a/MusicPlaylistMain.java b/MusicPlaylistMain.java
new file mode 100644
index 0000000..b093b5f
--- /dev/null
+++ b/MusicPlaylistMain.java
@@ -0,0 +1,43 @@
+import java.util.*;
+
+public class MusicPlaylistMain {
+	public static void main(String[] args) {
+		Scanner console = new Scanner(System.in);
+		System.out.println("Welcome to the CSE 122 Music Playlist!");
+
+		MusicPlaylist playlist = new MusicPlaylist();
+
+		String destination = navigator(console);
+		while (!destination.equalsIgnoreCase("Q")) {
+		if (destination.equalsIgnoreCase("A")) {
+			String songToAdd = console.nextLine();
+			playlist.addSong(songToAdd);
+		} else if (destination.equalsIgnoreCase("P")) {
+			playlist.playSong();
+		} else if (destination.equalsIgnoreCase("Pr")) {
+			playlist.printHistory();
+		} else if (destination.equalsIgnoreCase("C")) {
+			playlist.clearHistory();
+		} else if (destination.equalsIgnoreCase("D")) {
+			int numToDelete = Integer.parseInt(console.nextLine());
+			playlist.deleteFromHistory(numToDelete);
+		}
+		destination = navigator(console);
+		}
+	}
+    
+    // menu function, called initially and after any other functions
+    // return String for use in main menu loop
+	public static String navigator(Scanner console) {
+		System.out.println("(A) Add song");
+		System.out.println("(P) Play song");
+		System.out.println("(Pr) Print history");
+		System.out.println("(C) Clear history");
+		System.out.println("(D) Delete from history");
+		System.out.println("(Q) Quit");
+		System.out.println();
+		System.out.print("Enter your choice: ");
+		String destination = console.nextLine();
+		return destination;
+	}
+}
diff --git a/Review.java b/Review.java
new file mode 100644
index 0000000..cd449b4
--- /dev/null
+++ b/Review.java
@@ -0,0 +1,42 @@
+import java.util.*;
+
+public class Review {
+    // Create a Map of students in section to their favorite word/movie/song/etc
+    // Then, edit and print out the Map 
+
+	public static void main(String[] args) {
+		// Create the Map (do you want it to do ordered?)
+		Map<String, String> favorites = new TreeMap<>();
+		// Add key/value pairs to the Map
+		favorites.put("me", "キュ毛付きさぼたじ");
+		favorites.put("nik", "warp star");
+		favorites.put("andy", "none");
+		System.out.println(favorites);
+		// Delete one of the entries from the Map
+		favorites.remove("andy");
+		// Override one of the values
+		favorites.put("boner", "balls");
+		// Loop over the Map and print out all the values seperated by a comma and space
+		// Before printing - hypothesize what the output will look like!
+		for (String key : favorites.keySet()) {
+			System.out.print(favorites.get(key) + ", ");
+		}
+
+		System.out.println();
+
+		Set<Integer> intset = new HashSet<>();
+		
+		for (int i = 0; i < 10; i++) {
+			intset.add(i);
+		}
+
+		System.out.println(intset);
+
+		Stack<Integer> s = new Stack<>();
+		System.out.println(s.isEmpty());
+
+		MusicPlaylist p1 = new MusicPlaylist();
+		p1.addSong("ohyeahyeah");
+		p1.playSong();
+	}
+}
diff --git a/Stonks.java b/Stonks.java
new file mode 100644
index 0000000..de99ba5
--- /dev/null
+++ b/Stonks.java
@@ -0,0 +1,169 @@
+// Nik Johnson
+// 1-25-2024
+// TA: Andy Ruan
+// modified attempt for resubmission 1
+
+import java.util.*;
+import java.io.*;
+
+// stock simulator
+// stock market sandbox which reads fake market data from "stonks.tsv", and allows users to:
+// buy and sell stocks, and save their portfolio to a file.
+// upon quitting, the value of the users portfolio will be calculated and printed.
+
+public class Stonks {
+    public static final String STOCKS_FILE_NAME = "stonks.tsv";
+
+    public static void main(String[] args) throws FileNotFoundException {
+        Scanner console = new Scanner(System.in);
+        File stonks = new File(STOCKS_FILE_NAME);
+        Scanner stonklines = new Scanner(stonks);
+        int numStocks = Integer.parseInt(stonklines.nextLine());
+
+        String[] tickers = new String[numStocks];
+        Double[] prices = new Double[numStocks];
+        Double[] portfolio = new Double[numStocks];
+
+        // fill portfolio with zeros to prevent null exceptions
+        // without using Arrays.fill()
+        for (int n = 0; n < numStocks; n++) {
+            portfolio[n] = 0.0;
+        }
+
+        String info = stonklines.nextLine();
+
+        // this runs once.
+        // functionally decomposing it would add lines of code, but no functionality. 
+        int index = 0;
+        while (stonklines.hasNextLine()) {
+            String nextline = stonklines.nextLine();
+            Scanner token = new Scanner(nextline);
+            tickers[index] = token.next();
+            prices[index] = token.nextDouble();
+            index++;
+        }
+
+        System.out.println("Welcome to the CSE 122 Stocks Simulator!");
+        System.out.println("There are " + numStocks + " stocks on the market:");
+
+        for (int i = 0; i < numStocks; i++) {
+            System.out.println(tickers[i] + ": " + prices[i]);
+
+        }
+
+        System.out.println();
+        String next = navigator(console);
+
+        while (!next.equals("quit")) {
+            if (next.equals("buy")) {
+                portfolio = buy(console, tickers, prices, portfolio);
+            } else if (next.equals("sell")) {
+                portfolio = sell(console, tickers, prices, portfolio);
+            } else if (next.equals("save")) {
+                save(console, tickers, portfolio);
+            } else {
+                System.out.println("Invalid choice: " + next);
+                System.out.println("Please try again");
+                System.out.println();
+            }
+            next = navigator(console);
+        }
+
+        Double value = quit(prices, portfolio);
+        System.out.println("Your portfolio is currently valued at: $" + value);
+    }
+
+    // menu method, called for inital prompt and then after using any other methods
+    // returns String which decides which function to use
+
+    public static String navigator(Scanner console) {
+        System.out.println("Menu: buy, sell, save, quit");
+        System.out.print("Enter your choice: ");
+        String destination = console.next();
+        return destination;
+    }
+
+    // add (buy) to portfolio according to user input, no lower than $5.0
+    // takes console scanner, and all data arrays defined in main lines 24-26
+    // return modified portfolio with MORE shares than before
+
+    public static Double[] buy(Scanner console, String[] tickers, 
+    Double[] prices, Double[] portfolio) {
+        System.out.print("Enter the stock ticker: ");
+        String order = console.next();
+        System.out.print("Enter your budget: ");
+        Double budget = console.nextDouble();
+
+        if (budget >= 5.0) {
+            for (int i = 0; i < tickers.length; i++) {
+                if (order.equals(tickers[i])) {
+                    portfolio[i] += (budget / prices[i]);
+                    System.out.println("You successfully bought " + tickers[i] + ".");
+                    System.out.println();
+            }
+        } 
+        } else {
+            System.out.println("Budget must be at least $5");
+            System.out.println();
+        }       
+        return portfolio;
+    }
+
+    // subtract (sell) from portfolio according to user input, if they have enough to sell
+    // takes console scanner, and all data arrays defined in main lines 24-26
+    // return modified portfolio with LESS shares than before
+
+    public static Double[] sell(Scanner console, String[] tickers, 
+    Double[] prices, Double[] portfolio) {
+        System.out.print("Enter the stock ticker: ");
+        String ticker = console.next();
+        System.out.print("Enter the number of shares to sell: ");
+        Double sellAmount = console.nextDouble();
+        for (int i = 0; i < tickers.length; i++) {
+            if (ticker.equals(tickers[i])) {
+                if (sellAmount > portfolio[i]) {
+                    System.out.println("You do not have enough shares of " + ticker + " to sell " + sellAmount + " shares.");
+                    System.out.println();
+                } else if (sellAmount <= portfolio[i]) {
+                    portfolio[i] = portfolio[i] - sellAmount;
+                    System.out.println("You successfully sold " + sellAmount + " shares of " + ticker + ".");
+                    System.out.println();
+                }
+            }
+        }
+        return portfolio;
+    }
+
+    // write current portfolio to file named according to user input
+    // takes console scanner, array of tickers and the users current portfolio
+
+    public static void save(Scanner console, String[] tickers, Double[] portfolio) throws FileNotFoundException {
+        System.out.print("Enter new portfolio file name: ");
+        String fileName = console.next();
+        System.out.println();
+        File saveData = new File(fileName);
+        PrintStream savePortfolio = new PrintStream(saveData);
+        for (int i = 0; i < tickers.length; i++) {
+            if (portfolio[i] != 0.0) {
+                savePortfolio.println(tickers[i] + " " + portfolio[i]);
+            }
+        }
+    }
+
+    // upon quitting, calculate total portfolio value using-
+    // -values in portfolio and current market prices
+    // return total value for printing
+
+    public static double quit(Double[] prices, Double[] portfolio) {
+        System.out.println();
+        Double portfolioValue = 0.0;
+        for (int i = 0; i < prices.length; i++) {
+            if (portfolio[i] != null) {
+                Double currValue = prices[i]*portfolio[i];
+                portfolioValue += currValue;
+            } else portfolioValue += 0;
+        }
+        return portfolioValue;
+    }
+
+}
diff --git a/WordStats.java b/WordStats.java
new file mode 100644
index 0000000..22c3c76
--- /dev/null
+++ b/WordStats.java
@@ -0,0 +1,75 @@
+import java.util.*;
+
+public class WordStats {
+    public static void main(String[] args) {
+        Scanner console = new Scanner(System.in);
+
+        String[] words = getListOfWords(console);
+        System.out.println("Words: " + Arrays.toString(words));
+
+        String longestWord = getLongestWord(words);
+        System.out.println("Longest word: " + longestWord);
+        
+        vowelSearch(words);
+    }
+    
+
+    /*
+     * ask user for number of words to test, and store that (integer) as "number_of_Words"
+     * loop for that number of iterations, adding each word to array "words"
+     */
+    public static String[] getListOfWords(Scanner console) {
+        System.out.print("How many words? ");
+        int numbers_of_WORDS = console.nextInt();
+
+        String[] words = new String[numbers_of_WORDS];
+
+        for (int i = 0; i < numbers_of_WORDS; i++) {
+            System.out.print("Next word? ");
+            String Word = console.next();
+            words[i] = Word;
+        }
+
+        return words;
+    }
+    
+    /*
+     * iterate through array "words"
+     * return longest word
+     */
+
+    public static String getLongestWord(String[] words) {
+        String longestWord = "";
+        for (int i = 0; i < words.length; i++) {
+            String curr = words[i];
+            if (curr.length() > longestWord.length()) {
+                longestWord = curr;
+            }
+        }
+        return longestWord;
+
+    }
+
+    /*
+     * test first character of each word in array "words"
+     * if first char is any defined in upper or lower case vowels, print it
+     */
+         
+    public static void vowelSearch(String[] words) {
+        char[] uppercaseVowels = { 'A', 'E', 'I', 'O', 'U' };
+        char[] lowercaseVowels = { 'a', 'e', 'i', 'o', 'u' };
+        System.out.println("Words beginning with vowels: ");
+        for (int i = 0; i < words.length; i++) {
+            String curr = words[i];
+            char firstChar = curr.charAt(0);
+            for (int j = 0; j < uppercaseVowels.length; j++) {
+                if (firstChar == uppercaseVowels[j] || firstChar == lowercaseVowels[j]) {
+                    System.out.println("    " + curr);
+                }
+            }
+        }
+
+    }
+
+
+}
diff --git a/absurdle/Absurdle.java b/absurdle/Absurdle.java
new file mode 100644
index 0000000..61443af
--- /dev/null
+++ b/absurdle/Absurdle.java
@@ -0,0 +1,232 @@
+// Nik Johnson
+// 2-11-2024
+// TA: Andy Ruan
+
+/*
+absurd wordle-like game
+instead of guessing one word, prolongs game as long as possible by
+testing users guess against every word in selected dictionary, and
+choosing the largest set of words associated with a possible pattern
+for the users guess. the game only ends when the next set to be
+considered is narrowed down to one, and the user guesses it.
+*/
+
+import java.util.*;
+import java.io.*;
+
+public class Absurdle  {
+    public static final String GREEN = "🟩";
+    public static final String YELLOW = "🟨";
+    public static final String GRAY = "⬜";
+
+    // [[ ALL OF MAIN PROVIDED ]]
+    public static void main(String[] args) throws FileNotFoundException {
+        Scanner console = new Scanner(System.in);
+        System.out.println("Welcome to the game of Absurdle.");
+
+        System.out.print("What dictionary would you like to use? ");
+        String dictName = console.next();
+
+        System.out.print("What length word would you like to guess? ");
+        int wordLength = console.nextInt();
+
+        List<String> contents = loadFile(new Scanner(new File(dictName)));
+        Set<String> words = pruneDictionary(contents, wordLength);
+
+        List<String> guessedPatterns = new ArrayList<>();
+        while (!isFinished(guessedPatterns)) {
+            System.out.print("> ");
+            String guess = console.next();
+            String pattern = record(guess, words, wordLength);
+            guessedPatterns.add(pattern);
+            System.out.println(": " + pattern);
+            System.out.println();
+        }
+        System.out.println("Absurdle " + guessedPatterns.size() + "/∞");
+        System.out.println();
+        printPatterns(guessedPatterns);
+        console.close();
+    }
+
+    // [[ PROVIDED ]]
+    // Prints out the given list of patterns.
+    // - List<String> patterns: list of patterns from the game
+    public static void printPatterns(List<String> patterns) {
+        for (String pattern : patterns) {
+            System.out.println(pattern);
+        }
+    }
+
+    // [[ PROVIDED ]]
+    // Returns true if the game is finished, meaning the user guessed the word. Returns
+    // false otherwise.
+    // - List<String> patterns: list of patterns from the game
+    public static boolean isFinished(List<String> patterns) {
+        if (patterns.isEmpty()) {
+            return false;
+        }
+        String lastPattern = patterns.get(patterns.size() - 1);
+        return !lastPattern.contains("⬜") && !lastPattern.contains("🟨");
+    }
+
+    // [[ PROVIDED ]]
+    // Loads the contents of a given file Scanner into a List<String> and returns it.
+    // - Scanner dictScan: contains file contents
+    public static List<String> loadFile(Scanner dictScan) {
+        List<String> contents = new ArrayList<>();
+        while (dictScan.hasNext()) {
+            contents.add(dictScan.next());
+        }
+        return contents;
+    }
+
+    /*
+    look through list of words from dictionary, removing words that aren't of
+    the user specified length.
+
+    takes list of words from user specified dictionary, and user specified word length
+    
+    return set of words pruned according to user input
+
+    if the user specified length is less than one, throw IllegalArgumentException
+    */
+    public static Set<String> pruneDictionary(List<String> contents, int wordLength) {
+        if (wordLength < 1) throw new IllegalArgumentException();
+        Set<String> prunedDict = new HashSet<>();
+        for (String word : contents) {
+            if (word.length() == wordLength) {
+                prunedDict.add(word);
+            }
+        }
+        return prunedDict;
+    }
+
+    /*
+    evaluate users guess, looking for the largest set of words that have the pattern
+    of the guess. if all possible patterns have the same number of words, pick the
+    first one in alphabetical order.
+
+    takes users guess, set of words determined by pruneDictionary, and length of users guess
+
+    return the pattern associated with the largest set of words
+
+    if the users guess is the wrong length, or there is no words to be guessed,
+    throw IllegalArgumentException
+    */
+    public static String record(String guess, Set<String> words, int wordLength) {
+        if (guess.length() != wordLength || words.isEmpty()) {
+            throw new IllegalArgumentException();
+        }
+
+        Map<String, Set<String>> wordMap = new TreeMap<>();
+        for (String word : words) {
+            String nextPattern = patternFor(word, guess);
+            if (!wordMap.containsKey(nextPattern)) {
+                wordMap.put(nextPattern, new HashSet<String>());
+            }
+            wordMap.get(nextPattern).add(word);
+        }
+
+        Boolean allSameSize = true;
+        int setSize1 = 0;
+
+        for (String pattern : wordMap.keySet()) {
+            int size = wordMap.get(pattern).size();
+            if (setSize1 == 0) setSize1 = size;
+            if (setSize1 != size) allSameSize = false;
+        }
+
+        if (allSameSize) {
+            for (String pattern : wordMap.keySet()) {
+                removeAllNonMatching(words, wordMap.get(pattern));
+                return pattern;
+            }
+        }
+
+        String pattern = "";
+        int setSize = 0;
+        for (String word : wordMap.keySet()) {
+            int nextSetSize = (wordMap.get(word)).size();
+            if (nextSetSize > setSize) {
+                setSize = nextSetSize;
+                pattern = word;
+            }
+        }
+        removeAllNonMatching(words, wordMap.get(pattern));
+        return pattern;
+    }
+
+    /*
+    helper method for record, removes words from next considered set that arent in
+    the largest set determined in record
+
+    takes next set of words to be considered as determined by record,
+    which will be used to trim the previous set
+
+    no return
+    */
+    public static void removeAllNonMatching(Set<String> words, Set<String> match) {
+        Iterator<String> iter = words.iterator();
+        while(iter.hasNext()) {
+            if(!match.contains(iter.next())) {
+                iter.remove();
+            }
+        }
+    }
+
+    /*
+    produce pattern for users guess against every word in set of 
+    considered words.
+
+    takes users guess, and the word to generate a pattern against
+
+    return pattern of colored squares for use in record
+    */
+    public static String patternFor(String word, String guess) {
+        List<String> splitGuess = new ArrayList<>();
+        String pattern = new String();
+        for (int i = 0;i < guess.length(); i++) {
+            String nextChar = Character.toString(guess.charAt(i));
+            splitGuess.add(nextChar);
+        }
+
+        Map<Character, Integer> wordMap = new HashMap<>();
+        for (int j = 0; j < word.length(); j++) {
+            char wordChar = word.charAt(j);
+            if (!wordMap.containsKey(wordChar)) {
+                wordMap.put(wordChar, 1);
+            } else {
+                wordMap.put(wordChar, (wordMap.get(wordChar) + 1));
+            }
+        }
+
+        for (int n = 0; n < splitGuess.size(); n++) {
+            if ((Character.toString(word.charAt(n))).equals(splitGuess.get(n))) {
+                int currCount = wordMap.get((splitGuess.get(n)).charAt(0));
+                wordMap.put(word.charAt(n), (currCount - 1));
+                splitGuess.set(n, GREEN);
+            }
+        }
+
+        for (int n = 0; n < splitGuess.size(); n++) {
+            char charToCheck = (splitGuess.get(n)).charAt(0);
+            if ((wordMap.keySet()).contains(charToCheck)
+            && wordMap.get(charToCheck) != 0) {
+                int currCount2 = wordMap.get(charToCheck);
+                wordMap.put(charToCheck, (currCount2 - 1));
+                splitGuess.set(n, YELLOW);
+            }
+        }
+
+        for (int n = 0; n < splitGuess.size(); n++) {
+            if ((splitGuess.get(n)).length() == 1) {
+                splitGuess.set(n, GRAY);
+            }
+        }
+
+        for (int i = 0; i < splitGuess.size(); i++) {
+            pattern += splitGuess.get(i);
+        }
+        return pattern;
+    }
+}
diff --git a/absurdle/dict.txt b/absurdle/dict.txt
new file mode 100644
index 0000000..196d2cd
--- /dev/null
+++ b/absurdle/dict.txt
@@ -0,0 +1,5 @@
+argh
+beta
+flew
+crew
+else
diff --git a/absurdle/dictionary1.txt b/absurdle/dictionary1.txt
new file mode 100644
index 0000000..e6be740
--- /dev/null
+++ b/absurdle/dictionary1.txt
@@ -0,0 +1,2309 @@
+cigar
+rebut
+sissy
+humph
+awake
+blush
+focal
+evade
+naval
+serve
+heath
+dwarf
+model
+karma
+stink
+grade
+quiet
+bench
+abate
+feign
+major
+death
+fresh
+crust
+stool
+colon
+abase
+marry
+react
+batty
+pride
+floss
+helix
+croak
+staff
+paper
+unfed
+whelp
+trawl
+outdo
+adobe
+crazy
+sower
+repay
+digit
+crate
+cluck
+spike
+mimic
+pound
+maxim
+linen
+unmet
+flesh
+booby
+forth
+first
+stand
+belly
+ivory
+seedy
+print
+yearn
+drain
+bribe
+stout
+panel
+crass
+flume
+offal
+agree
+error
+swirl
+argue
+bleed
+delta
+flick
+totem
+wooer
+front
+shrub
+parry
+biome
+lapel
+start
+greet
+goner
+golem
+lusty
+loopy
+round
+audit
+lying
+gamma
+labor
+islet
+civic
+forge
+corny
+moult
+basic
+salad
+agate
+spicy
+spray
+essay
+fjord
+spend
+kebab
+guild
+aback
+motor
+alone
+hatch
+hyper
+thumb
+dowry
+ought
+belch
+dutch
+pilot
+tweed
+comet
+jaunt
+enema
+steed
+abyss
+growl
+fling
+dozen
+boozy
+erode
+world
+gouge
+click
+briar
+great
+altar
+pulpy
+blurt
+coast
+duchy
+groin
+fixer
+group
+rogue
+badly
+smart
+pithy
+gaudy
+chill
+heron
+vodka
+finer
+surer
+radio
+rouge
+perch
+retch
+wrote
+clock
+tilde
+store
+prove
+bring
+solve
+cheat
+grime
+exult
+usher
+epoch
+triad
+break
+rhino
+viral
+conic
+masse
+sonic
+vital
+trace
+using
+peach
+champ
+baton
+brake
+pluck
+craze
+gripe
+weary
+picky
+acute
+ferry
+aside
+tapir
+troll
+unify
+rebus
+boost
+truss
+siege
+tiger
+banal
+slump
+crank
+gorge
+query
+drink
+favor
+abbey
+tangy
+panic
+solar
+shire
+proxy
+point
+robot
+prick
+wince
+crimp
+knoll
+sugar
+whack
+mount
+perky
+could
+wrung
+light
+those
+moist
+shard
+pleat
+aloft
+skill
+elder
+frame
+humor
+pause
+ulcer
+ultra
+robin
+cynic
+aroma
+caulk
+shake
+dodge
+swill
+tacit
+other
+thorn
+trove
+bloke
+vivid
+spill
+chant
+choke
+rupee
+nasty
+mourn
+ahead
+brine
+cloth
+hoard
+sweet
+month
+lapse
+watch
+today
+focus
+smelt
+tease
+cater
+movie
+saute
+allow
+renew
+their
+slosh
+purge
+chest
+depot
+epoxy
+nymph
+found
+shall
+harry
+stove
+lowly
+snout
+trope
+fewer
+shawl
+natal
+comma
+foray
+scare
+stair
+black
+squad
+royal
+chunk
+mince
+shame
+cheek
+ample
+flair
+foyer
+cargo
+oxide
+plant
+olive
+inert
+askew
+heist
+shown
+zesty
+hasty
+trash
+fella
+larva
+forgo
+story
+hairy
+train
+homer
+badge
+midst
+canny
+fetus
+butch
+farce
+slung
+tipsy
+metal
+yield
+delve
+being
+scour
+glass
+gamer
+scrap
+money
+hinge
+album
+vouch
+asset
+tiara
+crept
+bayou
+atoll
+manor
+creak
+showy
+phase
+froth
+depth
+gloom
+flood
+trait
+girth
+piety
+payer
+goose
+float
+donor
+atone
+primo
+apron
+blown
+cacao
+loser
+input
+gloat
+awful
+brink
+smite
+beady
+rusty
+retro
+droll
+gawky
+hutch
+pinto
+gaily
+egret
+lilac
+sever
+field
+fluff
+hydro
+flack
+agape
+voice
+stead
+stalk
+berth
+madam
+night
+bland
+liver
+wedge
+augur
+roomy
+wacky
+flock
+angry
+bobby
+trite
+aphid
+tryst
+midge
+power
+elope
+cinch
+motto
+stomp
+upset
+bluff
+cramp
+quart
+coyly
+youth
+rhyme
+buggy
+alien
+smear
+unfit
+patty
+cling
+glean
+label
+hunky
+khaki
+poker
+gruel
+twice
+twang
+shrug
+treat
+unlit
+waste
+merit
+woven
+octal
+needy
+clown
+widow
+irony
+ruder
+gauze
+chief
+onset
+prize
+fungi
+charm
+gully
+inter
+whoop
+taunt
+leery
+class
+theme
+lofty
+tibia
+booze
+alpha
+thyme
+eclat
+doubt
+parer
+chute
+stick
+trice
+alike
+sooth
+recap
+saint
+liege
+glory
+grate
+admit
+brisk
+soggy
+usurp
+scald
+scorn
+leave
+twine
+sting
+bough
+marsh
+sloth
+dandy
+vigor
+howdy
+enjoy
+valid
+ionic
+equal
+unset
+floor
+catch
+spade
+stein
+exist
+quirk
+denim
+grove
+spiel
+mummy
+fault
+foggy
+flout
+carry
+sneak
+libel
+waltz
+aptly
+piney
+inept
+aloud
+photo
+dream
+stale
+vomit
+ombre
+fanny
+unite
+snarl
+baker
+there
+glyph
+pooch
+hippy
+spell
+folly
+louse
+gulch
+vault
+godly
+threw
+fleet
+grave
+inane
+shock
+crave
+spite
+valve
+skimp
+claim
+rainy
+musty
+pique
+daddy
+quasi
+arise
+aging
+valet
+opium
+avert
+stuck
+recut
+mulch
+genre
+plume
+rifle
+count
+incur
+total
+wrest
+mocha
+deter
+study
+lover
+safer
+rivet
+funny
+smoke
+mound
+undue
+sedan
+pagan
+swine
+guile
+gusty
+equip
+tough
+canoe
+chaos
+covet
+human
+udder
+lunch
+blast
+stray
+manga
+melee
+lefty
+quick
+paste
+given
+octet
+risen
+groan
+leaky
+grind
+carve
+loose
+sadly
+spilt
+apple
+slack
+honey
+final
+sheen
+eerie
+minty
+slick
+derby
+wharf
+spelt
+coach
+erupt
+singe
+price
+spawn
+fairy
+jiffy
+filmy
+stack
+chose
+sleep
+ardor
+nanny
+niece
+woozy
+handy
+grace
+ditto
+stank
+cream
+usual
+diode
+valor
+angle
+ninja
+muddy
+chase
+reply
+prone
+spoil
+heart
+shade
+diner
+arson
+onion
+sleet
+dowel
+couch
+palsy
+bowel
+smile
+evoke
+creek
+lance
+eagle
+idiot
+siren
+built
+embed
+award
+dross
+annul
+goody
+frown
+patio
+laden
+humid
+elite
+lymph
+edify
+might
+reset
+visit
+gusto
+purse
+vapor
+crock
+write
+sunny
+loath
+chaff
+slide
+queer
+venom
+stamp
+sorry
+still
+acorn
+aping
+pushy
+tamer
+hater
+mania
+awoke
+brawn
+swift
+exile
+birch
+lucky
+freer
+risky
+ghost
+plier
+lunar
+winch
+snare
+nurse
+house
+borax
+nicer
+lurch
+exalt
+about
+savvy
+toxin
+tunic
+pried
+inlay
+chump
+lanky
+cress
+eater
+elude
+cycle
+kitty
+boule
+moron
+tenet
+place
+lobby
+plush
+vigil
+index
+blink
+clung
+qualm
+croup
+clink
+juicy
+stage
+decay
+nerve
+flier
+shaft
+crook
+clean
+china
+ridge
+vowel
+gnome
+snuck
+icing
+spiny
+rigor
+snail
+flown
+rabid
+prose
+thank
+poppy
+budge
+fiber
+moldy
+dowdy
+kneel
+track
+caddy
+quell
+dumpy
+paler
+swore
+rebar
+scuba
+splat
+flyer
+horny
+mason
+doing
+ozone
+amply
+molar
+ovary
+beset
+queue
+cliff
+magic
+truce
+sport
+fritz
+edict
+twirl
+verse
+llama
+eaten
+range
+whisk
+hovel
+rehab
+macaw
+sigma
+spout
+verve
+sushi
+dying
+fetid
+brain
+buddy
+thump
+scion
+candy
+chord
+basin
+march
+crowd
+arbor
+gayly
+musky
+stain
+dally
+bless
+bravo
+stung
+title
+ruler
+kiosk
+blond
+ennui
+layer
+fluid
+tatty
+score
+cutie
+zebra
+barge
+matey
+bluer
+aider
+shook
+river
+privy
+betel
+frisk
+bongo
+begun
+azure
+weave
+genie
+sound
+glove
+braid
+scope
+wryly
+rover
+assay
+ocean
+bloom
+irate
+later
+woken
+silky
+wreck
+dwelt
+slate
+smack
+solid
+amaze
+hazel
+wrist
+jolly
+globe
+flint
+rouse
+civil
+vista
+relax
+cover
+alive
+beech
+jetty
+bliss
+vocal
+often
+dolly
+eight
+joker
+since
+event
+ensue
+shunt
+diver
+poser
+worst
+sweep
+alley
+creed
+anime
+leafy
+bosom
+dunce
+stare
+pudgy
+waive
+choir
+stood
+spoke
+outgo
+delay
+bilge
+ideal
+clasp
+seize
+hotly
+laugh
+sieve
+block
+meant
+grape
+noose
+hardy
+shied
+drawl
+daisy
+putty
+strut
+burnt
+tulip
+crick
+idyll
+vixen
+furor
+geeky
+cough
+naive
+shoal
+stork
+bathe
+aunty
+check
+prime
+brass
+outer
+furry
+razor
+elect
+evict
+imply
+demur
+quota
+haven
+cavil
+swear
+crump
+dough
+gavel
+wagon
+salon
+nudge
+harem
+pitch
+sworn
+pupil
+excel
+stony
+cabin
+unzip
+queen
+trout
+polyp
+earth
+storm
+until
+taper
+enter
+child
+adopt
+minor
+fatty
+husky
+brave
+filet
+slime
+glint
+tread
+steal
+regal
+guest
+every
+murky
+share
+spore
+hoist
+buxom
+inner
+otter
+dimly
+level
+sumac
+donut
+stilt
+arena
+sheet
+scrub
+fancy
+slimy
+pearl
+silly
+porch
+dingo
+sepia
+amble
+shady
+bread
+friar
+reign
+dairy
+quill
+cross
+brood
+tuber
+shear
+posit
+blank
+villa
+shank
+piggy
+freak
+which
+among
+fecal
+shell
+would
+algae
+large
+rabbi
+agony
+amuse
+bushy
+copse
+swoon
+knife
+pouch
+ascot
+plane
+crown
+urban
+snide
+relay
+abide
+viola
+rajah
+straw
+dilly
+crash
+amass
+third
+trick
+tutor
+woody
+blurb
+grief
+disco
+where
+sassy
+beach
+sauna
+comic
+clued
+creep
+caste
+graze
+snuff
+frock
+gonad
+drunk
+prong
+lurid
+steel
+halve
+buyer
+vinyl
+utile
+smell
+adage
+worry
+tasty
+local
+trade
+finch
+ashen
+modal
+gaunt
+clove
+enact
+adorn
+roast
+speck
+sheik
+missy
+grunt
+snoop
+party
+touch
+mafia
+emcee
+array
+south
+vapid
+jelly
+skulk
+angst
+tubal
+lower
+crest
+sweat
+cyber
+adore
+tardy
+swami
+notch
+groom
+roach
+hitch
+young
+align
+ready
+frond
+strap
+puree
+realm
+venue
+swarm
+offer
+seven
+dryer
+diary
+dryly
+drank
+acrid
+heady
+theta
+junto
+pixie
+quoth
+bonus
+shalt
+penne
+amend
+datum
+build
+piano
+shelf
+lodge
+suing
+rearm
+coral
+ramen
+worth
+psalm
+infer
+overt
+mayor
+ovoid
+glide
+usage
+poise
+randy
+chuck
+prank
+fishy
+tooth
+ether
+drove
+idler
+swath
+stint
+while
+begat
+apply
+slang
+tarot
+radar
+credo
+aware
+canon
+shift
+timer
+bylaw
+serum
+three
+steak
+iliac
+shirk
+blunt
+puppy
+penal
+joist
+bunny
+shape
+beget
+wheel
+adept
+stunt
+stole
+topaz
+chore
+fluke
+afoot
+bloat
+bully
+dense
+caper
+sneer
+boxer
+jumbo
+lunge
+space
+avail
+short
+slurp
+loyal
+flirt
+pizza
+conch
+tempo
+droop
+plate
+bible
+plunk
+afoul
+savoy
+steep
+agile
+stake
+dwell
+knave
+beard
+arose
+motif
+smash
+broil
+glare
+shove
+baggy
+mammy
+swamp
+along
+rugby
+wager
+quack
+squat
+snaky
+debit
+mange
+skate
+ninth
+joust
+tramp
+spurn
+medal
+micro
+rebel
+flank
+learn
+nadir
+maple
+comfy
+remit
+gruff
+ester
+least
+mogul
+fetch
+cause
+oaken
+aglow
+meaty
+gaffe
+shyly
+racer
+prowl
+thief
+stern
+poesy
+rocky
+tweet
+waist
+spire
+grope
+havoc
+patsy
+truly
+forty
+deity
+uncle
+swish
+giver
+preen
+bevel
+lemur
+draft
+slope
+annoy
+lingo
+bleak
+ditty
+curly
+cedar
+dirge
+grown
+horde
+drool
+shuck
+crypt
+cumin
+stock
+gravy
+locus
+wider
+breed
+quite
+chafe
+cache
+blimp
+deign
+fiend
+logic
+cheap
+elide
+rigid
+false
+renal
+pence
+rowdy
+shoot
+blaze
+envoy
+posse
+brief
+never
+abort
+mouse
+mucky
+sulky
+fiery
+media
+trunk
+yeast
+clear
+skunk
+scalp
+bitty
+cider
+koala
+duvet
+segue
+creme
+super
+grill
+after
+owner
+ember
+reach
+nobly
+empty
+speed
+gipsy
+recur
+smock
+dread
+merge
+burst
+kappa
+amity
+shaky
+hover
+carol
+snort
+synod
+faint
+haunt
+flour
+chair
+detox
+shrew
+tense
+plied
+quark
+burly
+novel
+waxen
+stoic
+jerky
+blitz
+beefy
+lyric
+hussy
+towel
+quilt
+below
+bingo
+wispy
+brash
+scone
+toast
+easel
+saucy
+value
+spice
+honor
+route
+sharp
+bawdy
+radii
+skull
+phony
+issue
+lager
+swell
+urine
+gassy
+trial
+flora
+upper
+latch
+wight
+brick
+retry
+holly
+decal
+grass
+shack
+dogma
+mover
+defer
+sober
+optic
+crier
+vying
+nomad
+flute
+hippo
+shark
+drier
+obese
+bugle
+tawny
+chalk
+feast
+ruddy
+pedal
+scarf
+cruel
+bleat
+tidal
+slush
+semen
+windy
+dusty
+sally
+igloo
+nerdy
+jewel
+shone
+whale
+hymen
+abuse
+fugue
+elbow
+crumb
+pansy
+welsh
+syrup
+terse
+suave
+gamut
+swung
+drake
+freed
+afire
+shirt
+grout
+oddly
+tithe
+plaid
+dummy
+broom
+blind
+torch
+enemy
+again
+tying
+pesky
+alter
+gazer
+noble
+ethos
+bride
+extol
+decor
+hobby
+beast
+idiom
+utter
+these
+sixth
+alarm
+erase
+elegy
+spunk
+piper
+scaly
+scold
+hefty
+chick
+sooty
+canal
+whiny
+slash
+quake
+joint
+swept
+prude
+heavy
+wield
+femme
+lasso
+maize
+shale
+screw
+spree
+smoky
+whiff
+scent
+glade
+spent
+prism
+stoke
+riper
+orbit
+cocoa
+guilt
+humus
+shush
+table
+smirk
+wrong
+noisy
+alert
+shiny
+elate
+resin
+whole
+hunch
+pixel
+polar
+hotel
+sword
+cleat
+mango
+rumba
+puffy
+filly
+billy
+leash
+clout
+dance
+ovate
+facet
+chili
+paint
+liner
+curio
+salty
+audio
+snake
+fable
+cloak
+navel
+spurt
+pesto
+balmy
+flash
+unwed
+early
+churn
+weedy
+stump
+lease
+witty
+wimpy
+spoof
+saner
+blend
+salsa
+thick
+warty
+manic
+blare
+squib
+spoon
+probe
+crepe
+knack
+force
+debut
+order
+haste
+teeth
+agent
+widen
+icily
+slice
+ingot
+clash
+juror
+blood
+abode
+throw
+unity
+pivot
+slept
+troop
+spare
+sewer
+parse
+morph
+cacti
+tacky
+spool
+demon
+moody
+annex
+begin
+fuzzy
+patch
+water
+lumpy
+admin
+omega
+limit
+tabby
+macho
+aisle
+skiff
+basis
+plank
+verge
+botch
+crawl
+lousy
+slain
+cubic
+raise
+wrack
+guide
+foist
+cameo
+under
+actor
+revue
+fraud
+harpy
+scoop
+climb
+refer
+olden
+clerk
+debar
+tally
+ethic
+cairn
+tulle
+ghoul
+hilly
+crude
+apart
+scale
+older
+plain
+sperm
+briny
+abbot
+rerun
+quest
+crisp
+bound
+befit
+drawn
+suite
+itchy
+cheer
+bagel
+guess
+broad
+axiom
+chard
+caput
+leant
+harsh
+curse
+proud
+swing
+opine
+taste
+lupus
+gumbo
+miner
+green
+chasm
+lipid
+topic
+armor
+brush
+crane
+mural
+abled
+habit
+bossy
+maker
+dusky
+dizzy
+lithe
+brook
+jazzy
+fifty
+sense
+giant
+surly
+legal
+fatal
+flunk
+began
+prune
+small
+slant
+scoff
+torus
+ninny
+covey
+viper
+taken
+moral
+vogue
+owing
+token
+entry
+booth
+voter
+chide
+elfin
+ebony
+neigh
+minim
+melon
+kneed
+decoy
+voila
+ankle
+arrow
+mushy
+tribe
+cease
+eager
+birth
+graph
+odder
+terra
+weird
+tried
+clack
+color
+rough
+weigh
+uncut
+ladle
+strip
+craft
+minus
+dicey
+titan
+lucid
+vicar
+dress
+ditch
+gypsy
+pasta
+taffy
+flame
+swoop
+aloof
+sight
+broke
+teary
+chart
+sixty
+wordy
+sheer
+leper
+nosey
+bulge
+savor
+clamp
+funky
+foamy
+toxic
+brand
+plumb
+dingy
+butte
+drill
+tripe
+bicep
+tenor
+krill
+worse
+drama
+hyena
+think
+ratio
+cobra
+basil
+scrum
+bused
+phone
+court
+camel
+proof
+heard
+angel
+petal
+pouty
+throb
+maybe
+fetal
+sprig
+spine
+shout
+cadet
+macro
+dodgy
+satyr
+rarer
+binge
+trend
+nutty
+leapt
+amiss
+split
+myrrh
+width
+sonar
+tower
+baron
+fever
+waver
+spark
+belie
+sloop
+expel
+smote
+baler
+above
+north
+wafer
+scant
+frill
+awash
+snack
+scowl
+frail
+drift
+limbo
+fence
+motel
+ounce
+wreak
+revel
+talon
+prior
+knelt
+cello
+flake
+debug
+anode
+crime
+salve
+scout
+imbue
+pinky
+stave
+vague
+chock
+fight
+video
+stone
+teach
+cleft
+frost
+prawn
+booty
+twist
+apnea
+stiff
+plaza
+ledge
+tweak
+board
+grant
+medic
+bacon
+cable
+brawl
+slunk
+raspy
+forum
+drone
+women
+mucus
+boast
+toddy
+coven
+tumor
+truer
+wrath
+stall
+steam
+axial
+purer
+daily
+trail
+niche
+mealy
+juice
+nylon
+plump
+merry
+flail
+papal
+wheat
+berry
+cower
+erect
+brute
+leggy
+snipe
+sinew
+skier
+penny
+jumpy
+rally
+umbra
+scary
+modem
+gross
+avian
+greed
+satin
+tonic
+parka
+sniff
+livid
+stark
+trump
+giddy
+reuse
+taboo
+avoid
+quote
+devil
+liken
+gloss
+gayer
+beret
+noise
+gland
+dealt
+sling
+rumor
+opera
+thigh
+tonga
+flare
+wound
+white
+bulky
+etude
+horse
+circa
+paddy
+inbox
+fizzy
+grain
+exert
+surge
+gleam
+belle
+salvo
+crush
+fruit
+sappy
+taker
+tract
+ovine
+spiky
+frank
+reedy
+filth
+spasm
+heave
+mambo
+right
+clank
+trust
+lumen
+borne
+spook
+sauce
+amber
+lathe
+carat
+corer
+dirty
+slyly
+affix
+alloy
+taint
+sheep
+kinky
+wooly
+mauve
+flung
+yacht
+fried
+quail
+brunt
+grimy
+curvy
+cagey
+rinse
+deuce
+state
+grasp
+milky
+bison
+graft
+sandy
+baste
+flask
+hedge
+girly
+swash
+boney
+coupe
+endow
+abhor
+welch
+blade
+tight
+geese
+miser
+mirth
+cloud
+cabal
+leech
+close
+tenth
+pecan
+droit
+grail
+clone
+guise
+ralph
+tango
+biddy
+smith
+mower
+payee
+serif
+drape
+fifth
+spank
+glaze
+allot
+truck
+kayak
+virus
+testy
+tepee
+fully
+zonal
+metro
+curry
+grand
+banjo
+axion
+bezel
+occur
+chain
+nasal
+gooey
+filer
+brace
+allay
+pubic
+raven
+plead
+gnash
+flaky
+munch
+dully
+eking
+thing
+slink
+hurry
+theft
+shorn
+pygmy
+ranch
+wring
+lemon
+shore
+mamma
+froze
+newer
+style
+moose
+antic
+drown
+vegan
+chess
+guppy
+union
+lever
+lorry
+image
+cabby
+druid
+exact
+truth
+dopey
+spear
+cried
+chime
+crony
+stunk
+timid
+batch
+gauge
+rotor
+crack
+curve
+latte
+witch
+bunch
+repel
+anvil
+soapy
+meter
+broth
+madly
+dried
+scene
+known
+magma
+roost
+woman
+thong
+punch
+pasty
+downy
+knead
+whirl
+rapid
+clang
+anger
+drive
+goofy
+email
+music
+stuff
+bleep
+rider
+mecca
+folio
+setup
+verso
+quash
+fauna
+gummy
+happy
+newly
+fussy
+relic
+guava
+ratty
+fudge
+femur
+chirp
+forte
+alibi
+whine
+petty
+golly
+plait
+fleck
+felon
+gourd
+brown
+thrum
+ficus
+stash
+decry
+wiser
+junta
+visor
+daunt
+scree
+impel
+await
+press
+whose
+turbo
+stoop
+speak
+mangy
+eying
+inlet
+crone
+pulse
+mossy
+staid
+hence
+pinch
+teddy
+sully
+snore
+ripen
+snowy
+attic
+going
+leach
+mouth
+hound
+clump
+tonal
+bigot
+peril
+piece
+blame
+haute
+spied
+undid
+intro
+basal
+shine
+gecko
+rodeo
+guard
+steer
+loamy
+scamp
+scram
+manly
+hello
+vaunt
+organ
+feral
+knock
+extra
+condo
+adapt
+willy
+polka
+rayon
+skirt
+faith
+torso
+match
+mercy
+tepid
+sleek
+riser
+twixt
+peace
+flush
+catty
+login
+eject
+roger
+rival
+untie
+refit
+aorta
+adult
+judge
+rower
+artsy
+rural
+shave
diff --git a/absurdle/dictionary2.txt b/absurdle/dictionary2.txt
new file mode 100644
index 0000000..31bb410
--- /dev/null
+++ b/absurdle/dictionary2.txt
@@ -0,0 +1,9 @@
+ally
+betablocker
+cool
+dealer
+else
+flew
+dogood
+hope
+ibex
diff --git a/absurdle/dictionary3.txt b/absurdle/dictionary3.txt
new file mode 100644
index 0000000..a14bf9a
--- /dev/null
+++ b/absurdle/dictionary3.txt
@@ -0,0 +1,30 @@
+stews
+birds
+braid
+bends
+rates
+slabs
+abash
+frags
+rares
+drags
+garbs
+stair
+steer
+trail
+great
+crane
+slate
+stink
+frier
+yacht
+carts
+craft
+hobby
+lobby
+train
+break
+treat
+skunk
+drank
+bunny
diff --git a/absurdle/small_dict.txt b/absurdle/small_dict.txt
new file mode 100644
index 0000000..32e2fed
--- /dev/null
+++ b/absurdle/small_dict.txt
@@ -0,0 +1,9 @@
+rgrasfally
+beta
+cool
+deal
+else
+flew
+good
+hope
+ibex
diff --git a/helloworld.java b/helloworld.java
new file mode 100644
index 0000000..f9f58c0
--- /dev/null
+++ b/helloworld.java
@@ -0,0 +1,8 @@
+// package src;
+// import src.printer;
+
+public class helloworld {
+    public static void main(String[] args) {
+        System.out.println("hellow");
+    }
+}
\ No newline at end of file
diff --git a/linter/BlankPrintlnCheck.java b/linter/BlankPrintlnCheck.java
new file mode 100644
index 0000000..dfb4f22
--- /dev/null
+++ b/linter/BlankPrintlnCheck.java
@@ -0,0 +1,19 @@
+// Nik Johnson
+// 2-24-2024
+// TA: Andy Ruan
+
+import java.util.*;
+
+// checks lines for the characters "System.out.println("")"
+public class BlankPrintlnCheck implements Check {
+
+    // if the line being checked has a blank println statement, return a new error (code 3)
+    // takes line and line number
+    // returns error inside optional 
+    public Optional<Error> lint(String line, int lineNumber) {
+        if (line.contains("System.out.println(\"\")")) {
+            return Optional.of(new Error(3, lineNumber, "Line contains blank print statement"));
+        }
+        return Optional.empty();
+    }
+}
diff --git a/linter/BreakCheck.java b/linter/BreakCheck.java
new file mode 100644
index 0000000..0007fe3
--- /dev/null
+++ b/linter/BreakCheck.java
@@ -0,0 +1,23 @@
+// Nik Johnson
+// 2-24-2024
+// TA: Andy Ruan
+
+import java.util.*;
+
+// checks Strings for the characters "break" that come BEFORE the characters "//"
+public class BreakCheck implements Check {
+    
+    // if the line being checked has "break" in it 
+    // after removing all single line comments, return a new error (code 2)
+    // takes line and line number
+    // returns error inside optional
+    public Optional<Error> lint(String line, int lineNumber) {
+        String input = line;
+        String output = input.replaceAll("//.*", "");
+
+        if (output.contains("break")) {
+            return Optional.of(new Error(2, lineNumber, "we cant use break in this class bro"));
+        }
+        return Optional.empty();
+    }
+}
diff --git a/linter/Check.java b/linter/Check.java
new file mode 100644
index 0000000..2b3bca5
--- /dev/null
+++ b/linter/Check.java
@@ -0,0 +1,11 @@
+import java.util.*;
+
+// A common interface for linters that can check a single line of code
+// Every Check will check for its own type of error on a single line of code.
+public interface Check {
+	// Checks for this Check's error condition on this line with this line number.
+	// If an error exists on this line, returns an Optional with an Error present 
+	// indicating an error occurred. If no errors are present, returns an empty Optional.
+	public Optional<Error> lint(String line, int lineNumber);
+}
+
diff --git a/linter/Error.java b/linter/Error.java
new file mode 100644
index 0000000..da4a051
--- /dev/null
+++ b/linter/Error.java
@@ -0,0 +1,43 @@
+// Nik Johnson
+// 2-24-2024
+// TA: Andy Ruan
+
+/*
+Defining an object called Error, which has the fields:
+code: the errors code, represented by an int
+lineNumber: the line where the error occurred
+message: a description of the error
+*/
+public class Error {
+
+	private int code;
+	private int lineNumber;
+	private String message;
+
+	// construct an error with its fields
+	public Error(int code, int lineNumber, String message) {
+		this.code = code;
+		this.lineNumber = lineNumber;
+		this.message = message;
+	}
+
+	// format an error and its information nicely
+	public String toString() {
+		return ("(Line: " + lineNumber + ") " + "has error code " + code + "\n" + message);
+	}
+
+	// return line where the error occurs
+	public int getLineNumber() {
+		return this.lineNumber;
+	}
+
+	// return the error code (a number)
+	public int getCode() {
+		return this.code;
+	}
+
+	// return the errors description
+	public String getMessage() {
+		return this.message;
+	}
+}
diff --git a/linter/Linter.java b/linter/Linter.java
new file mode 100644
index 0000000..e30a8c3
--- /dev/null
+++ b/linter/Linter.java
@@ -0,0 +1,39 @@
+// Nik Johnson
+// 2-24-2024
+// TA: Andy Ruan
+
+import java.util.*;
+import java.io.*;
+
+// file-based linting object, linting based on checks defined in a list
+public class Linter {
+
+    private List<Check> checks;
+
+    // constructor, takes list of checks to perform
+    public Linter(List<Check> checks) {
+        this.checks = checks;
+    }
+
+    // compile list of errors based on output of check classes
+    // takes filename to perform checks on
+    // return list of errors present in that file
+    public List<Error> lint(String fileName) throws FileNotFoundException {
+        File toBeChecked = new File(fileName);
+        Scanner fileScanner = new Scanner(toBeChecked);
+        List<Error> errors = new ArrayList<>();
+        int lineNumber = 1;
+        while (fileScanner.hasNext()) {
+            String line = fileScanner.nextLine();
+            for (Check check : checks) {
+                Optional<Error> error = check.lint(line, lineNumber);
+                if (error.isPresent()) {
+                    errors.add(error.get());
+                }
+            }
+            lineNumber++;
+        }
+        fileScanner.close();
+        return errors;
+    }
+}
diff --git a/linter/LinterMain.java b/linter/LinterMain.java
new file mode 100644
index 0000000..97fb2b8
--- /dev/null
+++ b/linter/LinterMain.java
@@ -0,0 +1,22 @@
+// Nik Johnson
+// 2-24-2024
+// TA: Andy Ruan
+
+import java.util.*;
+import java.io.*;
+
+public class LinterMain {
+    public static final String FILE_NAME = "TestFile.txt";
+
+    public static void main(String[] args) throws FileNotFoundException {
+        List<Check> checks = new ArrayList<>();
+        checks.add(new LongLineCheck());
+        checks.add(new BreakCheck());
+        checks.add(new BlankPrintlnCheck());
+        Linter linter = new Linter(checks);
+        List<Error> errors = linter.lint(FILE_NAME);
+        for (Error e : errors) {
+            System.out.println(e);
+        }
+    }
+}
diff --git a/linter/LongLineCheck.java b/linter/LongLineCheck.java
new file mode 100644
index 0000000..d5d4368
--- /dev/null
+++ b/linter/LongLineCheck.java
@@ -0,0 +1,21 @@
+// Nik Johnson
+// 2-24-2024
+// TA: Andy Ruan
+
+import java.util.*;
+
+// long line checker
+public class LongLineCheck implements Check {
+
+    // if the line being checked is 100 characters or longer, return a new error (code 1)
+    // takes line and line number
+    // returns error inside optional
+    public Optional<Error> lint(String line, int lineNumber) {
+        if (line.length() >= 100) {
+            return Optional.of(new Error(1, lineNumber, 
+            "Line length exceeded maximum length of 100 characters"));
+        }
+
+        return Optional.empty();
+    }
+}
diff --git a/linter/TestFile.java b/linter/TestFile.java
new file mode 100644
index 0000000..ebdff55
--- /dev/null
+++ b/linter/TestFile.java
@@ -0,0 +1,10 @@
+public class TestFile {
+    public static void main(String[] args) {
+        System.out.println("This is a really really really long line that should fail the long line check");
+        while (true) {
+            System.out.println("");
+            break;
+        }
+        // break
+    }
+}
diff --git a/linter/TestFile.txt b/linter/TestFile.txt
new file mode 100644
index 0000000..76a8979
--- /dev/null
+++ b/linter/TestFile.txt
@@ -0,0 +1,89 @@
+package com.example;
+
+public class Example {
+    public static void main(String[] args) {
+        int x = 5;
+        while (x < 10) {
+            System.out.println("Hello, world!");
+            break;
+        }
+        for (int i = 0; i < 10; i++) {
+            if (i % 2 == 0) {
+                continue;
+            } else {
+                System.out.println(i);
+            }
+        }
+        try {
+            throw new Exception("Test");
+        } catch (Exception e) {
+            System.out.println("Caught an exception: " + e.getMessage());
+        } finally {
+            System.out.println("Finally block executed.");
+        }
+        for (int j = 0; j < 100; j++) {
+            if (j % 2 == 0) {
+                break;
+            } else {
+                System.out.println(j);
+            }
+        }
+        while (x > 5) {
+            System.out.println("Hello, world!");
+            break;
+        }
+        if (x % 2 == 0) {
+            continue;
+        } else {
+            System.out.println(x);
+        }
+        for (int k = 0; k < 1000; k++) {
+            if (k % 2 == 0) {
+                break;
+            } else {
+                System.out.println(k);
+            }
+        }
+        while (x > 5) {
+            System.out.println("Hello, world!");
+            break;
+        }
+        if (x % 2 == 0) {
+            continue;
+        } else {
+            System.out.println(x);
+        }
+        for (int l = 0; l < 10000; l++) {
+            if (l % 2 == 0) {
+                break;
+            } else {
+                System.out.println(l);
+            }
+        }
+        while (x > 5) {
+            System.out.println("Hello, world!");
+            break;
+        }
+        if (x % 2 == 0) {
+            continue;
+        } else {
+            System.out.println(x);
+        }
+        for (int m = 0; m < 100000; m++) {
+            if (m % 2 == 0) {
+                break;
+            } else {
+                System.out.println(m);
+            }
+        }
+        while (x > 5) {
+            System.out.println("Hello, world!");
+            break;
+        }
+        if (x % 2 == 0) {
+            continue;
+        } else {
+            System.out.println(x);
+        }
+    }
+}
diff --git a/printer.java b/printer.java
new file mode 100644
index 0000000..9392884
--- /dev/null
+++ b/printer.java
@@ -0,0 +1,7 @@
+public class printer {
+    public static void main(String[] args) {
+        System.out.println("hellow");
+        System.out.println("hello");
+        System.out.println("helw");
+    }
+}
\ No newline at end of file
diff --git a/stonks.tsv b/stonks.tsv
new file mode 100644
index 0000000..16256ca
--- /dev/null
+++ b/stonks.tsv
@@ -0,0 +1,7 @@
+5
+Symbol Price P/E Ratio Dividend Yield
+AAPL 150.2 30.0 1.5%
+COST 673.58 45.8 1.5% 
+GOOGL 2750.50 35.0 0.8%
+MSFT 310.75 28.5 1.2%
+AMZN 3400.25 40.0 0.5%
diff --git a/variables.java b/variables.java
new file mode 100644
index 0000000..5c1803c
--- /dev/null
+++ b/variables.java
@@ -0,0 +1,10 @@
+public class variables {
+    public static void main(String[] args) {
+        int x = 8;
+        int xy = 16;
+        int y = 32;
+        System.out.println((x+3)*200);
+        System.out.println(xy);
+        System.out.println(y);
+    }
+}
\ No newline at end of file
diff --git a/wordcount.java b/wordcount.java
new file mode 100644
index 0000000..8aba15d
--- /dev/null
+++ b/wordcount.java
@@ -0,0 +1,18 @@
+import java.util.*;
+import java.io.*;
+    
+public class wordcount {
+    public static void main(String[] args) throws FileNotFoundException {
+        File input = new File(args[0]);
+        Scanner fileScanner = new Scanner(input);
+
+        int count = 0;
+        while (fileScanner.hasNext()) {
+            String nextToken = fileScanner.next();
+            count++;
+        }
+
+        fileScanner.close();
+        System.out.println(count);
+    }
+}