A0A0, 186 bytes + 5841 output = 6027
We're making use of the fact that the challenge doesn't require us to give a shortest length sequence, just a sequence. For a language like A0A0, any math operation more fancy than multiplication already gets annoying to implement, so no complicated stuff here. Instead we generate a sequence by first going up to one hundred (with the sequence
xxx-x-x-xx) and then just going down by one repeatedly until we hit the right number.
This penalizes us heavily in the output score, but it saves a lot of work in the actual code. (It does make for an even worse phone entry screen, though, so there's that.)
222-2-2-22. I chose a different character than
x (allowed per the challenge), since
x has an ascii value of 120, which is three characters, whereas
2 is only two characters (ascii value 50). You could technically do unprintable ascii values to get into the single digits, but in my opinion that is a bit against the spirit of the question. This is split across two columns, which gives the same amount of bytes as a single column, but two columns makes it easier to read on this site.
I0 A3 V0 G0 P45 S1 A0
G-1 A0 A0
A0 C3 G1 G1 G1 G1 G1 G1 G1 A0
A0 L100 S2 M6
A0 A1 G-3 G-3 G-3 G-3 G-3 G-3 G-3 A0
We now need to loop. We first take the input, so we can generate the right amount of dashes for the sequence. We then put this in the operand and append this operand, as well as the rest of the instructions into the loop below. This completes a loop that loops starting from the input until the value one hundred and prints a dash every single time. These are the actual instructions in the loop.
L100 S2 M6 V0 G0 P45 S1
L100 ; compare the operand to value one hundred, store result in operand
S2 ; add two to the operand
M6 ; multiple the operand by six
V0 ; the operand
G0 ; goto the offset of the operand
P45 ; print a dash
S1 ; add one to the operand
The jumping always jumps to either the loop below it, or to nothing which halts the program. The loop below simply jumps back up to this loop.
G1 G1 A0 C3 G1 G1 A0
G-4 G-4 A0 G-4 G-4 G-4 A0
A1 G-3 G-3 A0 A1 G-3 G-3 A0
This is the loop that jumps back up to the first loop. It looks a bit weird, but that's because this loop doesn't do anything other than jump back up top, so we can manually evaluate the loop until it gets into a position that has the shortest amount of bytes. This configuration saves one byte from the next best configuration and thirteen bytes compared to the worst configuration.
Once the value is equal to one hundred (or greater, but that will never happen), the loop will jump down to a place beyond this loop which is empty and will thus halt the program.