Kết thúc các tab so với không gian chiến tranh

Vì vậy, đã có rất nhiều tranh luận về việc nên sử dụng các tab hoặc khoảng trắng để thụt lề / định dạng mã. Bạn có thể giúp các trường đại học giải quyết tranh chấp, bằng cách đi đến một phương pháp định dạng độc đáo vô cùng điên rồ .

---

Công việc của bạn là viết một chương trình hoặc chức năng đầy đủ để mở rộng tất cả các tab thành bốn không gian. Và sau đó thay thế một chuỗi n khoảng trắng bằng "/ (n - hai ngôi sao ở đây) /". Bạn sẽ nhận được đầu vào trên nhiều dòng ở bất kỳ định dạng hợp lý nào (mảng chuỗi đơn cho mỗi dòng mới. Mảng cột, v.v.)

---

Mẫu đầu vào xấu hổ bị đánh cắp . Lưu ý rằng vì các tab được mở rộng tự động thành bốn khoảng trắng trên SE, tôi biểu thị nó là ký tự "^", nhưng bạn cũng phải xử lý các tab (codepoint 0x09). Tất cả các ký tự "^" đại diện cho một bảng.

Calculate the value 256 and test if it's zero
If the interpreter errors on overflow this is where it'll happen
++++++++[>++++++++<-]>[<++++>-]
+<[>-<
    Not zero so multiply by 256 again to get 65536
    [>++++<-]>[<++++++++>-]<[>++++++++<-]
    +>[>
        # Print "32"
        ++++++++++[>+++++<-]>+.-.[-]<
    <[-]<->] <[>>
        # Print "16"
        +++++++[>+++++++<-]>.+++++.[-]<
<<-]] >[>
    # Print "8"
    ++++++++[>+++++++<-]>.[-]<
<-]<
# Print " bit cells\n"
+++++++++++[>+++>+++++++++>+++++++++>+<<<<-]>-.>-.+++++++.+++++++++++.<.
>>.++.+++++++..<-.>>-
Clean up used cells.
[[-]<]l
^this is preceded by a tab
^^two tabs
^^^three tabs etcetera! 

Sản lượng mẫu

Calculate the value 256 and test if it's zero
If the interpreter errors on overflow this is where it'll happen
++++++++[>++++++++<-]>[<++++>-]
+<[>-<
/**/Not zero so multiply by 256 again to get 65536
/**/[>++++<-]>[<++++++++>-]<[>++++++++<-]
/**/+>[>
/******/# Print "32"
/******/++++++++++[>+++++<-]>+.-.[-]<
/**/<[-]<->] <[>>
/******/# Print "16"
/******/+++++++[>+++++++<-]>.+++++.[-]<
<<-]] >[>
/**/# Print "8"
/**/++++++++[>+++++++<-]>.[-]<
<-]<
# Print " bit cells\n"
+++++++++++[>+++>+++++++++>+++++++++>+<<<<-]>-.>-.+++++++.+++++++++++.<.
>>.++.+++++++..<-.>>-
Clean up used cells.
[[-]<]l
/**/this is preceded by a tab
/******/two tabs
/**********/three tabs etcetera! 

---

Vì trường đại học cần không gian để tải xuống cả Vim và Emacs, bạn được phép lưu trữ rất ít cho mã của mình. Do đó, đây là môn đánh gôn và mã ngắn nhất sẽ thắng. Bạn có thể cho rằng đầu vào được hình thành tốt và các dòng có ít hơn bốn khoảng trắng (sau khi thay thế các tab) có thể dẫn đến hành vi không xác định.

Khước từ

Chiến lược định dạng "xuất sắc" này được cung cấp bởi Geobits và được sao chép lại với sự cho phép của anh ta. Không có lập trình viên nào bị tổn hại trong quá trình sản xuất thử thách này.

V , 21 , 20 byte

Íô/    
Î^hr/hv0r*r/

Hãy thử trực tuyến!

Đây thực sự chỉ là một cổng trực tiếp của câu trả lời vim của tôi. Sự khác biệt đáng chú ý:

• Các Ílệnh (Toàn cầu thay thế) sẽ tự động điền vào /glá cờ, mà tiết kiệm hai byte

• ô giống hệt với \t

• ÎLà một bản ghi nhớ cho :%norm, và nó cũng lấp đầy khoảng trống cần thiết giữa :%normvà bộ tổ hợp phím.

• Sự trở lại vận chuyển cuối cùng được thêm vào ngầm.

Vim, 37, 34, 33, 32 byte

:%s/\t/    /g|%norm ^hr/hv0r*r/

Hãy thử trực tuyến!

Lưu ý rằng điều này đòi hỏi một sự trở lại vận chuyển kéo dài (enter) trong vim, mặc dù không có trong trình thông dịch trực tuyến.

Cái này sử dụng trình thông dịch V vì nó tương thích ngược. Một giải pháp rất đơn giản.

