Ich habe einen Java-Pseudocode, der Leerzeichen anstelle von geschweiften Klammern verwendet, und ich möchte, dass Sie ihn konvertieren.

I / O.

Ihr Programm sollte eine Eingabedatei zusammen mit einer Zahl verwenden, die angibt, wie viele Leerzeichen zum Einrücken eines Blocks verwendet werden. Hier ist ein Beispiel:

$ convert.lang input.p 4
// Konvertiere mit 4 Leerzeichen als Blocktrennzeichen
$ convert.lang input.p 2
// Konvertiere mit 2 Leerzeichen als Blocktrennzeichen

Anschließend sollte das Ergebnis mit dem angegebenen Blocktrennzeichen konvertiert und das Ergebnis in stdout ausgegeben werden.

Das Fleisch des Programms

Blöcke, die mit :und jede Zeile innerhalb des Blocks geöffnet werden, werden mit dem Blocktrennzeichen wie Python-Code eingerückt.

während (wahr):
    System.out.println ("Test");

Jedes :wird durch a ersetzt {und a }wird an das Ende des Blocks angehängt.

while (wahr) {
    System.out.println ("Test");
}}

Beispiele

Eingang:

öffentlicher Klassentest:
    public static void main (String [] args):
        System.out.println ("Java ist ausführlich ...");

Ausgabe:

$ convert Test.pseudojava 4
öffentlicher Klassentest {
    public static void main (String [] args) {
        System.out.println ("Java ist ausführlich ...");
    }}
}}

Eingang:

Main():
  printf ("Hallo Welt");

Ausgabe:

$ convert test.file 2
main () {
  printf ("Hallo Welt");
}}

Eingang:

def generic_op (the_stack, func):
    # Generischer Op-Handling-Code
    b = the_stack.pop ()
    wenn isinstance (b, Liste):
        wenn b:
            Rückkehr
        top = b.pop (0)
        während b:
            top = func (top, b.pop (0))
        the_stack.push (oben)
    sonst:
        a = the_stack.pop ()
        Rückgabefunktion (a, b)

Ausgabe:

$ convert code.py 4
def generic_op (the_stack, func) {
    # Generischer Op-Handling-Code
    b = the_stack.pop ()
    if isinstance (b, Liste) {
        wenn b {
            Rückkehr
        }}
        top = b.pop (0)
        während b {
            top = func (top, b.pop (0))
        }}
        the_stack.push (oben)
    }}
    sonst {
        a = the_stack.pop ()
        Rückgabefunktion (a, b)
    }}
}}

Wertung

Der Code mit der geringsten Anzahl von Bytes gewinnt!

Perl, 41 Bytes

#!perl -p0
1while s/( *).*\K:((
\1 .*)+)/ {\2
\1}/

Wenn man den Shebang als zwei zählt, wird die Eingabe von stdin übernommen. Ein Befehlszeilenargument muss nicht angegeben werden. Jeder gültige Verschachtelungskontext kann ermittelt (und abgeglichen) werden, ohne die Einrückungsgröße zu kennen.

Regex-Zusammenbruch

( *)                   # as many spaces as possible (\1)
    .*                 # as many non-newline characters as possible \
                         (greediness ensures this will always match a full line)
      \K               # keep all that (i.e. look-behind assertion)
        :              # colon at eol (newline must be matched next)
         (
          (
           \n\1        # newline with at least one more space than the first match
                .*     # non-newlines until eol
                  )+   # as many of these lines as possible
                    )  # grouping (\2)

Beispielnutzung

in1.dat

public class Test:
    public static void main(String[] args):
        System.out.println("Java is verbose...");

Ausgabe

$ perl py2java.pl < in1.dat
public class Test {
    public static void main(String[] args) {
        System.out.println("Java is verbose...");
    }
}

in2.dat

main():
  printf("Hello World");

Ausgabe

$ perl py2java.pl < in2.dat
main() {
  printf("Hello World");
}

in3.dat

def generic_op(the_stack, func):
    # Generic op handling code
    b = the_stack.pop()
    if isinstance(b, list):
        if b:
            return
        top = b.pop(0)
        while b:
            top = func(top, b.pop(0))
        the_stack.push(top)
    else:
        a = the_stack.pop()
        return func(a, b)

Ausgabe

$ perl py2java.pl < in3.dat
def generic_op(the_stack, func) {
    # Generic op handling code
    b = the_stack.pop()
    if isinstance(b, list) {
        if b {
            return
        }
        top = b.pop(0)
        while b {
            top = func(top, b.pop(0))
        }
        the_stack.push(top)
    }
    else {
        a = the_stack.pop()
        return func(a, b)
    }
}

Python 3, 299 265 Bytes

import sys;s=int(sys.argv[2]);t="";b=0
for l in open(sys.argv[1]):
 h=l;g=0
 for c in l:
  if c!=" ":break
  g+=1
 if g/s<b:h=" "*g+"}\n"+h;b-=1
 if l.strip().endswith(":"):h=l.split(":")[0];h+=" {";b+=1
 t+=h+"\n"
b-=1
while b>-1:
 t+=" "*(b*s)+"}\n"b-=1
print(t)

Boom bam pow.

Verwendeter Algorithmus:

// globale vars
string total // total modifiziertes Programm
int b // Puffer einrücken

Zeile durch Zeilen: // über jede Zeile iterieren
  string mline = "" // Zeile, die zur Gesamtsumme hinzugefügt werden soll

  // Berechne die Anzahl der Leerzeichen vor der Zeile (könnte viel einfacher sein)
  int Leerzeichen = 0 // Gesamträume
  c durch Zeile: // gehe jedes Zeichen in der Zeile durch
    if c! = "": // wenn das aktuelle Zeichen kein Leerzeichen ist (was bedeutet, dass wir alle durchgesehen haben
        break // Durchbrechen der Iteration durch Zeichen
    Leerzeichen ++ // Inkrementiere die Leerzeichen, weil wir ein Leerzeichen getroffen haben (hurr derr)

  if Leerzeichen / SPACE_SETTING <b: // wenn die Anzahl der Einrückungen der aktuellen Zeile kleiner als der Einrückungspuffer ist
    mline = "} \ n" + line // schließende Klammer am Zeilenanfang hinzufügen
    b-- // Puffer dekrementieren

  if line.endswith (":"): // wenn die Zeile mit einem `:` endet
    entfernen: aus der Zeile
    mline + = "{" // anhängen {
    b ++ // Puffer erhöhen
  total + = mline // Geänderte Zeile zu total hinzufügen

drucken (gesamt)

Ruby, 70

x=$_+"
"
1while x.sub! /^(( *).*):
((\2 .*?
)*)/,'\1 {
\3\2}
'
$><<x

Fügt einen nachgestellten Zeilenumbruch hinzu. Benötigt nicht den Parameter für die Blockgröße des Einzugs.

Führen Sie dies mit -n0(das ist wirklich 68 + 2). Vielen Dank an @primo für das Speichern von über einem Dutzend Bytes.