Se puede obtener cualquier número entero positivo comenzando con 1 y aplicando una secuencia de operaciones, cada una de las cuales es "multiplicar por 3" o "dividir por 2, descartando cualquier resto" .

Ejemplos (escribir f para * 3 yg para / 2):

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

Escribe un programa con el siguiente comportamiento:

Entrada : cualquier número entero positivo, vía stdin o codificado. (Si está codificado, el número de entrada se excluirá de la longitud del programa).
Salida : una cadena de f y g tal que <input> = 1 <string>(como en los ejemplos). Tal cadena en orden inverso también es aceptable. NB: La salida contiene solo f's y g's, o está vacía.

El ganador es la entrada con la menor cantidad de bytes de programa más salida cuando 41 es la entrada.

GolfScript, puntaje 64 (43-2 + 23)

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

(41 está codificado, por lo tanto, -2 caracteres para la puntuación). La salida es

fffgffggffggffgggffgggg

que tiene 23 caracteres (sin nueva línea). Por construcción, el código garantiza que siempre devuelve (una de) las representaciones más cortas.

Nos estamos ensuciando, amigos!

JAVA 210 207 199 caracteres

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);}}

no golfizado:

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);
    }
}

salida: dependiendo de la fe de los antiguos dioses, la más corta que tuve fue 30. Tenga en cuenta que la salida debe leerse desde la derecha.

234

1 ggfgfgfgfggfggfgffgfggggfgffgfggfgfggggfgffgfggfgfggfgfggfgfgggggfffgfggfgfggfgfgggffgggggfffgfggggfgffgfggfgfggfgfggfgfggfgfggfgfggfgfggggfgffgfggfgfggfgfggfgfggfgfggfgfggggggggggggfgfgfggggfgfgfggfffgfgfggffgfgfggfgfggggffgfgfffff

108

1 gggffgfgfggggggfggggfgffggggfgfgfgfgfgffgggfgggggfggfffggfgfffffgggffggfgfgggffggfgfgggffggggggfgfgffgfgfff

editar 45

1 ggfgfgfgfgggfggfffgfggfgfgggggggffgffgfgfff

puntos : 318 199 + 30 = 229

edit1 (2 * i + 1)% 3 == 0 -> (2 * i)% 3 == 1

Nota Bene si usa Java 6 y no Java 7 mientras juega golf, puede usar

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

Estructura de 39 caracteres en lugar de una estructura estándar que tiene 53 caracteres de longitud.

Python, puntaje 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 caracteres de código (líneas nuevas como 1 cada uno) - 2 para el número de entrada codificado + 36 caracteres de salida

Salida:

ffffffffffffffffgggggggggggggggggggg

Python, puntaje 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, puntaje 89 (63 - 2 + 28)

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

Conjetura: si el enfoque ingenuo descrito en mi solución original a continuación llega a un ciclo, ese ciclo será [21, 7, 15, 5, 10, 21, ...] . Como no hay contraejemplos para 1 ≤ n ≤ 10 ⁶ , parece probable que esto sea cierto. Para probar esto, sería suficiente demostrar que este es el único ciclo que puede existir, lo que puedo hacer o no en un momento posterior.

La solución anterior evita el ciclo inmediatamente, en lugar de adivinar (erróneamente) y evitarlo la segunda vez.

Salida (28 bytes):

ggfgfgfgfggfggfgfgfggfgfgfff

Perl, puntaje 100 (69 - 2 + 33)

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

Usando un enfoque de adivinar y verificar. La cadena se construye utilizando operaciones inversas (convirtiendo el valor a 1 , en lugar de al revés), y la cadena se refleja en consecuencia, lo que está permitido por la especificación del problema.

Siempre que se encuentre un no múltiplo de tres, se multiplicará por dos, agregando uno si el resultado sería un múltiplo de tres. Cuando se encuentra un múltiplo de tres, se dividirá entre tres ... a menos que este valor se haya encontrado previamente, lo que indica un ciclo, por lo tanto, adivina y verifica.

Salida (33 bytes):

ggfgfgfgfggfggfgffgfgggfggfgfgfff

J, puntaje 103 (82-2 + 23)

* Nota: nombré mis verbos fy g, para no confundirme con cadenas de salida fy g.

Codificado duro:

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

Funciones generales:

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

Eliminó la operación en bloques de números binarios, que fue el cambio más importante en cuanto a la compactación g. Cambié el nombre de las variables y eliminé algunos espacios en blanco por el gusto de hacerlo, pero todo sigue siendo funcionalmente igual. (Uso: g 41)

J, puntaje 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
)

Salida: ffffffffggggggggfgffggg

fconvierte una lista de booleanos en números, usando 0s como *3y 1s como /2(y floor). #:i.2^icrea una matriz de rango 2 que contiene todas las matrices booleanas de rango 1 de longitud i.