Đây là một gif cho phép bạn thấy giải pháp xảy ra trong thời gian thực. Cái này sử dụng một phiên bản cũ hơn một chút và tôi đã thêm một số tổ hợp phím bổ sung để làm cho nó chạy chậm hơn để bạn có thể thấy điều gì xảy ra:

Và đây là lời giải thích về cách thức hoạt động của nó:

:%s/\t/    /g           "Replace every tab with 4 spaces
|                       "AND
%norm                   "On every line:
      ^                 "  Move to the first non-whitespace char
       h                "  Move one character to the left. If there is none, the command will end here.
         r/             "  Replace it with a slash
           h            "  Move to the left
            v0          "  Visually select everything until the first column
              r*        "  Replace this selection with asterisks
                r/      "  Replace the first character with a slash

Perl, 41 byte

s,␉,    ,g;s,^  ( +),/@{[$1=~y| |*|r]}/,

Chạy với -pcờ, như vậy:

perl -pe 's,␉,    ,g;s,^  ( +),/@{[$1=~y| |*|r]}/,'
#     ↑   └───────────────────┬───────────────────┘
#     1 byte               40 bytes

Thay thế ␉bằng một tab (trong Bash, hãy thử gõ Control-V Tab.)

Cheddar , 60 57 56 byte

Đã lưu 3 byte nhờ @Conor O'Brien

@.sub(/\t/g," "*4).sub(/^ +/gm,i->"/"+"*"*(i.len-2)+"/")

Tôi muốn Cheddar có định dạng chuỗi tốt hơn.

Hãy thử trực tuyến!

Giải trình

Đây là một chức năng. @là một thuộc tính có chức năng đại diện (ví dụ như ruby &:) cho phép bạn làm những việc như: `ar.map (@. head (-1))

@                      // Input
 .sub( /\t/g, " "*4)   // Replace tabs with four spaces
 .sub(
   /^ +/gm,            // Regex matches leading spaces
   i ->                // i is the matched leading spaces
     "/"+              // The / at the beginning
     "*"*(i.len-2)+    // Repeat *s i-2 times
     "/"                // The / at the end
 )

Nếu bạn không quen thuộc với regex, hãy:

/^ +/gm

điều này về cơ bản khớp với một hoặc nhiều +khoảng trắng ( ) khoảng trống ( ) ở đầu ( ^) của mọi gdòng ( m) ( ).

Toán học, 97 byte

a=StringReplace;a[a[#,"\t"->"    "],StartOfLine~~b:" "..:>"/"<>Table["*",StringLength@b-2]<>"/"]&

Chức năng ẩn danh. Lấy một chuỗi làm đầu vào và trả về một chuỗi là đầu ra.

Python 3, 124 byte

Sử dụng regex ol 'tốt.

import re
lambda I:re.sub('^\s*(?m)',lambda m:'/'+'*'*len(m.group()[:-2])+'/',re.sub('\t+',lambda g:' '*4*len(g.group()),I))

Nghĩa là nó!

Java 210 207 byte

Đây là giải pháp tham khảo thực hiện nó một cách ngây thơ.

void a(String[]a){for(String s:a){s=s.replaceAll("\t", "    ");String x,y="";int j,i=s.length()-(x=s.replaceAll("^\\s+", "")).length();if(i>3){y="/";for(j=0;j++<i-1;)y+="*";y+="/";}System.out.println(y+x);}}

JavaScript ES6, 75 byte

s=>s.replace(/\t/g,"    ").replace(/^ +/gm,k=>`/${"*".repeat(k.length-2)}/`)

Thay thế \tbằng một tab bằng chữ trong mã của bạn.

Java, 185 184 167 152 byte

S->S.map(s->{s=s.replace("\t","    ");String t=s.replaceAll("^ +","");int n=s.length()-t.length();if(n>3){s="/";for(;n-->2;)s+="*";s+="/"+t;}return s;})

Đưa ra định nghĩa rất lỏng lẻo của chuỗi chuỗi được đưa ra trong bài viết ban đầu, tôi đã sử dụng Stream<String>cho phép tiết kiệm byte do đó.

Tôi đã sử dụng các kỹ thuật khác với RI để đạt được cùng một mục tiêu. Các thuật toán chính nó là giống nhau.

Kiểm tra và không được phép :

import java.util.Arrays;
import java.util.stream.Stream;

public class Main {

  public static void main(String[] args) {
    StringStreamTransformer sst = lines -> lines.map(line -> {
      line = line.replace("\t","    ");
      String trimmed = line.replaceAll("^ +", "");
      int startingSpaces = line.length() - trimmed.length();
      if (startingSpaces > 3) {
        line = "/";
        for(;startingSpaces > 2; startingSpaces--) {
          line += "*";
        }
        line += "/" + trimmed;
      }
      return line;
    });


    Stream<String> lines = Arrays.stream(new String[]{
      "lots of spaces and tabs after\t\t    \t\t         \t\t\t\t\t",
      "no space",
      " 1 space",
      "  2 spaces",
      "   3 spaces",
      "    4 spaces",
      "     5 spaces",
      "      6 spaces",
      "       7 spaces",
      "        8 spaces",
      "\t1 tab",
      "\t\t2 tabs",
      "\t\t\t3 tabs"
    });
    sst.map(lines).map(s -> s.replace(" ", ".").replace("\t","-")).forEach(System.out::println);


  }
}

Võng mạc , 25 byte

Các \tnên được thay thế bằng một ký tự tab thực tế (0x09).

\t
4$* 
%`^  ( +)
/$.1$**/

