Java 7, 725 Bytes
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;}
Da die Methode gdie Methode verwendet f, um das Ergebnis zu berechnen, indem sie eine mögliche Leerenliste durchläuft, bis diejenige gefunden wird, die der eingegebenen entspricht, den Bytes vonf zweimal gezählt (da beide Methoden für diese Herausforderung ohne die andere ausgeführt werden sollten).
Erläuterung:
Im Allgemeinen fdurchläuft die Methode einfach alle binären String-Darstellungen von Ganzzahlen und erhöht einen Zähler jedes Mal, wenn ein gültiger gefunden wird. Gültige Binär-Strings für diese Challenge entsprechen den folgenden Regeln: Sie beginnen mit einem 1und enden mit einem 0; Sie haben die gleiche Anzahl von Einsen und Nullen. und jedes Mal , entfernen Sie das erste 1und 0und validieren , was wieder verlassen, werden diese beiden Regeln gelten weiterhin . Nachdem der Zähler der Eingabe entspricht, konvertiert er diesen Binär-String in eine String-Leerenliste, indem er all 1mit [und all 0mit ersetzt] .
Was die Methode betrifft g: Wir beginnen mit "[]"(Darstellung der Leerenliste 0) und verwenden die Methode dann weiter, fwährend eine Ganzzahl erhöht wird, bis sie mit der Eingabezeichenfolge übereinstimmt.
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`
Beispiel für Eingabe- und Ausgabefälle:
Probieren Sie es hier aus. (HINWEIS: In den letzten paar Testfällen ist es ziemlich langsam. Für alle dauert es ungefähr 10-15 Sekunden.)
0 <-> []
1 <-> [[]]
2 <-> [[][]]
3 <-> [[[]]]
4 <-> [[][][]]
5 <-> [[][[]]]
6 <-> [[[]][]]
7 <-> [[[][]]]
8 <-> [[[[]]]]
9 <-> [[][][][]]
10 <-> [[][][[]]]
11 <-> [[][[]][]]
12 <-> [[][[][]]]
13 <-> [[][[[]]]]
14 <-> [[[]][][]]
50 <-> [[[][[[]]]]]
383 <-> [[[][]][[[][]]]]