通过从1开始并应用一系列操作可获得任何正整数，每个操作要么是“乘以3”，要么是“除以2，则舍弃任何余数”。

示例（用f表示* 3，用g表示/ 2）：

4 = 1 *3 *3 /2 = 1 ffg
6 = 1 ffggf = 1 fffgg
21 = 1 fffgfgfgggf

编写一个具有以下行为的程序：

输入：通过stdin或硬编码的任何正整数。（如果是硬编码，则输入数字将从程序长度中排除。）
输出：一串f和g的字符串<input> = 1 <string>（例如示例中）。这样的反序字符串也是可以接受的。注意：输出仅包含f和g，或者为空。

当输入41时，获胜者是程序加输出字节最少的条目。

GolfScript，得分64（43-2 + 23）

0{)1.$2base:s{{3*}{2/}if}/41=!}do;s{103^}%+

（41是硬编码的，因此得分为-2个字符）。输出是

fffgffggffggffgggffgggg

这是23个字符（没有换行符）。通过构造，代码保证了它总是返回最短的表示形式（之一）。

朋友们，我们越来越脏了！

爪哇 210207 199个字符

public class C{public static void main(String[] a){int i=41;String s="";while(i>1){if(i%3<1){s+="f";i/=3;}else if(i%3<2){s+="g";i+=i+1;}else{s+="g";i+=i+(Math.random()+0.5);}}System.out.println(s);}}

非高尔夫：

public class C {

    public static void main(String[] a) {

        int i = 41;
        String s = "";
        while (i > 1) {
            if (i % 3 == 0) {
                s += "f";
                i /= 3;
            } else {
                if (i % 3 == 1) {
                    s += "g";
                    i += i + 1;
                } else {
                    s += "g";
                    i += i + (Math.random() + 0.5);
                }
            }
        }
        System.out.println(s);
    }
}

输出：根据古老众神的信仰，我最短的时间是30岁。请注意，必须从右侧读取输出。

234

1 ggfgfgfgfggfggfgffgfggggfgffgfggfgfggggfgffgfggfgfggfgfggfgfgggggfffgfggfgfggfgfgggffgggggfffgfggggfgffgfggfgfggfgfggfgfggfgfggfgfggfgfggggfgffgfggfgfggfgfggfgfggfgfggfgfggggggggggggfgfgfggggfgfgfggfffgfgfggffgfgfggfgfggggffgfgfffff

108

1 gggffgfgfggggggfggggfgffggggfgfgfgfgfgffgggfgggggfggfffggfgfffffgggffggfgfgggffggfgfgggffggggggfgfgffgfgfff

编辑 45

1 ggfgfgfgfgggfggfffgfggfgfgggggggffgffgfgfff

要点： 318 199 + 30 = 229

编辑1（2 * i + 1）％3 == 0->（2 * i）％3 == 1

如果您在打高尔夫球时使用Java 6而不是Java 7，则可以使用

public class NoMain {
    static {
        //some code
        System.exit(1);
    }
}

39个字符的结构代替了53个字符长的标准结构。

Python，得分124（90-2 + 36）

x=41;m=f=g=0
while(3**f!=x)*(m!=x):
 f+=1;m=3**f;g=0
 while m>x:m/=2;g+=1
print'f'*f+'g'*g

90个字符的字符（每个换行符为1个）-2个用于硬编码的输入数字+ 36个字符的输出

输出：

ffffffffffffffffgggggggggggggggggggg

Python，得分121（87-2 + 36）

t=bin(41)
l,n,f=len(t),1,0
while bin(n)[:l]!=t:f+=1;n*=3
print(len(bin(n))-l)*'g'+f*'f'

Perl得分89（63-2 + 28）

$_=41;$_=${$g=$_%3||$_==21?g:f}?$_*2+$_%3%2:$_/3while$_>print$g

猜想：如果下面我的原始解决方案中描述的幼稚方法达到一个循环，则该循环将为 [21，7，15，15，5，10，21，...]。由于没有 1≤n≤10 ^6的反例，因此这似乎是正确的。为了证明这一点，就足以证明这是其中唯一的周期可以存在，这我可能会或可能不会在稍后的时间点做。

上述解决方案避免了立即循环，而不是（错误地）猜测，并且避免了第二次循环。

输出（28个字节）：

ggfgfgfgfggfggfgfgfggfgfgfff

Perl，得分100（69-2 + 33）

$_=41;1while$_>print$s{$_=$$g?$_*2+$_%3%2:$_/3}=$g=$_%3||$s{$_/3}?g:f

使用猜测和检查的方法。字符串是使用反运算构造的（将值转换为1，而不是相反的方式），并且字符串会相应地进行镜像，这是问题说明所允许的。

每当遇到三的非整数倍时，它将乘以2，如果结果为三的整数倍，则将其相加。当遇到三的倍数时，它将除以三...除非先前已经遇到过该值，表示一个周期，因此是猜测。

输出（33字节）：

ggfgfgfgfggfggfgffgfgggfggfgfgfff

J，得分103（82-2 + 23）

*注：我叫我的动词f和g，不要与输出字符串混淆f和g。

硬编码：

f=:3 :'s=.1 for_a.y do.s=.((<.&-:)`(*&3)@.a)s end.'
'gf'{~#:(>:^:(41&~:@f@#:)^:_)1

通用功能：

f=:3 :'s=.1 for_a.y do.s=.((<.&-:)`(*&3)@.a)s end.'
g=:3 :'''gf''{~#:(>:^:(y&~:@f@#:)^:_)1'

取消了对二进制数字块的操作，这对压缩而言是最重要的更改g。重命名了变量，并删除了一些空格，但在功能上仍然相同。（用法：g 41）

J，得分197（174 + 23）

f =: 3 : 0
acc =. 1
for_a. y do. acc =. ((*&3)`(<.&-:)@.a) acc end.
)

g =: 3 : 0
f2 =: f"1 f.
l =. 0$0
i =. 1
while. 0=$(l=.(#~(y&=@:f2))#:i.2^i) do. i=.>:i end.
'fg'{~{.l
)

输出： ffffffffggggggggfgffggg

f布尔值的列表转换成数，使用作为0 *3和1作为/2（和floor）。#:i.2^i创建一个包含所有长度为1的布尔型布尔数组的秩2数组i。