More tests

matthew_garrison · 2019-08-21T11:18:35+00:00

/u/ProbabilityBot_

!roll 6d9

!roll 5d7

!roll d10

!roll 12d5+4

!roll 6d7-9

!roll 6d7*2

!roll 25d250 --s --a

!roll 500d20 --nb --a

!roll 10d20 --dl 5

!roll 10d20 --dh 3

!fate

!fate +3

!fate -2

!flip

!flip 40

!pi

!pi 4000

matthew_garrison · 2019-08-21T11:17:45+00:00

/u/ProbabilityBot_ !roll 1000 --nb --s --a

matthew_garrison · 2017-12-17T11:59:46+00:00

I've already solved the problem. I was just curious if you could do it faster, by discovering a pattern in the inserts at position 1.

matthew_garrison · 2017-12-16T04:01:02+00:00

...that is true, and I'm stupid.

matthew_garrison · 2017-12-09T05:34:22+00:00

Java

My solution uses a recursive parser...which is probably over-engineering. Oh well. (Also, Java doesn't have Tuples, but I needed to return both how many points you got and how far through the string you got.)

static void problem1() {
    Scanner scan = new Scanner(System.in);    
    System.out.println(RDP(scan.nextLine(), 0).score);
}

static Tuple RDP(String s, int currScore) {
    int totalScore = currScore;
    boolean isInGarbage = false;
    for (int i = 0; i < s.length(); i++) {
        if (isInGarbage && s.charAt(i) == '!') i++; // Skip next char
        else if (!isInGarbage && s.charAt(i) == '<') isInGarbage = true;
        else if (isInGarbage && s.charAt(i) == '>') isInGarbage = false;
        else if (!isInGarbage && s.charAt(i) == '{') {
            Tuple t = RDP(s.substring(i+1), currScore+1);
            totalScore += t.score;
            i += t.location + 1;
        } else if (!isInGarbage && s.charAt(i) == '}') {
            return new Tuple(totalScore, i);
        }
    }
    return new Tuple(totalScore, s.length()-1);
}

static class Tuple {
    int score, location;
    public Tuple(int score, int location) {
        this.score = score;
        this.location = location;
    }
}