Jede positive ganze Zahl kann erhalten werden, indem mit 1 begonnen und eine Folge von Operationen angewendet wird , von denen jede entweder "mit 3 multiplizieren" oder "durch 2 dividieren und den Rest verwerfen" ist .

Beispiele (Schreiben von f für * 3 und g für / 2):

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

Schreiben Sie ein Programm mit folgendem Verhalten:

Eingabe : jede positive ganze Zahl, über stdin oder fest codiert. (Wenn fest codiert, wird die Eingabezahl von der Programmlänge ausgeschlossen.)
Ausgabe : Eine Zeichenfolge von fs und gs, so dass <input> = 1 <string>(wie in den Beispielen). Eine solche Zeichenfolge in umgekehrter Reihenfolge ist ebenfalls akzeptabel. NB: Die Ausgabe enthält nur fs und gs oder ist leer.

Der Gewinner ist der Eintrag mit den wenigsten Bytes an Programm plus Ausgabe, wenn 41 die Eingabe ist.

GolfScript, Punktzahl 64 (43-2 + 23)

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

(41 ist fest codiert, daher -2 Zeichen für die Partitur). Die Ausgabe ist

fffgffggffggffgggffgggg

Das sind 23 Zeichen (ohne Zeilenumbruch). Durch die Konstruktion garantiert der Code, dass er immer (eine) der kürzesten Darstellungen zurückgibt.

Wir werden schmutzig, Freunde!

JAVA 210 207 199 Zeichen

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

Nicht Golf:

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

Ausgabe: Abhängig vom Glauben der alten Götter war die kürzeste, die ich hatte, 30. Beachten Sie, dass die Ausgabe von rechts gelesen werden muss.

234

1 ggfgfgfgfggfggfgffgfggggfgffgfggfgfggggfgffgfggfgfggfgfggfgfgggggfffgfggfgfggfgfgggffgggggfffgfggggfgffgfggfgfggfgfggfgfggfgfggfgfggfgfggggfgffgfggfgfggfgfggfgfggfgfggfgfggggggggggggfgfgfggggfgfgfggfffgfgfggffgfgfggfgfggggffgfgfffff

108

1 gggffgfgfggggggfggggfgffggggfgfgfgfgfgffgggfgggggfggfffggfgfffffgggffggfgfgggffggfgfgggffggggggfgfgffgfgfff

bearbeiten 45

1 ggfgfgfgfgggfggfffgfggfgfgggggggffgffgfgfff

Punkte: 318 199 + 30 = 229

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

Nota Bene, wenn Sie beim Golfen Java 6 und nicht Java 7 verwenden, können Sie verwenden

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

Struktur mit 39 Zeichen anstelle einer Standardstruktur mit 53 Zeichen.

Python, Punktzahl 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 Zeichen Code (Zeilenumbrüche jeweils 1) - 2 für fest codierte Eingabezahlen + 36 Zeichen Ausgabe

Ausgabe:

ffffffffffffffffgggggggggggggggggggg

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

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

Vermutung: Wenn der in meiner ursprünglichen Lösung unten beschriebene naive Ansatz jemals einen Zyklus erreicht, wird dieser Zyklus [21, 7, 15, 5, 10, 21, ...] sein . Da es keine Gegenbeispiele für 1 ≤ n ≤ 10 ^{6 gibt} , scheint dies wahrscheinlich zu stimmen. Um dies zu beweisen, würde es genügen zu zeigen, dass dies der einzige Zyklus ist, derexistieren kann , was ich zu einem späteren Zeitpunkt tun kann oder nicht.

Die obige Lösung vermeidet den Zyklus sofort, anstatt (falsch) zu raten und ihn beim zweiten Mal zu vermeiden.

Ausgabe (28 Bytes):

ggfgfgfgfggfggfgfgfggfgfgfff

Perl, Punktzahl 100 (69 - 2 + 33)

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

Verwenden eines Guess-and-Check-Ansatzes. Die Zeichenfolge wird mithilfe inverser Operationen erstellt (Konvertieren des Werts in 1 statt umgekehrt), und die Zeichenfolge wird entsprechend gespiegelt, was in der Problemspezifikation zulässig ist.

Immer wenn ein Nicht-Vielfaches von drei angetroffen wird, wird es mit zwei multipliziert und eins addiert, wenn das Ergebnis dann ein Vielfaches von drei wäre. Wenn ein Vielfaches von drei angetroffen wird, wird es durch drei geteilt ... es sei denn, dieser Wert wurde zuvor angetroffen, was auf einen Zyklus hinweist, also Vermutung und Überprüfung.

Ausgabe (33 Bytes):

ggfgfgfgfggfggfgffgfgggfggfgfgfff

J, Punktzahl 103 (82-2 + 23)

* Hinweis: Ich habe meine Verben benannt fund gdarf nicht mit Ausgabezeichenfolgen fund verwechselt werden g.

Fest codiert:

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

Allgemeine Funktionen:

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

Die Bearbeitung von Binärzahlblöcken wurde abgeschafft, was die wichtigste Änderung in Bezug auf die Komprimierung war g. Variablen umbenannt und zum Teufel einige Leerzeichen entfernt, aber funktionell ist immer noch alles gleich. (Verbrauch: g 41)

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

Ausgabe: ffffffffggggggggfgffggg

fkonvertiert eine Liste von Booleschen Werten in Zahlen, wobei 0s als *3und 1s als /2(und floor) verwendet werden. #:i.2^iErstellt ein Array mit Rang 2, das alle booleschen Arrays mit Rang 1 enthält i.