learnxinyminutes-docs/golfscript.html.markdown

---
language: GolfScript
filename: golfscript.gs
contributors:
    - ["Nicholas S Georgescu", "http://github.com/ngeorgescu"]
---

GolfScript is an esoteric language that was developed in 2007 by Darren
Smith. It is a scripting language with an interpreter written in Ruby. It lets
you write very dense code in very few characters. The main goal of the language
is, as the name suggests, to solve problems in as few keystrokes as possible.
The examples page on the GolfScript website even has an entire Sudoku solver
written in just 77 characters.

If you get really good at GolfScript you can easily find yourself using it as a
go-to language for solving some (even somewhat hard) coding problems. It's never
going to be faster than Ruby, but it can be very fast to write, since a single
character of GolfScript can replace an entire line of code in some other languages.

GolfScript is based on the use of the stack. This tutorial therefore will
read as a sequence of stack operations on an actual stack, as opposed to some
standalone code and individual results. The stack starts as an empty list, and
everything either adds to the stack, or it pops some items off, transforms them,
and puts them back onto the stack.

To get started running GolfScript, you can get the golfscript.rb file from the
[GitHub repo](https://github.com/darrenks/golfscript).  Copy it into your `$PATH`,
(dropping the .rb and chmodding as necessary). You can run GolfScript from either
the interactive interpreter (which mirrors the tutorial below). Once you get the hang
of GolfScript, you can start running from "stdin". If you see a script starting with `~`,
it was probably designed to be dropped in a file and run with `golfscript file.gs`.  You
can pipe in or enter in your input at runtime.

```golfscript
> anything undefined technically evaluates to nothing and so is also a comment
# but commenting it out explicitly anyway is probably a good idea because if
# you use a reserved keyword or any punctuation you'll run into trouble.
[]
> ######################################################################
#       datatypes
########################################################################
> 1 # Here we add 1 to the stack.  Any object entry adds things to the stack
[1]
> 'abc' # here we are adding a string. The only difference between single and
# double quotes is that double lets you escape more things other than \' and \n
# it won't matter for the sake of this tutorial.
[1 "abc"]
> {+} # the third type of object you can put on the stack is a block
[1 "abc" {+}]
> ] # this takes everything prior and puts it into an array, the fourth type
# of object. (besides bug exploits like [2-1?] those are the only four types)
[[1 "abc" {+}]]
> ; # let's clear the stack by executing the discard function on this array.
# if you type the characters  ]; it always clears the stack.
[]
> 1"abc"{+}]; # newlines are whitespaces. Everything we did up to this point
# can be put into one line and it all works the exact same.
########################################################################
#       operators and math
########################################################################
[]
> 1 1 # we add two 1s to the stack.  We could also duplicate the first with .
[1 1]
> + # math is done by executing an operation on the top of the stack. This
# can be a standalone character. The way to read this is that we put a 1 on
# the stack, another one one the stack, and then executed a + operation which
# takes the top two elements off of the stack, sums them up, and returns them
# to the stack.  This is typically referred to as postfix notation.  It can be
# a bit jarring, but this is the way to think about things.  You're adding to
# the stack with objects and modifying the top of the stack with operators.
[2]
> 8 1- # minus works the same way. N.B. that we still have that 2 on the stack
# from earlier
[2 7]
> 10 2* # multiplication works the same way. The product is added to the stack
[2 7 20]
> 35 4/ # all division is integer division
[2 7 20 8]
> 35 4%  # modulo operation
[2 7 20 8 3]
> 2 3? # exponentiation
[2 7 20 8 3 8]
> 8~ # bitwise "not" function on signed integers
[2 7 20 8 3 8 -9]
> -1~ # this yields 0, which is useful to know for the ? operator
[2 7 20 8 3 8 -9 0]
> 5 3| # or: yields 7, since [1 0 1] | [0 1 1] => [1 1 1]
[2 7 20 8 3 8 -9 0 7]
> 5 3^ # xor: yields 6, since the parity differs at [1 1 0]
[2 7 20 8 3 8 -9 0 7 6]
> 5 3& # and: yields 1, since it's the only bit active in both: [0 0 1]
[2 7 20 8 3 8 -9 0 7 6 1]
> ]; ###################################################################
#       booleans
########################################################################
[]
> 5 3
[5 3]
> < #add two numbers to the stack, and then perform a lessthan operation
# booleans are False if 0, [], {}, '', and true if anything else.
[0]
> 5 3> # greater than operation.
[0 1]
> 5 3= #single equal is the operator. Again, before the equals is executed,
# the stack reads [0 1 5 3], and then the equals operator checks the top 2
# values and yields:
[0 1 0]
> ! #not, returns 1 if 0 else 0.
[0 1 1]
> ) #increments the last number
[0 1 2]
> ( #decrements the last number
[0 1 1]
> ]; ###################################################################
#       stack control
########################################################################
[]
> 1 # put a number on the stack
[1]
> . # duplicate the number
[1 1]
> ) # increment
[1 2]
> \ # flip the top two items
[2 1]
> 1$ # $ copies the nth-to-last item on the stack at the index preceding.
# Here we get the 1-indexed item.
[2 1 2]
> 0$ # to copy the 0-indexed item we use the appropriate index.
# This is identical to . operation
[2 1 2 2]
> ) # increment
[2 1 2 3]
> @ # pulls the third item up to the top
[2 2 3 1]
> [@] # use this trick to flip the top 3 items and put them into an array
# if you wrap any operation in brackets it flips the results into an array.
# even math operations like, [+] and [-]
[2 [3 1 2]]
> ]; # also, using at most two strokes you can orient the top three items
# in any permutation. Below are shown the results on 3,~
  #      => 0 1 2    (i.e. doing nothing)
  #   \  => 0 2 1
  #   @\ => 1 0 2
  #   @  => 1 2 0
  #   @@ => 2 0 1
  #   \@ => 2 1 0
[]
> ######################################################################
#       using arrays
########################################################################
[]
> 2, # comma is the range() function
[[0 1]]
> , # and also the length() function
[2]
> ;4, # let's get an array of four items together
[[0 1 2 3]]
> ) # we can pop off the last value
[[0 1 2] 3]
> + # and put it back
[[0 1 2 3]]
> ( # we can pop off the first value
[[1 2 3] 0]
> \+ # and put it back
[[0 1 2 3]]
> 2- # we can subtract a particular value
[[0 1 3]]
> [1 3] # or a list of values
[[0 1 3] [1 3]]
> -
[[0]]
> ! # boolean operations also work on lists, strings, and blocks. If it's
# empty it's a 1, otherwise 0. Here, the list has a zero, but it's not zero-
# length, so the array as a whole is still True... and hence "not" is False
[0]
> ;4,(+ # let's make a range, pop the first value, and tack it on the end
[[1 2 3 0]]
> $ # we can also restore order by sorting the array
[[0 1 2 3]]
> 1 >  # we can also use < > and = to get the indeces that match. Note this
# is not a filter! This is an index match. Filtering items greater than one
# is done with {1>},
[[1 2 3]]
> 2 < # remember it's zero-indexed, so everything in this array is at an index
# less than 2, the indeces are 0 and 1.
[[1 2]]
> 1= # < and > return an array, even if it's one item.  Equals always drops
# it out of the array
[2]
> ;6,2% # the modulo operator works on lists as the step.
[[0 2 4]]
> ;4,2,-:a 3,2+:b # booleans also work on lists. lets define two lists
[[2 3] [0 1 2 2]]
> | # "or" - returns set of items that appear in either list i.e. "union set"
[[2 3 0 1]]
> ;a b& # returns set of items that appear in 1 AND 2, e.g. "intersection set"
[[2]]
> ;a b^ # returns the symmetric difference set between two lists,
[[3 0 1]]
> ~ # tilde unpacks the items from a list
[3 0 1]
> ]; a
[2 3]
> 2? # finds the index of an item
[0]
> ;3a?
[1]
> 4a? # returns -1 if the item doesn't exist. Note: Order of element and array
# doesn't matter for searching. it can be [item list?] or [list item?].
[1 -1]
> ]; # clear
[]
> 3,[4]* # join or intersperse: puts items in between the items
[[0 4 1 4 2]]
> ; 3,4* # multiplication of lists
[[0 1 2 0 1 2 0 1 2 0 1 2]]
> ;[1 2 3 2 3 5][2 3]/ # "split at"
[[[1] [] [5]]]
> ;[1 2 3 2 3 5][2 3]% # modulo is "split at... and drop empty"
[[[1] [5]]]
> ];####################################################################
#       strings
########################################################################
# strings work just like arrays
[]
> "use arch, am vegan, drive a stick" ', '/ # split
[["use arch" "am vegan" "drive a stick"]]
> {'I '\+', BTW.'+}% # map
[["I use arch, BTW." "I am vegan, BTW." "I drive a stick, BTW."]]
> n* # join.  Note the variable n is defined as a newline char by default
["I use arch, BTW.\nI am vegan, BTW.\nI drive a stick, BTW."]
> n/ # to replace, use split, and join with the replacement string.
[n "Also, not sure if I mentioned this, but" n]{+}* # fold sum 3-item array
* # and use join to get the result
n+ print # and then pop/print the results prettily
I use arch, BTW.
Also, not sure if I mentioned this, but
I am vegan, BTW.
Also, not sure if I mentioned this, but
I drive a stick, BTW.
[]
> '22222'{+}* # note that if you fold-sum a string not in an array, you'll
# get the sum of the ascii values. '2' is 50, so five times that is:
[250]
> ]; # this actually is a clever trick to get ascii values into an array.
[]
> "aabc" [{""+~}*] # if you fold over addition and drop it into a string: 
[[97 97 98 99]]
> {[.]""^}%""+ # which can be returned to a string as such using a ""^ map.
# and an empty string join.
["aabc"]
> {32-}% # note that most mapping operations work on the ascii values as
# you would expect, for instance with the difference between A and a being
# 32, you can just subtract that from the ascii value to get:
["AABC"] 
> ]; ###################################################################
#       blocks
########################################################################
[]
> 3,~ # start with an unpacked array
[0 1 2]
> {+-} # brackets define a block which can comprise multiple functions
[0 1 2 {+-}]
> ~ # blocks are functions waiting for execution. tilde does a single
# execution of the block in this case, we added the top two values, 1 and 2,
# and subtracted from 0
[-3]
> ;10,~{+}5* # multiplication works on executing blocks multiple times
# in this case we added the last 6 values together by running "add" 5 times
[0 1 2 3 39]
> ];10,4> # we can achieve the same result by just grabbing the last 6 items
[[4 5 6 7 8 9]]
> {+}* # and using the "fold" function for addition.
[39]
> # "fold" sequentially applies the operation pairwise from the left
# and then dumps the results.  Watch what happens when we use the duplicate
# operator to fold. it's clear what happens when we duplicate and then negate
# the duplicated item:
> ;4,{.-1*}*
[0 1 -1 2 -2 3 -3]
> ]{3%}, # we can filter a list based on applying the block to each element
# in this case we get the numbers that do NOT give 0 mod 3
[[1 -1 2 -2]]
> ;10,{3%0}, # note that only the last element matters for retaining in the
# array.  Here we take 0..9, calculate x mod 3, and then return a 0. The
# intermediate generated values are dumped out sequentially.
[0 1 2 0 1 2 0 1 2 0 []]
> ]; # clear
[]
> 5,{5*}% # map performs each operation on the array and returns the result
# to an array
[[0 5 10 15 20]]
> {.}% # watch what happens when you map duplicate on each item
[[0 0 5 5 10 10 15 15 20 20]]
> ]; ###################################################################
#       Control Flow!
########################################################################
# This is the most important part of scripting. Most languages have
# two main types of loops, for loops and while loops. Even though golfscript
# has many possible loops, only a few are generally useful and terse. For loops
# are implemented using mapping, filtering, folding, and sorting over lists.
# For instance, we can take the factorial of 6 by:
6, # get 0..5
{)}% # increment the list, i.e. "i++ for i in list" to get 1..6
{*}* # fold by multiplication , 9 characters for the operator itself.
[720]
> 6),(;{*}* # but can we get shorter? We can save some space by incrementing
# the 6, dropping the zero, and folding. 8 characters.
> # we can also use fold to do the same thing with unfold
1 6        # accumlator and multiplicand, we'll call A and M
{}{        # while M
  .        # copy M, so now the stack is A M M
    @      # bring A to the top, so now M M A
     *     # apply M to the accumulator, so M A
       \(  # flip the order, so it's A M, and M--
}/;        # "end", drop the list of multiplicands
# this is effectively a while-loop factorial
[720 720]
> 1.{6>!}{.@*\)}/; # we can also do the same thing with M++ while M not > 6
> 1 6{.@*\(.}do; # works the same way as the decrementing fold.
[720 720 720]
> ]; #obviously a for loop is ideal for factorials, since it naturally lends
# itself to running over a finite set of items.
########################################################################
#       Writing code
########################################################################
# Let's go through the process for writing a script. There are some tricks and
# ways to think about things. Let's take a simple example: a prime sieve.
# There are a few strategies for sieving. First, there's a strategy that
# uses two lists, candidates and primes. We pop a value from candidates,
# remove all the candidates divisible by it, and then add it to the primes.
# Second, there's just a filtering operation on numbers. I think it's
# probably shorter to write a program that just checks if a number has no
# numbers mod zero besides 0, 1, and itself. Slower, but shorter is king.
# Let's try this second strategy first.
[]
> 10 # we're probably going to filter a list using this strategy. It's easiest
# to start working with one element of the list. So let's take some example
# where we know the answer that we want to get.
[10]
> .,2> # let's duplicate it and take a list of values, and drop the first two
[10 [2 3 4 5 6 7 8 9]]
> {1$\%!}, # duplicate the ten, and scoot it behind the element, and then run
# 10 element %, and then ! the answer, so we are left with even multiples
[10 [2 5]]
> \; # we want to get rid of the intermediate so it doesn't show up in our
# solution.
[[2 5]]
> 10.,2,-{1$\%!},\; # Okay, let's put our little function together on one line
[[2 5] [2 5]]
> ;; # now we just filter the list using this strategy. We need to negate the
# result with ! so when we get a number with a factor, ! evaluates to 0, and
# the number is filtered out.
[]
> 10,{.,2,-{1$\%!},\;!}, # let's try filtering on the first 10 numbers
[[0 1 2 3 5 7]]
> 2> # now we can just drop 0 and 1.
[[2 3 5 7]]
> 4.?,{.,2,-{1$\%!},\;!},2> # trick: an easy way to generate large numbers in
# a few bytes is duplicate and exponentiate. 4.? is 256, and 9.? is 387420489
[[2 3 5 7] [2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89
97 101 103 107 109 113 127 131 137 139 149 151 157 163 167 173 179 181 191 193
197 199 211 223 227 229 233 239 241 251]]
> ];'4.?,{.,2,-{1$\%!},\;!},2>', # how long is our code for p<256 ?
[25]
> ; # this is 25 characters. Can we do better?!
[]
> []99,2> # let's go with the first strategy.  We'll start with an empty list
# of primes and a list of candidates
[[] [2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54
55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80
81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98]]
> (\ # pop left and leave left, we're going to copy this value with the filter
[[] 2 [3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54
55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80
81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98]]
> {1$%}, # filter out anything that is 0 mod by the popped item one back on the
# stack
[[] 2 [3 5 7 9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47 49 51
53 55 57 59 61 63 65 67 69 71 73 75 77 79 81 83 85 87 89 91 93 95 97]]
> @@+ # great, all the 2-divisible values are off the list! now we need to add
# it to the running list of primes
[[3 5 7 9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47 49 51 53 55
57 59 61 63 65 67 69 71 73 75 77 79 81 83 85 87 89 91 93 95 97] [2]]
> \ # swap back. Now it seems pretty clear when our candidates list is empty
# we're done. So let's try it with a do loop. Remember we need to duplicate
# the final value for the pop check. So we add a dot
[[2] [3 5 7 9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47 49 51 53
55 57 59 61 63 65 67 69 71 73 75 77 79 81 83 85 87 89 91 93 95 97]]
> {(\{1$%},@@+\.}do;
[[2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97]]
> ; # ok that worked. So let's start with our initialization as well.
[]4.?,2>{(\{1$%},@@+\.}do; # and let's check our work
[[2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 101
103 107 109 113 127 131 137 139 149 151 157 163 167 173 179 181 191 193 197 199
211 223 227 229 233 239 241 251]]
> ,'[]99,2>{(\{1$%},@@+\.}do;', # how long is this?
[26]
> ]; # wow this solution is only 26 long, and much more effective. I don't see
# a way to get any smaller here. I wonder if with unfold we can do better?  The
# strategy here is to use unfold and then at the end grab the first value from
# each table.
[]
> 99,2> # start with the candidates list
[[2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55
56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81
82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98]]
> (\{1$%}, # pop left and filter
[2 [3 5 7 9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47 49 51 53
55 57 59 61 63 65 67 69 71 73 75 77 79 81 83 85 87 89 91 93 95 97]]
> (\{1$%}, # again
[2 3 [5 7 11 13 17 19 23 25 29 31 35 37 41 43 47 49 53 55 59 61 65 67 71 73 77
79 83 85 89 91 95 97]]
89 91 95 97]]
> {}{(\{1$%},}/ # ok I think it'll work. let's try to put it into an unfold.
[2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 [[5 7
11 13 17 19 23 25 29 31 35 37 41 43 47 49 53 55 59 61 65 67 71 73 77 79 83 85
89 91 95 97] [7 11 13 17 19 23 29 31 37 41 43 47 49 53 59 61 67 71 73 77 79 83
89 91 97] [11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97] [13
17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97] [17 19 23 29 31 37 41
43 47 53 59 61 67 71 73 79 83 89 97] [19 23 29 31 37 41 43 47 53 59 61 67 71 73
79 83 89 97] [23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97] [29 31 37 41
43 47 53 59 61 67 71 73 79 83 89 97] [31 37 41 43 47 53 59 61 67 71 73 79 83 89
97] [37 41 43 47 53 59 61 67 71 73 79 83 89 97] [41 43 47 53 59 61 67 71 73 79
83 89 97] [43 47 53 59 61 67 71 73 79 83 89 97] [47 53 59 61 67 71 73 79 83 89
97] [53 59 61 67 71 73 79 83 89 97] [59 61 67 71 73 79 83 89 97] [61 67 71 73
79 83 89 97] [67 71 73 79 83 89 97] [71 73 79 83 89 97] [73 79 83 89 97] [79 83
89 97] [83 89 97] [89 97] [97]]]
> ;] # drop that list of candidates generated at each step and put the items
# left behind by the unfold at each step (which is the primes) into a list
[[2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97]]
> ]; # clear and let's try with larger numbers
[]
> 4.?,2>{}{(\{1$%},}/;]
[[2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 101
103 107 109 113 127 131 137 139 149 151 157 163 167 173 179 181 191 193 197 199
211 223 227 229 233 239 241 251]]
>;'4.?,2>{}{(\{1$%},}/;]', # find the length of our solution.
[21]
> ]; # only 21 characters for the primes! Let's see if we actually can use this
# strategy of leaving items behind, now using the do loop to get even shorter!
> 3.?,2> # candidates
[[2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26]]
> (\{1$%}, # pop and filter
[2 [3 5 7 9 11 13 15 17 19 21 23 25]]
> (\{1$%}, # again!
[2 3 [5 7 11 13 17 19 23 25]]
> {(\{1$%},.}do;] # try in a do loop and drop the empty list of candidates at
# the end of the do loop.  Don't forget the dot before the closing brace!
[[2 3 5 7 11 13 17 19 23]]
> ;4.?,2>{(\{1$%},.}do;] # check our work
[[2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 101
103 107 109 113 127 131 137 139 149 151 157 163 167 173 179 181 191 193 197 199
211 223 227 229 233 239 241 251]]
> ;'4.?,2>{(\{1$%},.}do;]',
[21]
>]; # Still 21 characters. there's one other thing to try, which is the prime
# test known as Wilson's theorem. We can try filtering the items down using
# this test.
[]
> '4.?,2>{.,(;{*}*.*\%},'.~\, # let's run it and take the length
[[2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 101
103 107 109 113 127 131 137 139 149 151 157 163 167 173 179 181 191 193 197 199
211 223 227 229 233 239 241 251] 21]
> ; # Still 21 characters! I think this number is quite good and it's not
# obvious how to beat it. The problem with GolfScript is there's always someone
# out there who thinks of some trick you didn't. For instance, you might think
# you're doing well with a Collatz seq generator of {(}{.2%{3*)}{2/}if}/ until
# you find that someone figured out {(}{3*).2%6\?/}/ which is so much shorter
# and cleaner - the unfold operation is nearly half the length!
########################################################################
#       How to read GolfScript
########################################################################
# let's take the gcd from the GolfScript banner. It starts with:
[]
> '2706 410'~ # so that's pretty straightforward, that it just evals the list
# and dumps the results on the stack. It's common to read from stdin which
# necessitates unpacking with ~
[2706 410]
> . # we want to know what that do loop does. the best way to do that is to
# drop the braces and run the loop one command at a time. We duplicate
[2706 410 410]
> @\ # We rearrange
[410 2706 410]
> % # we take the modulo
[410 246]
> .@\% # repeat. Note we don't need to run the final dot before the closing
# brace since this is just a value that is popped to check the loop condition
# you can also replicate the loop end with a semicolon to pop it yourself.
[246 164]
> .@\% # again!
[164 82]
> .@\% # and finally we hit zero. The loop would exit and ; would pop the zero,
# leaving you with the gcd of 82.
[82 0]
> ;; 2706 410{1$1$%.}do # Clearly this involves knowing about Euclid's method.
# you can also try a more obvious method like this one here which shows the
# numbers in sequence.
[2706 410 246 164 82 0]
>]; # so sometimes it pays dividends to know the math and you can write short
# algorithms that rely on easy tricks that aren't immediately obvious.
[]
> # let's try looking at the sudoku solver that is on the examples page. I'll
# skip the unpack step.
[2 8 4 3 7 5 1 6 9 0 0 9 2 0 0 0 0 7 0 0 1 0 0 4 0 0 2 0 5 0 0 0 0 8 0 0 0 0 8
0 0 0 9 0 0 0 0 6 0 0 0 0 4 0 9 0 0 1 0 0 5 0 0 8 0 0 0 0 7 6 0 4 4 2 5 6 8 9 7
3 1]:a 0?:b # again the grid is put into an array. Now, the next step
# is to define the "@" symbol as the working grid. This is because "@9" is
# interpreted as two symbols, whereas if you used something like "a" as the
# variable "a9" is interpreted as a single symbol, and this is not defined,
# so it will not get run at execution time. You would need a space which is an
# additional char. On the other hand, redefining built-ins is confusing so I
# will use "a" and "b" for the "@" and "^" definitions respectively. So the
# grid is "a" and the zero-index location of the first zero is "b", at index 9.
[9]
> ~! # this makes sure that the value is not -1 for find, i.e. -1~ evaluates to
# 0 so a ! makes it nonzero.  ?~! is a great trick for "isn't in the list"
[0]
> {@p}* # this prints out the grid the number of times as the previous value,
# which is how this thing "finishes". So if 0 isn't in the grid, it prints.
> 10, # let's get the digits 0-9. Zero will be eliminated because our original
# value is zero so when we look in any row or column, zero is guaranteed to be
# there.
[[0 1 2 3 4 5 6 7 8 9]]
> a 9/  # split the original grid row-wise
b 9/    # get the row of our checked value, in this case the second row
=       # and we get that row and
-       # take those numbers off the candidates
[[1 3 4 5 6 8]]
> a     # put the grid on the stack
b 9%    # get the column of the zero
>       # drop the first x values of the grid
9%      # take every ninth digit. We now have the column the zero is in
> -     # pull those items off the candidates list
[[1 3 5 6]]
> a 3/  # split the grid into three-long arrays
b 9%    # get the column of the zero
3/      # is the column in the left (0), middle (1), or right (2) triad?
 >      # pull that many three-groups off
3%      # get every third. Now we have 9 groups - the left side of the grid
3/      # divide those 9 groups it into thirds
b 27/   # was the zero on top (0), middle (1), or bottom (2) third of the grid?
=       # since it's the top, grab the top group of triads. You now have the
        # 1/9th of The sudoku grid where the zero sits
[[1 3 5 6] [[2 8 4] [0 0 9] [0 0 1]]]
> {+}*- # flatten those lists and remove those items from the candidates
# We now have the possible values for the position in question that work given
# the current state of the grid! if this list is empty then we've hit a
# contradiction given our previous values.
[[3 5 6]]
> 0= # {a b<\+a 1 b+>+}/ # now we've hit this unfold operation. If you run it
# you'll find we get the grids back. How does that work?! Let's take the first
# value in the "each" []{}/ operation. This is the best way to figure out what
# is happening in a mapping situation.
[3]
> a     # get the grid
b<      # get the grid up to the zero
\+      # and tack on our value of 3.
[[2 8 4 3 7 5 1 6 9 3]]
> a 1b+>+ # and we add on the rest of the grid. Note: we could do 1 char better
# because 1b+ is equivalent to but, longer than, just b)
[[2 8 4 3 7 5 1 6 9 3 0 9 2 0 0 0 0 7 0 0 1 0 0 4 0 0 2 0 5 0 0 0 0 8 0 0 0 0 8
0 0 0 9 0 0 0 0 6 0 0 0 0 4 0 9 0 0 1 0 0 5 0 0 8 0 0 0 0 7 6 0 4 4 2 5 6 8 9 7
3 1]]
> 1;; # and the do block runs again no matter what. So it's now clear why this
# thing exists with an error: if you solve the last digit, then this loop just
# keeps on rolling! You could add some bytes for some control flow but if it
# works it works and short is king.
[]

# Closing Tips for getting to the next level:
# 0. using lookback might be more effective than swapping around the values.
#    for instance, 1$1$ and \.@.@.\ do the same thing: duplicate last two items
#    but the former is more obvious and shorter.
# 1. golfscript can be fun to use for messing around with integer sequences or
#    do other cool math. So, don't be afraid to define your own functions to
#    make your life easier, like
> {$0=}:min; {$-1=}:max; {.,(;{*}*.*\%}:isprime; {.|}:set; # etc.
# 2. write pseudocode in another language or port a script over to figure out
#    what's going on. Especially useful when you combine this strategy with
#    algebra engines. For instance, you can port the examples-page 1000 digits
#    of pi to python and get:
#        import sympy as sp
#        a, k = sp.var('a'), list(range(20))[1::2]
#        for _ in range(len(k)-1):
#            m = k.pop()
#            l = k.pop()
#            k.append(((l+1)//2*m)//(l+2)+2*a)
#        print(str(k[0]))
#    which gives "2*a + floor(2*a/3 + floor(4*a/5 + 2*floor(6*a/7 + 3*floor(
#    8*a/9 + 4*floor(10*a/11 + 5*floor(12*a/13 + 6*floor(14*a/15 + 7*floor(16*
#    a/17 + 72/17)/15)/13)/11)/9)/7)/5)/3)"... which makes it much more obvious
#    what's going on than 10.3??:a;20,-2%{2+.2/@*\/a 2*+}* especially when
#    you're new to the language
# 3. a little math goes a long way. The above prime test uses Wilson's theorem
#    a comparable program testing for factors {:i,(;{i\%!},(;!}:isprime is
#    longer and slower. Also, as discussed above, Collatz is much shorter if
#    you recognize that you can do (3x+1) and then divide by 6 to the power
#    ((3x+1) mod 2).  (If x was even, (3x+1) is now odd, so 3x+1 div 6 is x/2.)
#    avoiding conditionals and redundancy can sometimes require such insight.
#    And of course, unless you know this continued fraction of pi it's hard to
#    calculate it in a terse block of code.
# 4. don't be afraid to define variables and use arrays! particularly if you
#    have 4 or more items to shuffle.
# 5. don't be afraid to use [some_long_script] to pack a bunch of items in an
#    array after the fact, rather than gathering or adding them later or
#    forcing yourself to use a datastructure that keeps the items in an array
# 6. sometimes you might get in a jam with - followed by an int that can be
#    solved with ^ to do a symmetric set difference without adding a space
# 7. "#{require 'net/http';Net::HTTP.get_response(URI.parse(address)).body}"
#    can get any page source from the internet, substituting 'address' for your
#    URL. Try it with an OEIS b-file or wordlists, etc. You can also use the
#    shorter "#{File.open('filename.txt').read}" to read in a file. GolfScript
#    can run "#{any_ruby_code_here}" and add the results to the stack.
# 8. you can set anything to mean anything, which can be useful for golf:
#       3:^;^2?  => 9 because this set ^ to 3, and 3 2 ? => 9
#       3:a;a2?  => Warning: pop on empty stack - because a2 doesn't exist
#       3:a;a 2? => 9 - it works again, but takes an extra character over ^2
#    usually you will only want to do this once you're trying to squeeze the
#    last few chars out of your code because it ruins your environment.
```

* [Run GolfScript online](https://tio.run/#golfscript)
* [GolfScript's documentation](http://www.golfscript.com/golfscript/builtin.html)
* [Useful StackExchange thread](https://codegolf.stackexchange.com/questions/5264/tips-for-golfing-in-golfscript)
* [GolfScript on GitHub](https://github.com/darrenks/golfscript)