Skip to content
The Chat Archive
gpt-4o-2024-05-13· OpenAI WildChat-4.8M (AI2)

The instructions for the coding test are as follows:" Votee would like to conduct the…

  1. User

    The instructions for the coding test are as follows:"

    Votee would like to conduct the coding test in a recorded live session. The idea is to connect to an API that plays a Wordle-like puzzle. You can find the API documentation at the following link: https://wordle.votee.dev:8000/redoc

    Developers are allowed to use any frameworks, IDEs, chatbots, LLMs, or other resources to write their program and showcase their skill set. However, if you take references from other open-source projects or tutorials, please ensure that proper credit is given. Plagiarism will not be tolerated, and it may affect the evaluation of your application.

    Your task is to write a program that automatically guesses random words against the API, using the following command as an example: curl -v ‘https://wordle.votee.dev:8000/random?guess=theft&seed=1234'" If I run curl -v ‘https://wordle.votee.dev:8000/random?guess=theft&seed=1234 in the terminal, the output: StatusCode : 200 StatusDescription : OK Content : [{"slot":0,"guess":"t","result":"correct"},{"slot":1,"guess":"h","result":"correct"},{"slot":2,"guess":"e","result":"correct"}, {"slot":3,"guess":"f","result":"correct"},{"slot":4,"guess":"t","result":... RawContent : HTTP/1.1 200 OK Content-Length: 211 Content-Type: application/json Date: Sun, 26 May 2024 08:27:33 GMT Server: uvicorn

                    [{"slot":0,"guess":"t","result":"correct"},{"slot":1,"guess":"h","result":...
    

    Forms : {} Headers : {[Content-Length, 211], [Content-Type, application/json], [Date, Sun, 26 May 2024 08:27:33 GMT], [Server, uvicorn]} Images : {} InputFields : {} Links : {} ParsedHtml : mshtml.HTMLDocumentClass RawContentLength : 211

    My Python program that guess the words: "import random import requests import json

    Load the word list from a file.

    with open("C:/Users/a/Desktop/wordle/valid-wordle-words.txt", 'r') as file: word_list = [line.strip() for line in file.readlines()] #print(len(word_list)) #- file.readlines(): #- Reads all the lines from the file and returns a list where each element is a line from the file, # including the newline character at the end of each line.

    #- line.strip():
    #- strip() is a string method that removes any leading and trailing whitespace
    # (including the newline character) from the string.
    

    API base URL

    base_url = 'https://wordle.votee.dev:8000/random'

    Function to make a guess by calling the API.

    def make_guess(guess, seed): # Make a GET request to the API with the guess and seed. response = requests.get(f"{base_url}?guess={guess}&seed={seed}") #F-strings are a feature in Python # that allows you to embed expressions inside string literals, using curly braces {} if response.status_code == 200: # Check if the response status code is 200 (OK) # Return the JSON response if the request was successful. return response.json() # Return the JSON response else: # Print an error message if the request failed. print("Failed to call the api.") return None # Return None if the request was not successful #print(make_guess('theft',1234))

    Function to filter the word list based on feedback

    def filter_word_list(word_list, feedback): new_word_list = word_list[:] # Create a copy of the current word list for feedback_item in feedback: # Iterate through each item in the feedback slot = feedback_item["slot"] # The position of the letter in the guessed word (get values of a dict) guess = feedback_item["guess"] # The guessed letter result = feedback_item["result"] # The result (‘correct’, ‘present’, ‘absent’)

        if result == "correct":
            # Keep words with the correct letter in the correct position
            # Iterate over each word in the original new_word_list
            # for word in new_word_list:
            #     # Check if the character at position ‘slot’ matches ‘guess’
            #     if word[slot] == guess:
            #         # If the condition is met, append the word to the filtered_word_list
            #         filtered_word_list.append(word)
            # # Assign the filtered list back to new_word_list
            # new_word_list = filtered_word_list
            new_word_list = [word for word in new_word_list if word[slot] == guess] # word is in new_word_list
        elif result == "present":
            # Keep words with the letter present but in a different position
            # for word in new_word_list:
            #     # Check if the guessed letter is in the word and is not at the ‘slot’ position
            #     if guess in word and word[slot] != guess:
            #         # If both conditions are met, append the word to the filtered_word_list
            #         filtered_word_list.append(word)
            #
            # # Assign the filtered list back to new_word_list
            # new_word_list = filtered_word_list
            new_word_list = [word for word in new_word_list if guess in word and word[slot] != guess]
        elif result == "absent":
            # Keep words without the absent letter
            new_word_list = [word for word in new_word_list if guess not in word]
    return new_word_list
    

    # Function to solve the puzzle

    def solve_puzzle(seed): attempts = 0 current_word_list = word_list # Start with the full word list print(f"Words remaining in the list: {len(current_word_list)}") # Print the number of words remaining

    while current_word_list:  # Continue as long as there are words to guess
        guess = current_word_list[0]  # Initially, guess the first word in the list
        print(f"Attempt {attempts + 1}: Guessing '{guess}'...") # Print the current attempt and guess
    
        # Make the guess by calling the API
        feedback = make_guess(guess, seed) # Get feedback for the guessed word
    
        # Check if the API call was successful and we received feedback
        if feedback:
            # Print the feedback for the current guess
            # print(f"Feedback: {json.dumps(feedback)}") # Print the feedback in a readable JSON format
            print(f"Feedback: {feedback}")
    
            # Check if all letters are correct
            if all(item['result'] == 'correct' for item in feedback):  # If all letters are marked as ‘correct’
                print(f"Solved with guess: {guess}") # Print the solved message
                return guess # Return the correct guess
    
            # Filter the word list based on the feedback
            current_word_list = filter_word_list(current_word_list, feedback)
    
            # Print the number of words left in the word list
            print(f"Words remaining in the list: {len(current_word_list)}") # Print the number of words remaining in the list
        else:
            print("Error: No feedback received.")
            return None
    
        attempts += 1 # Increment the number of attempts
    
        # Check if attempts exceeded 6 and print failure message if so
        if attempts >= 6:
            print("Failed to solve the puzzle within 6 attempts.")
    
    # else:
    #     # This part executes if while loop's condition becomes false (i.e., attempts >= 6)
    #     print("Failed to solve the puzzle.")
    #     return None  # Return None if the puzzle is not solved within 6 attempts
    

    Test with one random word

    seed = random.randint(0, 1000) # Generate a random seed print(f"seed:{seed}") solve_puzzle(seed) # Solve the puzzle using the random seed" Add a simple function(as simple as possible) to test with 10 word (from seed 0 to 9) and print the worst case(most number of attempt) and mean case (mean number of attempt).

  2. Assistant

    Certainly! I'll add a simple function to test the solve_puzzle function with 10 seeds (from 0 to 9) and print out the worst case (maximum number of attempts) and the mean case (average number of attempts).

    Here's the modified code with the new function integrated:

    import random
    import requests
    import json
    
    # Load the word list from a file.
    with open("C:/Users/a/Desktop/wordle/valid-wordle-words.txt", 'r') as file:
        word_list = [line.strip() for line in file.readlines()]
    
    # API base URL
    base_url = 'https://wordle.votee.dev:8000/random'
    
    # Function to make a guess by calling the API.
    def make_guess(guess, seed):
        response = requests.get(f"{base_url}?guess={guess}&seed={seed}")
        if response.status_code == 200:
            return response.json()
        else:
            print("Failed to call the API.")
            return None
    
    # Function to filter the word list based on feedback
    def filter_word_list(word_list, feedback):
        new_word_list = word_list[:]
        for feedback_item in feedback:
            slot = feedback_item["slot"]
            guess = feedback_item["guess"]
            result = feedback_item["result"]
    
            if result == "correct":
                new_word_list = [word for word in new_word_list if word[slot] == guess]
            elif result == "present":
                new_word_list = [word for word in new_word_list if guess in word and word[slot] != guess]
            elif result == "absent":
                new_word_list = [word for word in new_word_list if guess not in word]
        return new_word_list
    
    # Function to solve the puzzle
    def solve_puzzle(seed):
        attempts = 0
        current_word_list = word_list[:]
        print(f"Words remaining in the list: {len(current_word_list)}")
    
        while current_word_list:
            guess = current_word_list[0]
            print(f"Attempt {attempts + 1}: Guessing '{guess}'...")
    
            feedback = make_guess(guess, seed)
    
            if feedback:
                print(f"Feedback: {feedback}")
    
                if all(item['result'] == 'correct' for item in feedback):
                    print(f"Solved with guess: {guess}")
                    return attempts + 1
    
                current_word_list = filter_word_list(current_word_list, feedback)
                print(f"Words remaining in the list: {len(current_word_list)}")
            else:
                print("Error: No feedback received.")
                return None
    
            attempts += 1
    
            if attempts >= 6:
                print("Failed to solve the puzzle within 6 attempts.")
                return attempts
    
    # Function to test with 10 seeds and print worst and mean case
    def test_multiple_seeds():
        attempt_counts = []
    
        for seed in range(10):
            print(f"Testing seed: {seed}")
            attempts = solve_puzzle(seed)
            if attempts:
                attempt_counts.append(attempts)
    
        worst_case = max(attempt_counts)
        mean_case = sum(attempt_counts) / len(attempt_counts)
    
        print(f"Worst case (most attempts): {worst_case}")
        print(f"Mean case (average attempts): {mean_case}")
    
    # Run the test with 10 seeds
    test_multiple_seeds()
    

    This simple test function test_multiple_seeds() generates results for seeds ranging from 0 to 9 and then calculates and prints out the worst case (maximum number of attempts needed) and the mean case (average number of attempts).

    Feel free to run this complete code to test the functionality and evaluate the performance of the word-guessing algorithm against the provided API.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.