PhilippeTeuwen: Created page with "==2015== ===2015 Perl golf=== Goal: Write a Perl program that takes a parameter as input and outputs a filtered version with alternating upper/lower case letters of the (engli..."

2017-10-20T18:59:02Z

Created page with "==2015== ===2015 Perl golf=== Goal: Write a Perl program that takes a parameter as input and outputs a filtered version with alternating upper/lower case letters of the (engli..."

New page

==2015==
===2015 Perl golf===
Goal: Write a Perl program that takes a parameter as input and outputs a filtered version with alternating upper/lower case letters of the (english) alphabet. Non-letter characters have to be printed but otherwise ignored.
 Example:
Input Hello World! Hallo Welt!
Output HeLlO wOrLd! HaLlO wElT!
Rules:
* You have 1 second.
* You have 45 (ASCII) chars.
* Do not flood the server.

The first thing is to find how the server will use your script.
 Input isn't read from stdin but is expected as the first argument, so you can try locally with
perl -e 'print @ARGV[0]' 'Hello World! Hallo Welt!'
Hello World! Hallo Welt!
Then come with a strategy to convert letters as asked and squeeze it.
 Here is our solution: (37 chars)
<pre>
$_=pop;s/\pL.*?(\pL|$)/\u\L$&/g;print
</pre>
But here is actually how Fluxfingers designed this challenge: they tried internally, kept the best one-liner they could come with, which was 38 chars long, and extended the limit to 45 to give some room to the participants.
 The best solution Fluxfingers had in mind: (38 chars)
<pre>
$_=pop;s/\pL/uc$&^$"^($x^=$")/ge/print
</pre>
So we were one char shorter \o/

A little word of explanation of our solution:
<pre>
$_=pop;s/\pL.*?(\pL|$)/\u\L$&/g;print
$_= assign to the Perl "current var", so we don't have to mention it later
pop; we need @ARGV[0], pop is shorter
s/ / /g; search and replace, g=repeat
\pL.* \pL We want one letter followed optionally by some stuff followed by one letter
\w captures too much (also [0-9_]) so we rely on that Unicode magic \pL
So first captured letter needs to be in uppercase and second captured letter needs to be lowercase
.*? Problem with .* is that it captures too much, including letters.
One could write [^a-zA-Z]* but that's not golfing anymore
Adding the "?" reduces the "greediness" of the expression to capture as few chars as possible
(\pL|$) An issue wit \pL only is that it fails if there is an odd number of letters in the string
So here we say one letter, or end of string, to capture that corner case.
\u\L$& $& is what was captured by the regex, \u means first char uppercase, \L means lowercase for the remaining letters
print Should I explain?
</pre>

After the CTF, we got it even shorter, now 36 chars!:
<pre>
$_=uc pop;s/\pL.*?\pL/\u\L$&/g;print
uc Set whole input as uppercase
\pL No more dirty (\pL|$) trick here
</pre>
The trick is to avoid the corner case of odd number of letters by setting the whole input uppercase first

Alternative solution of 36 chars, optimizing what was discussed [https://github.com/teamavidya/ctf/commit/52f5789e743af94c147d4e5e0fd3796bc162872b#commitcomment-13953040 here]:
<pre>
$_=lc pop;s/\pL/$&^($u^=$")/ge;print
$_= assign to the Perl "current var", so we don't have to mention it later
lc Set whole input as lowercase
pop; we need @ARGV[0], pop is shorter
s/ / /ge search and replace, g=repeat, e=evaluate again the result
\pL We want one letter: \w captures too much (also [0-9_]) so we rely on that Unicode magic \pL

$& $& is what was captured by the regex
^ $" xor it with $" which evaluates to " ". The effect is that a letter XORed by 0x20 toggles its case.
^($u^=$") Actually that's to be done only half of the time so we xor with a variable that is constantly xored with " "
so $u value is successively 0x20, 0x00, 0x20, 0x00 etc
print Should I explain?
</pre>

'''UPDATE''': [https://github.com/teamavidya/ctf/commit/52f5789e743af94c147d4e5e0fd3796bc162872b#commitcomment-13964794 someone] managed to get down to 34 chars!:
<pre>
print pop=~s/\pL/lc$&^($u^=$")/ger
r perform non-destructive substitution and return the new value
</pre>

Actually we can go even further for some of those solutions if we tolerate that the script doesn't always work.
 One can simply reload multiple times the script till the server provides a compatible input to get the flag.
 E.g. 29 chars and 28 chars:
<pre>
$_=pop;s/\w.*?\w/\u$&/g;print
print pop=~s/\w.*?\w/\u$&/gr
</pre>
worked after a few reloads on the sentence "body. want Law the help of and, being. a, graduates"

===2015 PHP Golf===
Same as for Perl Golf, but now we've 62 chars max.
 The lazy solution: (57 chars)
<pre>
<?=`echo '$argv[1]'|perl -pe 's/\pL.*?(\pL|$)/\u\L$&/g'`;
</pre>

Apparently Fluxfingers solution was:
<pre>
<?=preg_filter("/\pL/e",'($0|" ")^chr($m^=32)',$argv[1]);
</pre>

Hack.lu 2015 Writeups - Revision history

PhilippeTeuwen: Created page with "==2015== ===2015 Perl golf=== Goal: Write a Perl program that takes a parameter as input and outputs a filtered version with alternating upper/lower case letters of the (engli..."