จบแท็บกับสงครามอวกาศ

ดังนั้นจึงมีการถกเถียงกันอย่างมากว่าจะใช้แท็บหรือช่องว่างเพื่อเยื้อง / จัดรูปแบบโค้ด คุณสามารถช่วยมหาวิทยาลัยตัดสินข้อพิพาทโดยไปที่วิธีการจัดรูปแบบที่ไม่ซ้ำกัน อย่างบ้าคลั่งอย่างไม่น่าเชื่อ

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! 

ตัวอย่างผลลัพธ์

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! 

เนื่องจากมหาวิทยาลัยต้องการพื้นที่ในการดาวน์โหลดทั้ง Vim และ Emacs คุณจึงได้รับอนุญาตให้ใช้พื้นที่เก็บข้อมูลเพียงเล็กน้อยสำหรับโค้ดของคุณ ดังนั้นนี่คือcode-golfและรหัสที่สั้นที่สุดชนะ คุณอาจสมมติว่าอินพุตมีรูปแบบที่ดีและบรรทัดที่มีช่องว่างน้อยกว่าสี่ช่อง (หลังจากแทนที่แท็บ) อาจส่งผลให้เกิดพฤติกรรมที่ไม่ได้กำหนด

คำปฏิเสธ

กลยุทธ์การจัดรูปแบบ "ยอดเยี่ยม" นี้ได้รับความอนุเคราะห์จาก Geobits และทำซ้ำโดยได้รับอนุญาต ไม่มีโปรแกรมเมอร์คนใดได้รับอันตรายในระหว่างการสร้างความท้าทายนี้

V , 21 , 20 ไบต์

Íô/    
Î^hr/hv0r*r/

ลองออนไลน์!

นี่เป็นเพียงพอร์ตโดยตรงของคำตอบกลุ่มของฉัน ความแตกต่างที่โดดเด่น:

• Íคำสั่ง (แทนทั่วโลก) เติมโดยอัตโนมัติใน/gธงซึ่งจะช่วยประหยัดไบต์ที่สอง

• ô เหมือนกันกับ \t

• Îเป็นตัวช่วยจำสำหรับ:%normและยังเติมในช่องว่างที่จำเป็นระหว่าง:%normและชุดของการกดแป้น

• มีการเพิ่มการรับคืนส่วนท้ายที่ส่วนท้ายโดยนัย

เป็นกลุ่ม, 37, 34, 33, 32 ไบต์

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

ลองออนไลน์!

โปรดทราบว่าการทำเช่นนี้จะต้องใช้การส่งคืนส่วนท้าย (ป้อน) เป็นกลุ่มแม้ว่าจะไม่ได้อยู่ในล่ามออนไลน์

วิธีนี้ใช้ล่าม V เพราะเข้ากันได้ย้อนหลัง ทางออกที่ตรงไปตรงมามาก

นี่คือ gif ที่ช่วยให้คุณเห็นการแก้ปัญหาที่เกิดขึ้นในเวลาจริง นี่ใช้รุ่นที่เก่ากว่าเล็กน้อยและฉันได้เพิ่มการกดแป้นพิเศษบางอย่างเพื่อให้ทำงานช้าลงเพื่อให้คุณเห็นสิ่งที่เกิดขึ้น:

และนี่คือคำอธิบายวิธีการทำงาน:

:%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 ไบต์

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

วิ่งด้วย-pธงเช่นนี้

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

แทนที่␉ด้วยแท็บ (ใน Bash ลองพิมพ์Control-V Tab)

เนยแข็งชนิดหนึ่ง , 60 57 56 ไบต์

บันทึกแล้ว 3 ไบต์ขอบคุณ @Conor O'Brien

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

ฉันหวังว่า Cheddar จะมีการจัดรูปแบบสตริงที่ดีกว่า

ลองออนไลน์!

คำอธิบาย

