How can I automate the hacking minigame?

Use the bracket trick to remove false entries and to refresh your guess attempts.

http://www.gamershell.com/faqs/fallout3hackingguide/1.0/

[II.7] The Bracket Trick

Hidden in the code block you may be able to find what I like to refer to as a "Bracket Trick." A Bracket Trick is a collection of those random punctuation marks that appear between the words that are encased in a bracket of any kind. In the code block above, there is one hidden in there.

The second column of the Code Block and the third row contains this line:

0xFA10 %'%{.@@}#?|+

The Bracket trick in this line is:

{.@@}

Every terminal has a chance to produce bracket tricks, but not every terminal will have one. Some may even have multiple tricks. To tell if you have found a Bracket Trick all you have to do is hover the cursor over the opening bracket. If the entire thing lights up, congratulations, you found it!

A Bracket trick can be between a few different types of brackets:

<___> [____] {____} (____)

Any of these can be any size possible in the scope of the code block and they can be across many lines.

A Bracket Trick will never contain a possible password.

I have found that the best way to search a code block for tricks is to just move the cursor over every character and if something that is not a word lights up, you found one.

Now that you know what they look like and how to find them easily you probably want to know why you want these.

These have a random chance when clicked to either give you another attempt or remove a possibility from the Code Block.

The best time to use one is when you have 3 attempts remaining so you don't try using the word it removes from the block before it does it.

I should mention that the guide linked/cited is for Fallout 3, but the trick is still available in Fallout: New Vegas.

I have already automated this for you. My solver is available at: http://moria.us/fallout3/terminal.html

Note: this is a single-page application, so you can just save the solver to your hard drive as an HTML file and run it from there.

Tutorial

Let's suppose you find the words RAMBO, DUMBO, MAMBA, BRICK, TANKS. Go ahead and enter those into the solver.

[del] RAMBO -0- -1- -2- -3- -4- 3 moves
[del] DUMBO -0- -1- -2- -3- -4- 3 moves
[del] MAMBA -0- -1- -2- -3- -4- 2 moves
[del] BRICK -0- -1- -2- -3- -4- 3 moves
[del] TANKS -0- -1- -2- -3- -4- 3 moves

You can see in the right column some of the words are marked as "2 moves" and some of the words are marked as "3 moves". This column is a little tricky to explain, but this shows the maximum number of required moves necessary to solve the puzzle under the following conditions:

1. You select that word next, and

2. You play perfectly afterwards.

So you can see that if you select MAMBA, you will need to guess at most two words in order to find the correct word.

Suppose you select MAMBA, and you have 2 positions correct. Click on the -2- next to MAMBA:

[del] RAMBO -0- -1- -2- -3- -4-
[del] DUMBO -0- -1- -2- -3- -4- 1 moves
[del] MAMBA -0- -1- [2] -3- -4-
[del] BRICK -0- -1- -2- -3- -4-
[del] TANKS -0- -1- -2- -3- -4-

The word must be DUMBO (which is the second move).

During a playthrough of Fallout 3, I noticed that a large number of terminals mostly had "5 move" words with maybe one or two "4 move" words. This means that using the tool, you can play perfectly and beat those terminals every single time... but without the tool, I would abort after three failed guesses.

All you need to do is click a word with a low number of moves.

More information

You can see why MAMBA is the best by clicking on all of the numbers next to MAMBA. No matter what you click, only one other word will be left (or zero).

If you pick a different word, like RAMBO, you might still be left with two choices afterwards. For example, if you choose RAMBO but have 3 positions left, you get:

[del] RAMBO -0- -1- -2- [3] -4-
[del] DUMBO -0- -1- -2- -3- -4- 2 moves
[del] MAMBA -0- -1- -2- -3- -4- 2 moves
[del] BRICK -0- -1- -2- -3- -4-
[del] TANKS -0- -1- -2- -3- -4-

How it works

"View Source" works fine, it's all JavaScript. If I recall correctly, it recursively calculates the maximum number of moves necessary by examining situations like "what if you choose DUMBO and you have 3 correct". The maxmoves() function is where it's at.

If you have a copy of Python 3 lying around, you can do this in a jiffy.

First off, transcribe the passwords in an array like this. (Don't type in the >>> characters.)

>>> passwords = ["hideout", "flowing", "blanket", "dealing", "banning", "leaving",
                 "studies", "fencing", "battles", "chamber", "parties", "carrier",
                 "blazing", "various", "working", "beating", "mention", "wanting"]

We can make a sanity check and make sure all passwords are long the same:

>>> list(map(len, passwords))
[7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7]

Now we need to see how many letters are the same between any two passwords. It's a one-liner:

>>> def distance(a,b):
      return sum(1 for al, bl in zip(a,b) if al == bl) if a != b else -1

If the passwords are actually the same we return -1 instead of 7 so we can ignore those cases.

Now we need the code to only pick the passwords that have as many matching characters as the game tells us. This is another one-liner. You give it the list of passwords, what you tried and didn't work and how many characters were right.

>>> def refine(candidates, wrong_pw, matches):
      result = list(x for x in candidates if distance(x, wrong_pw) == matches)
      return result

So let's say you tied the password "flowing" and got 1 character right. Ouch. You then use what we've defined like this:

>>> passwords = refine(passwords, "flowing", 1); passwords
['blanket', 'studies', 'parties', 'carrier', 'mention']

Okay, how about "studies"... nope, 3 correct letters.

>>> passwords = refine(passwords, "studies", 3); passwords
['parties']

Oh look, that must be the password!

---

So, how do we automize the choice of passwords from a pool? What we can do is look at each option and see, in the worst case, how many passwords that leaves us with. We can then pick the one with the lowest amount of worst-case remaining options. That password is the one with the best guarantee of whittling down the field.

This code checks every password against every other password against every other password to find the best candidate.

def get_next_guess(passwords):
  scores = {}
  for candidate in passwords:
    results = []
    remainder = (x for x in passwords if x != candidate)
    for correct_pw in remainder:
      no_alternatives = len(refine(remainder, candidate,
                                   distance(candidate, correct_pw)))
      results.append(no_alternatives)
    scores[candidate] = max(results)
  return min(scores, key = lambda x: scores[x])

This guesses 'parties' immediately on my computer, which is kind of lucky because 'beating' would've been just as good of a guess. Let's instead look at the one in the screenshot, where the correct password was 'WAITING'.

>>> passwords = ["cleanse", "grouped", "gaining", "wasting", "dusters", "letting", "endings", "fertile", "seeking", "certain", "bandits", "stating", "wanting", "parties", "waiting", "station", "maltase", "monster"]
>>> get_next_guess(passwords)
'wanting'
>>> #incorrect, 6/7 correct
>>> passwords = refine(passwords, "wanting", 6); passwords
['wasting', 'waiting']

With two passwords left, get_next_guess becomes basically a die roll. Just try the first and then the second, and you're done in three tries, no restarts.

(Fun aside. You know the link Colin D shared with the list of 12-character passwords? The writer there picked APPRECIATION. That's actually the best guess! In that case, it leaves you with no more than two alternatives regardless of what the correct password actually is.)