Java 7, 725 octets
f(int)( 325 octets ):
String f(int i){String s="";for(int j=0,e=0;e<i;e+=v(s))s=Integer.toBinaryString(j++);return"["+s.replace("1","[").replace("0","]")+"]";}int v(String s){for(;!s.isEmpty();s=s.replaceFirst("1","").replaceFirst("0",""))if(s.replace("1","").length()!=s.replace("0","").length()|s.charAt(0)<49|s.endsWith("1"))return 0;return 1;}
g(String)( 75 + 325 octets ):
int g(String s){int r=0;for(String i="10";!i.equals(s);i=f(++r));return r;}
Étant donné que la méthode gutilise la méthode fpour calculer son résultat en bouclant sur la liste de vides possible jusqu'à ce qu'elle trouve celui égal à celui entré, les octets de fsont comptés deux fois (car les deux méthodes devraient pouvoir s'exécuter sans l'autre pour ce défi).
Explication:
En général, la méthode fait fsimplement une boucle sur toutes les représentations binaires de chaînes d'entiers et augmente un compteur chaque fois qu'une valeur valide est trouvée. Les chaînes binaires valides pour ce défi sont conformes aux règles suivantes: elles commencent par un 1et se terminent par un 0; ils ont un nombre égal de 1 et de 0; et chaque fois que vous supprimez le premier 1et 0que vous validez ce qui reste, ces deux règles s'appliquent toujours. Une fois que le compteur est égal à l'entrée, il convertit cette chaîne binaire en une liste vide de chaînes, en remplaçant all 1with [et all 0with ].
Quant à la méthode g: nous commençons par "[]"(représentant void-list 0), puis continuons à utiliser la méthode ftout en augmentant un entier, jusqu'à ce qu'il corresponde à la chaîne d'entrée.
String f(int i){ // Method `f` with integer parameter and String return-type
String s=""; // Start with an empty String
for(int j=0,e=0;e<i; // Loop as long as `e` does not equal the input
e+=v(s)) // And append increase integer `e` if String `s` is valid
s=Integer.toBinaryString(j++);
// Change `s` to the next byte-String of integer `j`
// End of loop (implicit / single-line body)
return"["+ // Return the result String encapsulated in "[" and "]"
s.replace("1","[").replace("0","]")+"]";
// after we've replaced all 1s with "[" and all 0s with "]"
} // End of method `f`
int v(String s){ // Separate method with String parameter and integer return-type
for(;!s.isEmpty(); // Loop as long as String `s` isn't empty
s=s.replaceFirst("1","").replaceFirst("0",""))
// After each iteration: Remove the first "1" and "0"
if(s.replace("1","").length()!=s.replace("0","").length()
// If there isn't an equal amount of 1s and 0s
|s.charAt(0)<49 // or the String doesn't start with a 1
|s.endsWith("1")) // or the String doesn't end with a 0
return 0; // Return 0 (String is not valid)
// End of loop (implicit / single-line body)
return 1; // Return 1 (String is valid)
} // End of separate method
int g(String s){ // Method `g` with String parameter and integer return-type
int r=0; // Result integer
for(String i="[]";!i.equals(s);
// Loop as long as `i` does not equal the input String
i=f(++r)); // After each iteration: Set `i` to the next String in line
return r; // Return the result integer
} // End of method `g`
Exemples de cas d'entrée et de sortie:
Essayez-le ici. (REMARQUE: C'est assez lent pour les derniers cas de test. Cela prendra environ 10 à 15 secondes pour chacun d'eux.)
0 <-> []
1 <-> [[]]
2 <-> [[][]]
3 <-> [[[]]]
4 <-> [[][][]]
5 <-> [[][[]]]
6 <-> [[[]][]]
7 <-> [[[][]]]
8 <-> [[[[]]]]
9 <-> [[][][][]]
10 <-> [[][][[]]]
11 <-> [[][[]][]]
12 <-> [[][[][]]]
13 <-> [[][[[]]]]
14 <-> [[[]][][]]
50 <-> [[[][[[]]]]]
383 <-> [[[][]][[[][]]]]