นี่คือฟังก์ชั่น @เป็นคุณสมบัติที่แสดงหน้าที่ (เช่น ruby &:) ให้คุณทำสิ่งต่าง ๆ เช่น: `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
 )

หากคุณไม่คุ้นเคยกับ regex:

/^ +/gm

โดยทั่วไปจะจับคู่หนึ่ง+ช่องว่างหรือมากกว่า ( ) ที่จุดเริ่มต้น ( ^) ของทุกgบรรทัด ( m)

Mathematica, 97 ไบต์

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

ฟังก์ชั่นไม่ระบุชื่อ รับสตริงเป็นอินพุตและส่งคืนสตริงเป็นเอาต์พุต

Python 3, 124 ไบต์

ใช้ regex ที่ดี

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

ไอเดียมัน!

Java 210 207 ไบต์

นี่คือโซลูชันอ้างอิงที่ใช้งานอย่างไร้เดียงสา

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 ไบต์

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

แทนที่\tด้วยแท็บตัวอักษรในรหัสของคุณ

Java, 185 184 167 152 ไบต์

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;})

เนื่องจากนิยามของสตริงอาเรย์ที่หลวมมากในโพสต์เริ่มต้นฉันได้ใช้Stream<String>ซึ่งทำให้สามารถประหยัดไบต์ได้

ฉันใช้เทคนิคที่แตกต่างจาก RI เพื่อให้บรรลุเป้าหมายเดียวกัน อัลกอริทึมนั้นค่อนข้างเหมือนกัน

การทดสอบและ ungolfed :

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


  }
}

เรติน่า 25 ไบต์

\tควรจะถูกแทนที่ด้วยตัวแท็บจริง (0x09)

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

ลองออนไลน์!

คำอธิบาย

\t
4$* 

แทนที่แต่ละแท็บด้วยช่องว่างสี่ช่อง

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

แปลงแต่ละบรรทัดแยก ( %) โดยการจับคู่2+Nช่องว่างที่จุดเริ่มต้นของบรรทัดและแทนที่ด้วย/.../ที่...เป็นสำเนาN*

Python ขนาด125 111 ไบต์

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 สำหรับ -r) 57

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

⇥แท็บอยู่ที่ไหน
1. แทนที่แท็บด้วยช่องว่าง
2. /แทนที่แรกและครั้งสุดท้ายพื้นที่ชั้นนำที่มี
3. แทนที่ช่องว่างแรกหลังจาก/และ 0+ *ด้วย*จนกว่าจะไม่มีการแข่งขัน

มหาวิทยาลัยควรพิจารณาอนุญาตให้เพิ่มพื้นที่สำหรับโปรแกรมใน Emacs Lisp (หรือเป็นค่าเริ่มต้นtabifyและuntabifyคนเดียว) เนื่องจากพวกเขาได้รับ verbose มากกว่า Java นอกจากนี้ควรให้ความสำคัญกับนักเรียน (หรือครู) ที่มีขนาดตัวตนน้อยกว่าสี่คนหรือผู้ที่เกิดรหัสในภาษาที่ไม่เหมือนกับ C

วิธีแก้ไขปัญหาต่อไปนี้มี206 ไบต์

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

สมมติว่าtab-widthไม่จำเป็นต้องตั้งค่าอย่างชัดเจนเราสามารถบันทึกได้ 20 รายการ

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

และรุ่นที่ไม่ดีจะมีลักษณะเช่นนี้

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

เราเริ่มuntabifyภาคก่อนที่จะกระโดดเพื่อเริ่มต้น จากนั้นในขณะที่เราเห็นช่องว่างที่จุดเริ่มต้นของบรรทัดเราแทนที่ด้วยความคิดเห็นที่ตราบเท่าที่ช่องว่างดังกล่าว ความคิดเห็นที่จะแทรกถูกสร้างขึ้นโดย

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

ซึ่งตัวเองใช้เวลาถึง 97 ไบต์ โซลูชันที่สั้นลงเพื่อคัดลอกบางสตริง n ครั้งเป็นที่นิยมอย่างมาก

ทับทิม, 52 47 + 1 (p flag) = 48 ไบต์

แก้ไข : บันทึกทั้ง 5 ไบต์ด้วย Value Ink

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

GNU sed, 66 64 + 1 (แฟล็ก r) = 65 ไบต์

แก้ไข: 1 ไบต์น้อยลงขอบคุณคำแนะนำของRiley

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

รัน: sed -rf formatter.sed input_file

เหตุผลสำหรับการแยกกับการให้\nพื้นที่ชั้นนำจากส่วนที่เหลือของข้อความในบรรทัดว่าเป็นเพราะมิฉะนั้น c ++ บรรทัดที่เริ่มต้นด้วยการแสดงความคิดเห็นเช่นนี้/* */จะกลายเป็น/*****/เป็นเส้นที่เรียบง่าย 4 ชอบหรือแม้กระทั่งs,^(/\**) ,\1*, s,^(/\**) ( */),\1*\2,เนื่องจาก sed ดำเนินการสคริปต์สำหรับแต่ละบรรทัดอินพุตจึงไม่\nถูกนำมาใช้ในพื้นที่รูปแบบในการอ่าน