Hãy thử trực tuyến!

Giải trình

\t
4$* 

Thay thế mỗi tab bằng bốn khoảng trắng.

%`^  ( +)
/$.1$**/

Chuyển đổi mỗi dòng riêng ( %) bằng cách kết hợp 2+Nkhoảng trắng ở đầu dòng và thay thế nó bằng /.../nơi ...là Nbản sao của *.

Python, 125 111 byte

lambda s:'\n'.join(('/'+(len(L.replace('\t',' '*4))-len(L.strip())-2)*'*'+'/'+L.strip(),L)[L[0]>' ']for L in s)

https://repl.it/DGyh/2

SED (56 + 1 cho -r) 57

s/⇥/    /g;tr;:r;s,^ ( *) ,/\1/,;T;:l;s,^(/\**) ,\1*,;tl

Trường hợp ⇥một tab
1. thay thế các tab bằng dấu cách.
2. thay thế không gian hàng đầu đầu tiên và cuối cùng với /.
3. thay thế khoảng /trắng đầu tiên sau và 0+ *s *cho đến khi không có kết quả khớp.

Trường đại học nên xem xét cho phép thêm một chút không gian cho các chương trình trong Emacs Lisp (hoặc mặc định tabifyvà untabifymột mình), vì chúng thậm chí còn dài dòng hơn Java. Nó cũng nên chú ý đến các sinh viên (hoặc giáo viên) có kích thước nhận dạng nhỏ hơn bốn hoặc những người tình cờ viết mã bằng một số ngôn ngữ không giống như C.

Giải pháp sau đây có 206 byte

(lambda (b e)(let((tab-width 4))(untabify b e)(goto-char b)(while(re-search-forward"^ +"e t)(replace-match(format"/%s/"(apply'concat(mapcar(lambda(x)"*")(number-sequence 1(-(length(match-string 0))2)))))))))

Giả sử rằng tab-widthkhông cần phải được thiết lập rõ ràng, chúng ta có thể lưu 20 trong số chúng.

(lambda(b e)(untabify b e)(goto-char b)(while(re-search-forward"^ +"e t)(replace-match(format"/%s/"(apply'concat(mapcar(lambda(x)"*")(number-sequence 1(-(length(match-string 0))2))))))))

Và phiên bản không có người trông sẽ như thế này

(defun end-tab-war (beg end)
  (let ((tab-width 4))
    (untabify beg end)
    (goto-char beg)
    (while (re-search-forward "^ +" end t)
      (replace-match
       (format
        "/%s/"
        (apply 'concat
               (mapcar (lambda(x) "*")
                       (number-sequence 1
                                        (- (length (match-string 0))
                                           2)))))))))

Chúng tôi đầu tiên untabifykhu vực trước khi bắt đầu. Sau đó, trong khi chúng ta thấy khoảng trắng ở đầu một dòng, chúng ta thay thế nó bằng một nhận xét dài như khoảng trắng đã nói. Nói chính xác, bình luận được chèn vào được xây dựng bởi

 (format"/%s/"(apply'concat(mapcar(lambda(x)"*")(number-sequence 1(-(length(match-string 0))2)))))

mà chính nó chiếm 97 byte. Một giải pháp ngắn hơn để sao chép một số chuỗi n lần được đánh giá cao.

Ruby, 52 47 + 1 (cờ p) = 48 byte

Chỉnh sửa : đã lưu toàn bộ 5 byte, nhờ vào Value Ink

ruby -pe 'gsub ?\t," "*4;sub(/^ +/){?/+?**($&.size-2)+?/}'

GNU sed, 66 64 + 1 (cờ r) = 65 byte

Chỉnh sửa: Giảm 1 byte nhờ đề xuất của Riley .

s/\t/    /g
s,^ ( *) ,/\1\n,
:
s,^(/\**) ( *\n),\1*\2,
t
s,\n,/,

Chạy: sed -rf formatter.sed input_file

Lý do để phân tách với một \nkhoảng trắng hàng đầu từ phần còn lại của văn bản trên dòng đó là bởi vì nếu không thì một dòng C ++ bắt đầu bằng một nhận xét như thế này /* */sẽ bị biến thành /*****/một dòng 4 đơn giản hơn s,^(/\**) ,\1*,hoặc thậm chí s,^(/\**) ( */),\1*\2,. Vì sed thực thi tập lệnh cho từng dòng đầu vào, nên không có phần nào \nđược đưa vào không gian mẫu khi đọc.