[Community Puzzle] Format string validation

Coding Games and Programming Challenges to Code Better

Send your feedback or ask for help here!

1 Like

I’ve been lost on this for a bit. Maybe I’m taking the wrong approach?

I’m coding in JS, and I’ve had a few different logics I’ve tried out, and it end in one of two ways -
-The code becomes too complex to follow, so I paste my code into a notepad just in case, and start over.
-Limited by the approach

All of my logic seems to start the same. Divide the ‘format’ by “~”, and use String manipulation to find the portions of it within ‘text’. This typically works to start, and has been my initial approach.

My first logic worked for every test except the last. I think I know why.
In a situation where the text is ZZABXDABCDFFABYDZZ, and the format ~AB?D?F~
I was working through it, dividing it out by the "?"s after dividing it out by "~"s, and although it’d find an instance of “AB?” in the string, it didn’t find the right one, and I hadn’t programmed a way for it to backtrack and try the next.

My most recent logic was to separate into two parts. Firstly, the beginning and the end. Thinking if I could separate the special case of if it starts with “~” or not, from the rest of the logic, it might be easier.

I’m thinking maybe the answer lies somewhere in recursion? When learning programming, recursion is a topic that’s always given me trouble. I usually am able to understand enough to pass the courses, but never enough to apply it in actual programming. I feel like it’s a valuable tool, but I struggle when applying it.

I would like help.
Hints, or tips for the puzzle, or learning recursion in a way that I can see how to apply it?
Javascript-specific resources would be nice on the recursion, but I’m also fine just learning the general logic of it.

Most of the published Python solutions I can see use either regex or recursion, so recursion is definitely a way to go. There are also solutions using dynamic programming and other approaches, but they are very few.

1 Like

If you’re not ready for recursion, you can solve this puzzle without it.

  • First, write an “equals” function, to accept the “?” character (so that “ABCD” and “AB?D” would return true).
  • Then, write a “find” function, using your “equals” function (so that it would find “AB?D” in “ZZABCDZZ”), returning the index.

With those tools, you can just separate words by “~” as you said, and find each word in the text. Be careful about starting each search at the end of the previous one (that’s why “find” returns an index. You start your search at the previous index + previous word.length(), so that “AB~BC” wouldn’t match in “ABC”).

And if it’s too easy with that … you can try recursion. :wink:

1 Like

I’m always sad when I hear this because recursion is supposed to feel a lot more “natural” than programming with loops, so if a teacher makes loops easier than recursion they are doing something wrong in my opinion.

One way to think of recursion is that you have a trusted assistant who already knows how to do the task; you have to make just a little bit of progress yourself, but you can pass most of the task, as a subtask, to your assistant who already knows how to do it.

For instance, imagine you have to match ABXDABCDFF against ~AB?D?F~.

The very first thing to do is decide whether to include the first A into the ~ or not.

If you include it, then you’re left with matching BXDABCDFF against ~AB?D?F~, which you pass to your assistant.

If you don’t include it, then you’re left with matching ABXDABCDFF against AB?D?F~, which you pass to your assistant.

So this gives us the following recurrence relation:

match(“~AB?D?F~”, “ABXDABCDFF”) =
Ask your assistant to test match(“~AB?D?F~”, “BXDABCDFF”) and to test match(“AB?D?F~”, “ABXDABCDFF”), and use the result of these two subtasks to get the result of your task.

Now this is a recurrence relation, you can

  • use it directly to write a recursive function
  • use it to fill a dynamic programming table where M[i,j] stores the result of match(substring starting at index i, substring starting at index j)
  • use it for a stack-based or queue-based approach where you store all the pairs (format,text) that you want to try to match
  • or anything else of your choosing.

(Also note I arbitrarily decided to do remove characters from left to right, but you can also do it from right to left if you prefer, ie remove the F before the A)

1 Like

ty all for the tips ~
I’m going to try again later today.

I’d really like to do it using recursion, so I’m going to try that first.
I’ll comment again once I triumphantly complete the puzzle >:^)


Thank you very much for this puzzle, I really enjoyed it.
It reminded me some lessons I had long time ago.

1 Like

I don’t know if it still counts as recursion, because I called the recursive function inside of a loop, but it works :slight_smile:

Best part is, would have worked on my first try, but I forgot to pass the previous value of a variable when taking a step back, so it was statically set to false instead of taking a step back and using the previous value.

TL;DR thx for everyone that helped :):):).


I’m now realizing how much simpler this problem would have been to solve with regex xD


Bonjour, je ne comprends pas pourquoi le test 8 est considéré comme bon.

Début du texte = IboJSRam>|6&V17T_M|pww)m,<ns8{%9G5%%WT"S=f}kztLQ^eP-T/P-u@?LgbWjnmE
Début format . = Ibo~ . . . . >|6&~ . . . . . .pw~ )m~ . . . .{~ . . . . . . . . . . . . . . . . . . . -u@?LgbWjnm?/JB<
ça coince ici. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .^

puisque après le tiret (-) le format montre un ‘u’ alors que le texte donne un ‘T’

Que n’ai-je pas compris dans les consignes ? Merci de m’éclairer.

Hello, I don’t understand why test 8 is considered good.

Start of text . .= IboJSRam>|6&V17T_M|pww)m,<ns8{%9G5%WT “ S=f}kztLQ^eP-T/P-u@?LgbWjnmE
Start format . = Ibo~ . . . . >|6&~ . . . . . .pw~ )m~ . . . {~ . . . . . . . . . . . . . . . . . . . .-u@?LgbWjnm?/JB<
it’s sticking here. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .^

since after the hyphen (-) the format shows a ‘u’ whereas the text shows a ‘T’.

What did I not understand in the instructions? Thanks for clarifying.

You’re saying

Text:   { %9G5%%WT"S=f}k`ztLQ^eP -T/P -u@?LGbWjnmE/JB<c
          ~~~~~~~~~~~~~~~~~~~~~~  not matched from here
Format: { ~                      -u@?LGbWjnm?/JB<c

But you can also match the format this way:

Text:   { %9G5%%WT"S=f}k`ztLQ^eP -T/P -u@?LGbWjnmE/JB<c
          ~~~~~~~~~~~~~~~~~~~~~~ ~~~~
Format: { ~                           -u@?LGbWjnm?/JB<c

does someone know what is in test Big case, I passed all the tests except the one after submitting the code, I would like to know what is in this test.
Can someone help me please?

In Validator 8 (Big case), the input text is the same as that of Test 8, while the input format is around 50% the same as that of Test 8.

1 Like

you fail probably because ~?

Merci pour cet éclaircissement.

Certaines consignes mériteraient d’être améliorées.

C’est notamment le cas pour le problème “WAR”, la bataille navale, pour lequel j’ai vu passer une multitude de demande d’aide concernant le ramassage des cartes.

Ceci dit, j’aurais dû me douter qu’il fallait comprendre les consignes différemment puisque des participants de "format string validation’ avaient résolu ce problème. Je réfléchirai plus longtemps la prochaine fois :wink:

Thanks for the clarification.

Some of the instructions could be improved.

This is particularly the case for the “WAR” problem, the naval battle, for which I’ve seen a multitude of requests for help in collecting the cards.

Having said that, I should have known that the instructions needed to be understood differently, as participants in “format string validation” had solved this problem. I’ll think longer next time :wink:

1 Like