Java 7, 725 byte
f(int)( 325 byte ):
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 byte ):
int g(String s){int r=0;for(String i="10";!i.equals(s);i=f(++r));return r;}
Poiché il metodo gutilizza il metodo fper calcolare il risultato eseguendo il ciclo su un possibile elenco vuoto fino a quando non trova quello uguale a quello immesso, i byte di fvengono conteggiati due volte (poiché entrambi i metodi dovrebbero essere in grado di funzionare senza l'altro per questa sfida).
Spiegazione:
In generale, il metodo fesegue semplicemente il ciclo su tutte le rappresentazioni binarie di stringhe di numeri interi e aumenta un contatore ogni volta che ne viene trovato uno valido. Le stringhe binarie valide per questa sfida sono conformi alle seguenti regole: iniziano con a 1e finiscono con a 0; hanno un numero uguale di 1 e 0; e ogni volta che rimuovi il primo 1e 0convalidi ciò che resta, queste due regole si applicano comunque. Dopo che il contatore è uguale all'input, converte quella stringa binaria in una lista vuota stringa, sostituendo tutto 1con [e tutto 0con ].
Per quanto riguarda il metodo g: iniziamo con "[]"(che rappresenta l'elenco vuoto 0), quindi continuiamo a utilizzare il metodo faumentando un numero intero, finché non corrisponde alla stringa di input.
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`
Esempi di casi di input e output:
Provalo qui. (NOTA: è piuttosto lento per gli ultimi casi di test. Ci vorranno circa 10-15 secondi per tutti.)
0 <-> []
1 <-> [[]]
2 <-> [[][]]
3 <-> [[[]]]
4 <-> [[][][]]
5 <-> [[][[]]]
6 <-> [[[]][]]
7 <-> [[[][]]]
8 <-> [[[[]]]]
9 <-> [[][][][]]
10 <-> [[][][[]]]
11 <-> [[][[]][]]
12 <-> [[][[][]]]
13 <-> [[][[[]]]]
14 <-> [[[]][][]]
50 <-> [[[][[[]]]]]
383 <-> [[[][]][[[][]]]]