# Tips for golfing in AWK

What general tips do you have for golfing in AWK? I'm looking for ideas that can be applied to code golf problems in general that are at least somewhat specific to AWK. Please post one tip per answer.

These are not in any particular order, and some of them might even apply to other languages too, but not to a lot of them I think.

• You can sometimes use awk's simple string concatenation to assemble numbers

z=x*10+y and a=b*10

become

z=x y and a=b 0

• You can use the ~ operator (match pattern on the right side) to compare numbers or strings if you know that the two parts meet certain conditions

for instance if you know that a will always be smaller than or equal to b, you can replace

a==b

with

a~b

or if you want to check for an empty string s (which means that s isn't allowed to be "0" either), and you haven's changed the variable X before, so that it is still undefined, you could use

X~s

s==""

if you want to check if i is an integer you can use

i!~/\./ (i doesn't contain a dot)

i==int(i)

• You can swap two numbers in a single command

t=a;a=b;b=t

becomes

a+=b-(b=a)

saving one character

• If you don't need them as input anymore, you can use the input variables $1,$2, $3, ... as an array. So instead of writing a[n] you can just write$n. Sometimes even while reading the input from these you can use the already handled ones as a stack for something.

• You can make good use of the built-in separators FS (space, if not changed by you) and RS (newline) when concatenating strings

a=$1" "$2

becomes

a=$1FS$2

or even better

a=$1"\n"$2

becomes

a=$1RS$2

• If there is no input and you use the BEGIN block, you can try to use the END block instead. Depending on the judge it works. If you test it, you have to press Ctrl-D (end of input) to access the END block.

• If you want to skip the first line, you can use

C++

NR>1

if you won't be using C anywhere in your program.

## Techniques

• Thanks to Peter Taylor for pointing out the language-generic version of this question for which I did not bother to search. I'll try to limit this answer to things that are not available in other C-like languages.

• The frequently accessed builtin variables are 2 characters long. Find the break-even point for assigning to a temp variable. a=$1; is five characters, so it breaks even after five uses of $1;

• Remember that the default action for a matching pattern is print $0, so if you get what you want printed into $0, just use

1

• Getting creative with operator ordering can save you some parentheses or extra statements

for(i=1;i<=NF;i++)print$i;  vs for(;i<NF;)print$++i;


## Examples

• A solution to Do We Sink or Swim? in 70 characters:

n{for(;NF;NF--)s+=$NF;n--}NR==1{n=$1;p=$3}END{print p<s?"Swim":"Sink"}  • A solution to The Floating Horde in 44 characters: {for(i=NF;i>1;){n=int($i/2);$i%=2;$--i+=n}}1


## Summary

awk will probably never outgolf APL, Golfscript, J, or K, but you can quite consistently beat other high level languages.

• The question asks for tips which are somewhat specific to Awk. The ternary operator is included in the tips for all languages. Mar 17, 2014 at 20:35
• @laindir : for(;i<NF;)print$++i; can become NF=NF OFS='\n' Nov 1, 2022 at 14:13 To read and process a number on each line: { n=$1;
print(n*n);
// OR printf("%d\n",n*n);
}


Compressed form (Length = 14):

{print($1*$1)}       // thanks due to @manatwork


Shorter Code (Length = 7)

1,$0^=2 // thanks due to @llhuii  When compiled and run in gawk with inputs: 1 2 3  Output: 1 4 9  • Why the variable? And why the parenthesis? {print$1*$1} is shorter. Oct 26, 2013 at 11:02 • 1,$0^=2 is shorter Dec 8, 2013 at 7:12
• For any input different from 0 or null, $0^=2 does the same. Careful that when using 1,$0^=2, blank lines return 0. Dec 26, 2020 at 16:11
• @PedroMaimere : this solves it echo "1\n2\n3\n\n4\n5" | mawk '!NF || ($!_^=2)^_' 1 4 9 16 25 …. or not write any numbers at all mawk '!NF || ($!_*=$!_)^_' Nov 1, 2022 at 11:46 • @PedroMaimere : better yet : echo "0\n1\n2\n3\n\n4\n5" | mawk '!NF || ($!_^=++NF)^_' 0 1 4 9 16 25 - actual input lines containing a zero will print out zero squared, while blank lines remain as such. u can directly square hexes with mawk : echo 0x4F0FFF9 | mawk '($!_^=++NF)^_' CONVFMT='%.f' 6872912880599089 Nov 1, 2022 at 11:49 # Truthy and falsey values Boolean evaluation is somehow flexible in AWK, and this is awesome. Remember: AWK's basis is pattern{action}; when pattern is true, it executes action. Besides doing their business, some built-in functions return values, e.g., split(), gsub(). They are also useful as a pattern when manipulating the input. ## Examples of truthy and falsey variables I tried to come up with valuable examples of how to exploit truthy/falsey variables. This is non-exhaustive. Anyone is encouraged to share more examples, and I would add them to this list. Try it online! "strings are truthy"{print 1} # truthy; strings are always truthy, except for the null string -0xF3e10{print 2} # truthy; numbers different from zero are truthy 0{print 3} # falsey; zeroes are false: 0, -0, +0, 0x0, 0000... expect for "0", which is a string 0 b{print 4} # truthy; now the number 0 is concatenated to a null string (a variable still not assigned), thus converting it to "0" ""{print 5} # falsey; null string b{print 6} # falsey; b is null (a variable not assigned) a=@/x/{print 7} # truthy; defining a strongly typed regex constant. Different from a /x/ pattern /x/{print 8} # falsey; /x/ does not match the input c["test"]{print 9} # falsey; undefined item of array, null c["test"]++{print 10} # falsey; variable is evaluated before increment c["test"]{print 11} # truthy; now, c["test"] equals 1 c["test2"]{print 12} # falsey; although the c array now exists, the "test2" element does not  Result: 1 2 4 7 11  one of the great things about awk's sigils $ is that string concat can be even more condensed than having to use the built-ins as buffer zones - say, u wanna prepend a zero to the full row:

 _=0
$_=_$_

jot -c 8 75  | gawk '$_=+_$_'

0K
0L
0M
0N
0O
0P
0Q
0R


and you wanna make patterns out of it ?

jot -c 8 75  | gawk '$_=_++$_'  # integers

0K
L 1
M  2
N   3
O    4
P     5
Q      6
R       7

jot -c 8 75  | gawk '$_=_++$++_' # even numbers

K 0
L   2
M     4
N       6
O         8
P           10
Q             12
R               14

jot -c 8 75  | gawk '$_=++_$++_'  # odd numbers

K 1
L   3
M     5
N       7
O         9
P           11
Q             13
R               15


And honestly, what language can repeat stings THIS easily :

jot 20 | mawk 'NF=OFS=$_' 1 22 333 4444 55555 666666 7777777 88888888 999999999 10101010101010101010 1111111111111111111111 121212121212121212121212 13131313131313131313131313 1414141414141414141414141414 151515151515151515151515151515 16161616161616161616161616161616 1717171717171717171717171717171717 181818181818181818181818181818181818 19191919191919191919191919191919191919 2020202020202020202020202020202020202020  or can decode arbitrary precision hex with this few keystrokes : echo 0xEDCFAB12EDCFAB127659438976594389EDCFAB |  gawk -nM '$_=+\$_'

5303367068685265828195859270035065456131166123