Tôi đã có một số mã giả Java sử dụng khoảng trắng thay vì dấu ngoặc nhọn và tôi muốn bạn chuyển đổi nó.

Tôi / O

Chương trình của bạn sẽ lấy một tệp đầu vào cùng với một số chỉ định có bao nhiêu khoảng trắng được sử dụng để thụt một khối. Đây là một ví dụ:

$ convert.lang input.p 4
// Chuyển đổi bằng cách sử dụng 4 khoảng trắng làm dấu phân cách khối
$ convert.lang input.p 2
// Chuyển đổi bằng cách sử dụng 2 khoảng trắng làm dấu phân cách khối

Sau đó, nó sẽ chuyển đổi kết quả bằng cách sử dụng dấu phân cách khối đã chỉ định và đưa kết quả ra thiết bị xuất chuẩn.

Thịt của chương trình

Các khối mở với :và mỗi dòng trong khối được thụt vào bằng cách sử dụng dấu phân cách khối, như mã Python.

trong khi (đúng):
    System.out.println ("Kiểm tra");

Mỗi cái :được thay thế bằng a {và a }được gắn vào cuối khối.

trong khi (đúng) {
    System.out.println ("Kiểm tra");
}

Ví dụ

Đầu vào:

Kiểm tra lớp học công cộng:
    public static void main (String [] args):
        System.out.println ("Java là dài dòng ...");

Đầu ra:

$ chuyển đổi Test.pseudojava 4
Kiểm tra lớp học công cộng {
    public static void main (String [] args) {
        System.out.println ("Java là dài dòng ...");
    }
}

Đầu vào:

chủ yếu():
  printf ("Xin chào thế giới");

Đầu ra:

$ chuyển đổi test.file 2
chủ yếu() {
  printf ("Xin chào thế giới");
}

Đầu vào:

def generic_op (the_stack, func):
    # Mã xử lý op chung
    b = the_stack.pop ()
    nếu isinstance (b, list):
        nếu b:
            trở về
        đầu = b.pop (0)
        trong khi b:
            đầu = func (đầu, b.pop (0))
        the_stack.push (trên cùng)
    khác:
        a = the_stack.pop ()
        trả về func (a, b)

Đầu ra:

$ convert code 4
def generic_op (the_stack, func) {
    # Mã xử lý op chung
    b = the_stack.pop ()
    nếu isinstance (b, list) {
        nếu b {
            trở về
        }
        đầu = b.pop (0)
        trong khi b {
            đầu = func (đầu, b.pop (0))
        }
        the_stack.push (trên cùng)
    }
    khác {
        a = the_stack.pop ()
        trả về func (a, b)
    }
}

Chấm điểm

Mã có số lượng byte ít nhất sẽ thắng!

Perl, 41 byte

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

Đếm shebang là hai, đầu vào được lấy từ stdin. Một đối số dòng lệnh không cần phải được cung cấp. Bất kỳ bối cảnh lồng hợp lệ có thể được xác định (và khớp) mà không cần biết kích thước thụt đầu dòng.

Sự cố Regex

( *)                   # 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)

Sử dụng mẫu

in1.dat

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

Đầu ra

$ 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");

Đầu ra

$ 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)

Đầu ra

$ 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 byte

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.

Thuật toán được sử dụng:

// bình toàn cầu
chuỗi tổng // tổng chương trình sửa đổi
int b // bộ đệm thụt lề

dòng thông qua dòng: // lặp đi lặp lại trên mỗi dòng
  chuỗi mline = "" // dòng được thêm vào tổng số

  // tính toán số lượng khoảng trắng trước dòng (có thể dễ dàng hơn rất nhiều)
  int space = 0 // tổng số khoảng trắng
  c thru line: // đi qua mọi ký tự trong dòng
    if c! = "": // nếu char hiện tại không phải là khoảng trắng (có nghĩa là chúng ta đã đi qua tất cả chúng
        phá vỡ // thoát ra khỏi vòng lặp thông qua ký tự
    dấu cách ++ // tăng khoảng trắng vì chúng ta đã nhấn dấu cách (hurr derr)

  if dấu cách / SPACE_SETTING <b: // nếu số lần thụt dòng của dòng hiện tại nhỏ hơn bộ đệm thụt lề
    mline = "} \ n" + line // thêm khung đóng vào đầu dòng
    b-- // bộ đệm giảm dần

  if line.endswith (":"): // nếu dòng kết thúc bằng một `:`
    xóa: khỏi dòng
    mline + = "{" // nối thêm {
    b ++ // bộ đệm tăng
  tổng + = mline // thêm dòng sửa đổi vào tổng

in (tổng cộng)

Ruby, 70

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

Thêm một dòng mới. Không cần tham số kích thước khối thụt lề.

Chạy cái này với -n0(cái này thực sự là 68 + 2). Cảm ơn bạn rất nhiều đến @primo vì đã tiết kiệm được hơn một chục byte.