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

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

\
 \
  \
  /
 /
 \
 /
 \
  \

นี่คือคำอธิบายบางอย่าง:

• จะต้องมีหนึ่งสแลชต่อบรรทัด

• บรรทัดแรกจะมีช่องว่างนำหน้า 0 ช่อง

• สำหรับเครื่องหมายสแลชแต่ละคู่:

  • หากพวกเขาแตกต่างกันพวกเขาจะถูกดึงในคอลัมน์เดียวกัน ตัวอย่างเช่น\/จะให้:

    \
    /
    

  • หากพวกเขาเป็นตัวละครเดียวกันตัวล่างจะอยู่ในทิศทางที่ชี้ไปนั่นคือการย้ายไปทางขวาสำหรับแบ็กสแลชและย้ายไปทางซ้ายสำหรับสแลชข้างหน้า ดังนั้น\\//จะให้

    \
     \
     /
    /
    

• แต่ละบรรทัดอาจมีช่องว่างต่อท้ายพิเศษตราบใดที่สิ่งนี้ไม่เปลี่ยนลักษณะที่ปรากฏของเอาต์พุต ขึ้นอยู่กับการขึ้นบรรทัดใหม่และการขึ้นบรรทัดใหม่ชั้นนำด้วยเช่นกัน ไม่อนุญาตให้เว้นวรรคนำหน้า!

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

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

คุณอาจจะส่งออกโดยใด ๆรูปแบบที่เหมาะสม

ตามปกตินี่เป็นความท้าทายของการเล่นกอล์ฟดังนั้นพยายามแก้ปัญหาให้สั้นที่สุดแม้ว่าคุณจะเลือกภาษาที่ค่อนข้างยาก คะแนนโบนัสสำหรับการอธิบายเทคนิคที่น่าสนใจใด ๆ ที่คุณใช้ในการถอดไบต์!

ตัวอย่าง

#Input
\\\\\\\\\\\

#Output
\
 \
  \
   \
    \
     \
      \
       \
        \
         \
          \

#Input
\\\//\\/\//\\///

#Output
\
 \
  \
  /
 /
 \
  \
  /
  \
  /
 /
 \
  \
  /
 /
/


#Input
\/\/\/

#Output
\
/
\
/
\
/

GNU Sed, 20

s|\\|&^L|g
s|/|^H/^L^H|g

โปรดทราบว่า^Lและ^Hเป็นตัวอักษรป้อนกระดาษและอักขระถอยกลับ (0x12 และ 0x8)

คำตอบนี้ใช้ได้โดยเลื่อนเคอร์เซอร์ไปรอบ ๆ โดยใช้ backspace และอักขระป้อนกระดาษ เครื่องหมายทับขวา / แบ็กสแลชไม่ได้ถูกทิ้งไว้ด้วยช่องว่าง - ไม่แน่ใจว่าสิ่งนี้ตัดสิทธิ์คำตอบนี้ นี้ไม่ได้ทำงานใน TIO แต่มันดูดีภายใต้อาคารทั่วไปเช่นและxtermgnome-terminal

สร้างสคริปต์ sed นี้ใหม่ดังนี้:

base64 -d <<< c3xcXHwmDHxnCnN8L3wILwwIfGc= > downslash.sed

เรียกใช้ดังนี้:

$ echo '\\\//\/\\' | sed -f downslash.sed
\ 
 \ 
  \ 
  /
 /
 \ 
 /
 \ 
  \ 

$ 

คำอธิบาย:

s|\\|&^L|g     # move cursor down after every "\"
s|/|^H/^L^H|g  # move cursor left before every "/", then after, down and left again

ถ่าน , 13 12 11 ไบต์

ＦＳ¿⁼ι/↓¶/↘ι

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด รองรับ//s พิเศษ คำอธิบาย:

 Ｓ              Input string
Ｆ               Loop over each character
  ¿             If
    ι           Current character
   ⁼            Equals
     /          Literal /
      ↓¶        Move left
      ↓ /       Print a / downwards
         ↘ι     Else it's a \ so print that down and right

Python 2 , 55 54 51 57 53 ไบต์

^{-3 ไบต์ (และการแก้ไขข้อผิดพลาด) ต้องขอบคุณ Felipe Nardi Batista}

i=0
for c in input():i-=c<'<'*i;print' '*i+c;i+=c>'<'

ลองออนไลน์!

/// , 119 ไบต์

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

/=/\/\///M/
|%%=N/%|||=C/BA=\/\\/\/C\\=C\\/CbC=B\A\=CfC=AB=/A/%Mxy=B/|z%N|x|y% %N%x|y%%% |fzN%M%b|zN|M|%
=|/AB\\=%/|=AC

• ลองออนไลน์!
• ด้วย-dตัวเลือก (สถานะโปรแกรมที่แสดงในวงเล็บเหลี่ยมก่อนที่จะรันคำสั่งแต่ละคำสั่ง)

มันทำงานอย่างไร

• ในสิ่งต่อไปนี้อินพุตของ\\/\//จะถูกผนวกเข้ากับโปรแกรมสำหรับการสาธิต
• ␤ ใช้เพื่อแสดงบรรทัดใหม่ในโค้ดอินไลน์

ตัวย่อ

จุดเริ่มต้น/=/\/\///M/␤|%%=N/%|||=C/BA=ของโปรแกรมประกอบด้วยการเปลี่ยนตัวอักษรย่อของการเล่นกอล์ฟ

• =ขยาย//, Mการ␤|%%, Nการ%|||และการCBA

• หลังจากนี้โปรแกรมปัจจุบันจะกลายเป็น

  /\/\\/\/BA\\//BA\\/BAbBA//B\A\//BAfBA//AB///A/%
  |%%xy//B/|z%%||||x|y% %%|||%x|y%%% |fz%|||%
  |%%%b|z%||||
  |%%|%
  //|/AB\\//%/|//ABA\\/\//
  

อินพุตการบันทึก

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

• การเปลี่ยนตัวผู้เล่นที่สำคัญครั้งแรก/\/\\/\/BA\\/แทนที่สตริงด้วย /\/BA\
  • โปรแกรมพื้นฐานไม่ได้มี/\อยู่ในขณะนี้ดังนั้นการแทนที่นี้จะไม่ส่งผลกระทบต่อมัน
  • อย่างไรก็ตามสิ่งนี้จะแยกสตริงอินพุตที่ต่อท้ายออกเป็นซีเควนซ์ของ\s ตามด้วยซีเควนซ์ของ/s ซึ่งเมื่อรวมกับABAตอนท้ายของโปรแกรมพื้นฐานทำให้สามารถวนซ้ำได้ด้วยการแทนที่ต่อไปนี้
  • รวมทั้งคำนำหน้าก่อนที่มันจะสายป้อนตัวอย่างตอนนี้กลายเป็นABAABA\\/BA\//
• การเปลี่ยนตัวผู้เล่นถัดไป/BA\\/BAbBA/แทนที่โดย BA\BAbBA
  • เนื่องจาก /// การแทนที่ซ้ำแล้วซ้ำอีกจนกว่าจะไม่ตรงกันอีกต่อไปมันวนซ้ำทั้งหมด\ของสตริงอินพุตซึ่งตอนนี้มีคำนำหน้ากลายเป็นABAbBAbBA/BAbBA//
• ในทำนองเดียวกัน/B\A\//BAfBA/การเปลี่ยนแปลงBA/การBAfBAวนซ้ำผ่าน/s
  • การหลบหนี\ในการเปลี่ยนตัวครั้งนี้มีความจำเป็นเพราะไม่เช่นนั้นมันจะถูกทำลายโดยอันก่อน
  • ABAbBAbBAfBABAbBAfBAfBAการป้อนข้อมูลได้หันตอนนี้เป็น
• ถัดไปเอาชิ้นส่วนฟุ่มเฟือยบางส่วนของการเข้ารหัสที่เปลี่ยนมันเป็น /AB//AbBAbBAfBAbBAfBAfBA
  • สิ่งนี้ยังลบการแทนที่ABจากใน/|/AB\\/ภายหลังในโปรแกรมซึ่งจำเป็นต้องปกป้องมันจากการ/\จัดการข้างต้น
  • ณ จุดนี้ทุกคน\ในสายป้อนต้นฉบับได้กลายเป็นที่AbBและทุกได้กลายเป็น/ AfB( bและfยืนสำหรับถอยหลังและไปข้างหน้า) มีเร่ร่อนAที่ปลาย
• การแทนที่สองครั้งถัดไปจะแทนที่As และBs ทั้งหมดด้วยแฟรกเมนต์ของโปรแกรมเพื่อรันในสเตจสุดท้าย ในสตริงการแทนที่%s และ|s เข้ารหัสสิ่งที่จะกลายเป็น/s และ\s ตามลำดับ นี่มีสองประโยชน์:
  • ซึ่งแตกต่าง/และ\ที่%และ|s ไม่จำเป็นต้องหนีที่จะคัดลอก
  • สตริงการแทนที่หลีกเลี่ยงการมีซับสตริง/\ซึ่งจะถูก mangled โดยกิจวัตรก่อนหน้านี้
• หลังจากนี้การแทนที่/|/\\/(เดิม/|/AB\\/) จะถอดรหัส|s หลังจากนั้นสิ่งต่อไปนี้/%/|//ได้กลายเป็น/%/\//และถอดรหัส%s

โครงสร้างโปรแกรมในระยะสุดท้าย

ณ จุดนี้โปรแกรมฐานรันการแทนที่ทั้งหมดและสิ่งที่เหลืออยู่คือการเข้ารหัสโปรแกรมของสตริงอินพุต

• อักขระอินพุตแต่ละรายการกลายเป็นโปรแกรมย่อย

  /
  \//xy*\z//\\\\x\y/ //\\\/x\y/// \fz/\\\/
  \///b\z/\\\\
  \//\/
  

  (ลากขึ้นบรรทัดใหม่) ซึ่ง*หมายถึงทั้งfการเดิม/หรือการเดิมb\

• นอกจากนี้ยังมีคำสั่งการแทนที่ที่ไม่สมบูรณ์/␤\//xyในตอนท้ายของโปรแกรมซึ่งจะไม่มีผลกระทบใด ๆ ยกเว้นการจัดเตรียมที่จำเป็น/สำหรับการทดแทนโปรแกรมย่อยก่อนหน้านี้

สตริงย่อยที่แชร์

\/␤/ก่อนที่จะมีการทำซ้ำสุดท้ายผ่านโปรแกรมย่อยเริ่มมีการย่อยข้ามเขตแดนหลังจากโปรแกรมย่อยของตัวละครแต่ละรูปแบบ

• สตริงย่อยเหล่านี้ใช้เป็นสถานะโกลบอลที่แบ่งใช้ ทั้งหมดแทนที่เหลืออยู่ในโปรแกรมจะจัดการกับพวกเขาเหมือนกันและในแบบคู่ขนานดังกล่าวว่าตอนท้ายของแต่ละป้อนตัวอักษรของโปรแกรมย่อยสำเนาของสตริงย่อยที่ใช้ร่วมกันนี้ (ยกเว้นสุดท้าย/ซึ่งเบรกแทน) จะถูกเรียกใช้ในการพิมพ์เส้นที่ ตัวละคร
• เวอร์ชันเริ่มต้นของสตริงย่อยแสดงถึงการพิมพ์บรรทัดที่มี just /ซึ่งเป็นจินตภาพที่ถูกต้อง "บรรทัดก่อนหน้า" เพื่อทำให้อักขระอินพุตแรกถูกพิมพ์ที่จุดเริ่มต้นของบรรทัด
• โดยทั่วไปในระหว่างขั้นตอนการพิมพ์, สตริงย่อยที่ใช้ร่วมกันประกอบด้วยจำนวนของช่องว่าง\\หรือบรรทัดใหม่และต่อไปนี้\//

เรียกใช้โปรแกรมย่อยของตัวละคร

การทดแทนต่อไปนี้หลายครั้งมีการเสริม\ด้านในเพื่อป้องกันไม่ให้ถูกจับคู่และรวมกัน (รวมถึงสำเนาอื่น ๆ ในโปรแกรมย่อยอื่น ๆ ) การได้รับสิ่งนี้เป็นเหตุผลว่าทำไมทั้งสองxและyจำเป็น

• การเปลี่ยนตัวผู้เล่นครั้งแรกในโปรแกรมย่อยตัวอักษร/␤\//xyf\z/หรือ/␤\//xyb\z/, ทำให้␤/ในตอนท้ายของสตริงย่อยที่ใช้ร่วมกันที่จะกลายเป็นxyfzหรือxybzทันทีดังต่อไปนี้หรือ\/\\
• การแทนที่จะ/\\\\x\y/ /แทนที่\\xyด้วยช่องว่างและการแทนที่จะ/\\\/x\y//แทนที่\/xyโดยไม่มีอะไร
  • ซึ่งจะใช้เมื่ออักขระป้อนข้อมูลที่พิมพ์ก่อนหน้าคือ a \หรือ/ตามลำดับ
  • สตริงย่อยที่ใช้ร่วมกันในขณะนี้มีจำนวนที่เหมาะสมของพื้นที่สำหรับการพิมพ์\ต่อไปตามด้วยหรือfzbz
• การเปลี่ยนตัวผู้เล่น/ \fz/\\\/␤\//แทนที่​ fzโดย\/␤/และ/b\z/\\\\␤\//แทนที่โดย bz\\␤/
  • ซึ่งจะใช้เมื่ออักขระอินพุตปัจจุบันเป็น/หรือ\ตามลำดับ
  • คนแรกกินพื้นที่พิเศษเพื่อวาง/อย่างถูกต้อง
    • หากพื้นที่นี้หายไป (เช่นอินพุตละเมิดเงื่อนไขคำนำหน้า) การทดแทนต่อไปนี้จะตีความผิดโดยพิมพ์ขยะจำนวนมากและมักจะกดปุ่ม a ///ซึ่งเป็นลูปที่ไม่มีที่สิ้นสุด
  • แต่ละคำสั่งจะเพิ่มคำสั่งที่ถูกต้องเพื่อพิมพ์ตัวละครของตัวเองและคืนค่าเดิม␤/ที่ส่วนท้ายของสตริงย่อยที่ใช้ร่วมกัน
• โปรแกรมย่อยอักขระได้มาถึงสำเนาของสตริงย่อยที่ใช้ร่วมกันซึ่งพร้อมที่จะพิมพ์บรรทัดของมัน

/␤\//xyหลังจากที่ผ่านมาโปรแกรมย่อยตัวละครที่มีการเรียกใช้สิ่งที่เหลืออยู่ของโครงการคือ เนื่องจากสิ่งนี้เป็นการทดแทนที่ไม่สมบูรณ์เมื่อขาดหายไปในขั้นสุดท้าย/โปรแกรมจะข้ามและหยุดการทำงานตามปกติ

เยลลี่ขนาด 14 ไบต์

=”\ðḤ’+\_⁸⁶ẋżY

โปรแกรมเต็มรูปแบบการพิมพ์ผล

ลองออนไลน์!

อย่างไร?

=”\ðḤ’+\_⁸⁶ẋżY - Link: list of characters, s    e.g. "\\\//\\/"
 ”\            - literal '\'                         '\'
=              - equal? (call this e)                [1, 1, 1, 0, 0, 1, 1, 0]
   ð           - new dyadic chain f(e, s)
    Ḥ          - double                              [2, 2, 2, 0, 0, 2, 2, 0]
     ’         - decrement                           [1, 1, 1,-1,-1, 1, 1,-1]
      +\       - cumulative reduce with addition     [1, 2, 3, 2, 1, 2, 3, 2]
         ⁸     - chain's left argument, e            [1, 1, 1, 0, 0, 1, 1, 0]
        _      - subtract (# of leading spaces)      [0, 1, 2, 2, 1, 1, 2, 2]
          ⁶    - literal ' '                         ''
           ẋ   - repeat                              [""," ","  "," "," "," ","  ","  "]
            ż  - zip with s                          [["",'\'],[" ",'\'],["  ",'\'],["  ",'/'],[" ",'/'],[" ",'\'],["  ",'\'],["  ",'/']]
             Y - join with newlines                  ["",'\','\n'," ",'\','\n',"  ",'\','\n',"  ",'/','\n'," ",'/','\n'," ",'\','\n',"  ",'\','\n',"  ",'/']
               - implicit print - this smashes the lists (shown as "..." above) and the characters (shown as '...' above) together.

Haskell , 49 ไบต์

scanl(\x c->drop(sum[1|'/'<-c:x])(' '<$x)++[c])[]

ลองออนไลน์!

Perl 5 , 44 ไบต์

รหัส 42 ไบต์ + 2 สำหรับการ-Fตั้งค่าสถานะ

say$"x($s+=$\eq$_&&$#i**m|/|).($\=$_)for@F

ลองออนไลน์!

JavaScript (ES8), 66 59 63 ไบต์

บันทึกไปแล้ว 7 ไบต์ด้วยJustin Mariner
+4 ไบต์เพื่อแก้ไข/\\/\\/(สังเกตโดยNeil )

f=([a,...z],b=a<'0')=>a?a.padStart(b+=k=a>'/')+`
`+f(z,b-!k):''

ลองออนไลน์!

MATL , 23 19 18 ไบต์

ปิด 1 ไบต์ด้วย@Sanchises

fGqoEq1yd~h*YsGZ?c

อินพุตเป็นสตริงที่อยู่ในเครื่องหมายคำพูดเดี่ยว

ลองออนไลน์! หรือตรวจสอบกรณีทดสอบ: 1 , 2 ,3

คำอธิบาย

พิจารณาการป้อนข้อมูล'\\\//\/\\'เป็นตัวอย่าง

f      % Implicit input. Array of indices of nonzeros. Since all chars in the input
       % have nonzero code point, this gives [1 2 ... n] where n is input length
       % STACK: [1 2 3 4 5 6 7 8 9]
G      % Push input again
       % STACK: [1 2 3 4 5 6 7 8 9], '\\\//\/\\'
qo     % Subtract 1 from (the code-point) of each char and then compute modulo 2.
       % This transforms '\' into 1 and '/' into 0
       % STACK: [1 2 3 4 5 6 7 8 9], [1 1 1 0 0 1 0 1 1]
Eq     % Double, subtract 1. This transforms 0 into -1
       % STACK: [1 2 3 4 5 6 7 8 9], [1 1 1 -1 -1 1 -1 1 1]
1y     % Push 1 and duplicate from below
       % STACK: [1 2 3 4 5 6 7 8 9], [1 1 1 -1 -1 1 -1 1 1], 1, [1 1 1 -1 -1 1 -1 1 1]
d~     % Consecutive differences, logical negation: gives 1 if consecutive entries
       % are equal, 0 otherwise
       % STACK: [1 2 3 4 5 6 7 8 9], [1 1 1 -1 -1 1 -1 1 1], 1, [1 1 0 1 0 0 0 1]
h      % Horizontally concatenate
       % STACK: [1 2 3 4 5 6 7 8 9], [1 1 1 -1 -1 1 -1 1 1], [1 1 1 0 1 0 0 0 1]
*      % Element-wise multiplication
       % STACK: [1 2 3 4 5 6 7 8 9], [1 1 1 0 -1 0 0 0 1]
Ys     % Cumulative sum
       % STACK: [1 2 3 4 5 6 7 8 9], [1 2 3 3 2 2 2 2 3]
G      % Push input again
       % STACK: [1 2 3 4 5 6 7 8 9], [1 2 3 3 2 2 2 2 3], '\\\//\/\\'
Z?     % Build sparse matrix with those row indices, column indices, and values
       % STACK: [92  0  0;
                  0 92  0;
                  0  0 92;
                  0  0 47;
                  0 47  0;
                  0 92  0;
                  0 47  0;
                  0 92  0;
                  0  0 92]
c      % Convert to char. Char 0 is shown as space. Implicitly display
       % STACK: ['\  ';
                 ' \ ';
                 '  \';
                 '  /';
                 ' / ';
                 ' \ ';
                 ' / ';
                 ' \ ';
                 '  \']

C # (. NET Core) , 74 88 82 78 77 76 + 18 ไบต์

-1 ไบต์ต้องขอบคุณKevin Cruijssen

s=>s.Select((x,i)=>$"{x}".PadLeft((x-s[0])/45-~s.Take(i).Sum(y=>y<92?-1:1)))

ส่งออกคอลเลกชันของสตริงหนึ่งสำหรับแต่ละบรรทัด จำนวนไบต์ยังรวมถึง:

using System.Linq;

ลองออนไลน์!

คำอธิบายสำหรับ 77 คำตอบไบต์:

s =>                              // Take input, a string
    s.Select((x, i) =>            // Replace every character with:
        $"{x}"                    //     The character as string
        .PadLeft(                 //     Pad with this many spaces:
            s.Take(i)             //         Take characters, in the input string, preceding current one
            .Sum(y =>             //         Sum them by:
                y < 92 ? -1 : 1   //             If it's a \ add 1, if / subtract 1
            )
            + (x - s[0]) / 45 + 1 //         If first slash is a / add one more space, if current slash is a \ add one more space (I got this through power of MATHS!)
                                  //         How I arrived at this function:
                                  //         + x / 48        If current slash is a \ add one more space
                                  //         - s[0] / 48 + 1 If the first slash is a / add one more space
        )
    )

05AB1E , 14 ไบต์

ÇÈx<ηOs-W-ISú»

ลองออนไลน์!

คำอธิบาย

Ç                # convert input string to a list of ascii codes
 È               # check each for evenness
  x              # push a doubled copy
   <             # decrement
    η            # compute prefixes
     O           # sum each prefix
      s          # swap the unaltered copy of evenness to the top
       -         # subtract from the prefix-sum list
        W-       # subtract the minimum value
          IS     # push input split to a list of chars
            ú    # pad each with the number of spaces computed
             »   # join on newline

R , 122 121 ไบต์

-1 ไบต์ขอบคุณ Giuseppe

x=el(strsplit(scan(,""),""));n=seq(x);y=x>"/";for(i in n)cat(rep(" ",diffinv(y[n[-1]-1]+y[n[-1]]-1)[i]),x[i],"\n",sep="")

ลองออนไลน์!

ด้วยพื้นที่ว่างพิเศษ:

x = el(strsplit(scan(,""),""))
n = seq(x)
y = x>"/"
for(i in n) {
  cat(rep(" ", diffinv(y[n[-1]-1]+y[n[-1]]-1)[i]), x[i], "\n", sep="")
}

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

หากเรามีเครื่องหมายทับ N ตัวตัวแปรyนั้นจะเป็นเวกเตอร์ที่มีความยาว N โดยมี 1 สำหรับแต่ละตำแหน่งที่มี\0 มิฉะนั้น y[1:(N-1)] + y[2:N] - 1ดังนั้นการที่จะได้รับการเปลี่ยนแปลงในจำนวนของช่องว่างนำเส้นละเราจะคำนวณ ฟังก์ชั่นdiffinvแปลงความแตกต่างเหล่านี้เป็นลำดับเริ่มต้นด้วย 0 ส่วนที่เหลือเป็นเพียงเรื่องของการประกอบแต่ละบรรทัดตามจำนวนที่ต้องการของช่องว่างต่อท้ายตามด้วยเครื่องหมายทับที่เกี่ยวข้องและขึ้นบรรทัดใหม่

Brain-Flak , 175 ไบต์ (174 ตัวอักษร + 1 ธง)

วิ่งด้วย-cธง

{(({})<(())>){({}[()]<([{}])>)}{}(({}<>{}<><({}<>)((()()()()()){})>)<{({}[()]<((((()()()()){}){}){})>)}>{})<>}<>{}{({}<>)(({})(())){({}[()]<([{}]())>)}{}{<>{}<>(<{}>)}{}<>}<>

ลองออนไลน์!

คำอธิบาย

{ for each char in the input...
  (({})<(())>){({}[()]<([{}])>)}{} push 1/-1 for backslash/slash
  ((
   {}<>{}<> add the 1/-1 to a running total
   <
    ({}<>) move slash/backslash to other stack
    ((()()()()()){}) newline
   >
  )<{({}[()]<((((()()()()){}){}){})>)}>{}) spaces
  <>
}<>{} end for
reverse data order, removing one space before backslash
{({}<>)(({})(())){({}[()]<([{}]())>)}{}{<>{}<>(<{}>)}{}<>}<>

Ruby , 80 76 ไบต์

-4 ไบต์ต้องขอบคุณการจัดการ

puts"\\";$*[i=0].chars.each_cons 2{|b,c|puts" "*(b==c ?b==?/?i-=1:i+=1:i)+c}

ลองออนไลน์!

คำอธิบาย:

puts "\\"           # Output the first backslash
$*[i=0].            # Get the first argument and set i to 0
chars.              # Go through every individual character,
each_cons 2 { |b,c| # In pairs to compare easily
                    #
    puts " " *      # Decide how many padding spaces to use based on the value
                    # of i. The expression inside the parenthesis will return
                    # i but before that, it will increment/decrement i based
                    # on what the previous character was.
                        #
    ( b==c ?            # if b == c
        b==?/ ?         #   if b == "/" (Going to the left)
            i-=1        #       return decremented i
            :           #   else        (Going to the right)
            i+=1        #       return incremented i
        :               # else
        i) +            #   return i
                    #
                c   # Finally, write the second of the characters that we're
}                   # iterating through.

Java 8, 121 118 110 109 102 ไบต์

a->{String r="";int s=0,p=0,i;for(char c:a){for(i=s+=p+(p=c-63)>>5;i-->0;r+=" ");r+=c+"\n";}return r;}

-7 ไบต์ด้วยเวทมนตร์บิตฉลาดของ@Nevay :)

คำอธิบาย:

ลองที่นี่

a->{                    // Method with char-array parameter and String return-type
  String r="";          //  Return-String
  int s=0,              //  Amount of spaces
      p=0,              //  Previous characters (starting at 0)
      i;                //  Index-integer
  for(char c:a){        //  Loop over the input
    for(i=s+=p+(p=c-63)>>5;
                        //   If the current does not equals the previous character
                        //    Leave `s` the same
                        //   Else-if it's a '\':
                        //    Increase `s` by 1
                        //   Else (it's a '/'):
                        //    Decrease `s` by 1
                        //   And set the previous character to the current in the process
        i-->0;r+=" ");  //   Append `r` with `s` amount of spaces               
    r+=c+"\n";          //   Append the character + a new-line to the result
  }                     //  End of loop
  return r;             //  Return result-String
}                       // End of method

C (GCC), 137 134 97 ไบต์

ลองออนไลน์!

• 3 ไบต์ขอบคุณ ATaco

• 37 ไบต์ด้วย Digital Trauma & ThePirateBay

i,d;f(char*s){char c=s[i],n=s[++i];if(c){printf("%*c%c\n",d+1,c);(c-n)?d:(c==47)?--d:++d;f(s);}}

ไม่มีอะไรแฟนซีเกินไปเพียงแค่ฟังก์ชั่นวนซ้ำแบบง่าย ๆ ที่รับสตริงและพิมพ์เครื่องหมายสแลชโปรดทราบว่าอินพุตต้องหลบหลีกแบ็กสแลชก่อน

การใช้

f("\\\\\\//\\/\\\\",0,0);

Ungolfed

นี่คือคำตอบเก่าให้ลองลิงค์ออนไลน์สำหรับการอัปเดต!

f(char *s, i, d) {
    char c=s[i], n=s[++i];
    if(!c) return;
    for(int j=0; j<d; j++) printf(" ");
    printf("%c\n",c);
    f(s, i, (c!=n)?d:(c=='/')?d-1:d+1);
}

เอาท์พุต

C, 60 ไบต์

i;f(char*s){for(i=1;*s;s++)printf("%*c\n",*s%2?--i:i++,*s);}

ลองออนไลน์!

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

^|\\
 $&
+m`^( *)( /|\\)(/| \\)
$1$2¶$1$3
m`^ 

ลองออนไลน์! ลิงค์มีกรณีทดสอบ คำอธิบาย:

^|\\
 $&

เพิ่มช่องว่างที่จุดเริ่มต้นของแต่ละบรรทัดและก่อนแต่ละ\ช่อง

+m`^( *)( /|\\)(/| \\)
$1$2¶$1$3

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

m`^ 

ลบการเยื้องพิเศษ

ฉันเขียนเวอร์ชัน 94- ไบต์ซึ่ง (เช่นคำตอบ Charcoal ของฉัน) อนุญาตให้ใช้การรวมกันของสแลช: ลองออนไลน์! คำอธิบาย:

.$
¶$.`$* $&

รับลูกบอลกลิ้งโดยการเฉือนสุดท้ายและเยื้องไปยังตำแหน่งเดียวกันในบรรทัดของตัวเอง

/
 /

คำนำหน้าช่องว่างไปข้างหน้าทับทั้งหมดเพื่อให้พวกเขาสามารถจับ

+`^(.*)( /|\\)¶( *)( \\|/)
$1¶$3$2¶$3$4

นำเครื่องหมายทับสุดท้ายของอินพุตซ้ำหลายครั้งและจัดเรียงตามบรรทัดของตัวเองด้วยเครื่องหมายทับบนบรรทัดด้านล่าง

+ms`^(?<!^[\\/].*) (?!.*^[\\/])

ลบการเยื้องทางซ้าย

G`.

ลบอินพุตว่างตอนนี้

Lua , 96 ไบต์

c=0 for s in(...):gmatch(".")do c=c+(p==s and(s=="/"and-1or 1)or 0)p=s print((" "):rep(c)..s)end

ลองออนไลน์!

ที่สั้นที่สุดที่ฉันสามารถหา Lua ได้ อินพุตถูกนำมาจากบรรทัดคำสั่ง

นี่ใช้เทคนิคเล็กน้อย:

1. (...):gmatch(
   นี่ควรเป็นรูปแบบที่สั้นที่สุดในการรับสตริงเดี่ยวเข้าไปในโปรแกรม Lua จากบรรทัดคำสั่ง การ...แสดงออกใน Lua จับพารามิเตอร์ส่วนเกินใด ๆ กับฟังก์ชั่นที่ไม่ได้ระบุไว้ในการประกาศฟังก์ชั่นและจะใช้สำหรับ varargs เนื่องจากตัวหลักของโปรแกรม Lua ...ได้รับการเรียกว่าเป็นฟังก์ชั่นที่มีการขัดแย้งบรรทัดคำสั่งเป็นพารามิเตอร์ของอาร์กิวเมนต์บรรทัดคำสั่งจะจบลงใน
   วงเล็บที่อยู่รอบ ๆ จะเปลี่ยน...นิพจน์ที่มีหลายค่าให้เป็นนิพจน์ที่มีค่าเดียว ลองพิจารณาตัวอย่างนี้ (ค่อนข้างน่าแปลกใจ):

   function multipleReturnValues()
       return "abc", "def"
   end
   print(  multipleReturnValues()  ) --This prints: abc    def
   print( (multipleReturnValues()) ) --This prints: abc

2. ตัวแยกวิเคราะห์ Lua ไม่จำเป็นต้องมีตัวคั่นบรรทัดหรือแม้แต่ช่องว่างระหว่างคำสั่งตราบใดที่โทเค็นของคำสั่งทั้งสองสามารถแยกออกจากกันได้อย่างชัดเจนและมีการตีความข้อความเดียวที่เป็นรหัส Lua ที่ถูกต้อง
3. การใช้ผิดวิธีand/ orสำหรับ "if x แล้วให้ค่า 1 ค่าตรรกะ 2" ผู้ประกอบการ
   ของ Lua andส่งกลับอาร์กิวเมนต์แรกหากมันเป็นเท็จ มิฉะนั้นจะส่งคืนอาร์กิวเมนต์ที่สอง orผู้ประกอบการส่งกลับอาร์กิวเมนต์แรกของมันถ้ามันเป็น truthy; มิฉะนั้นอาร์กิวเมนต์ที่สอง
4. pไม่ต้องการการเริ่มต้น
   p==sจะต้องเป็นเท็จในการรันครั้งแรกของลูปโดยไม่คำนึงถึงอินพุต ไม่ได้ตั้งค่าเป็นค่าpใด ๆ ก่อนที่จะเข้าสู่ลูป (ปล่อยให้มันnil) จะทำให้เกิดขึ้นและบันทึกไบต์เช่นกัน

ทุกคนสามารถเล่นกอล์ฟนี้ (ใน Lua) ได้หรือไม่

Pyth , 28 ไบต์

j.u+?qeNY?>Y\/+PNdPPNPNYtzhz

ลองออนไลน์!

R , 119 ไบต์

function(s)for(i in 1:nchar(s))cat(rep(" ",cumsum(c(0,!diff(S<-(utf8ToInt(s)>48)*2-1))*S)[i]),substr(s,i,i),"
",sep="")

ลองออนไลน์!

ซึ่งแตกต่างไปจากคำตอบของ user2390246 แต่ละอันวนซ้ำไปตามสตริงพิมพ์อักขระช่องว่างจำนวนหนึ่งแล้วตามด้วย/\อักขระที่เหมาะสม

อย่างไรก็ตามฉันหลีกเลี่ยงการแยกสตริงโดยเลือกแทนที่อักขระด้วยค่าการเข้ารหัส UTF-8 ของพวกเขาแทนซึ่งทำให้ฉันสามารถคำนวณเลขคณิตกับตัวเลขโดยตรงได้ซึ่งช่วยฉันได้เพียงไม่กี่ไบต์

C # (.NET Core) , 60/65 ไบต์

ฉันลองรุ่น C # ที่สั้นกว่า

s=>{int i=0;return s.Select(x=>"".PadLeft(x<92?--i:i++)+x);}

ตามที่ระบุไว้: "นี่หมายความว่าทุกอินพุตจะเริ่มต้นด้วยแบ็กสแลช" หรือนานกว่าเล็กน้อยซึ่งแก้ปัญหาการเริ่มต้น "/"

s=>{int i=s[0]&1;return s.Select(x=>"".PadLeft(x<92?--i:i++)+x);}

ลองออนไลน์!

Lua , 88 84 ไบต์

รุ่นที่ปรับปรุง (-4 ไบต์ขอบคุณ QuertyKeyboard)

s=""g=s.gsub g(...,".",function(c)s=g(g(g(s,"\\"," "),"/?$",c)," /","/")print(s)end)

ลองออนไลน์!

รุ่นดั้งเดิม (88 ไบต์)

ความพยายามใน Lua อีกครั้งคราวนี้ด้วยวิธีที่แตกต่างอย่างสิ้นเชิงโดยใช้การจัดการสตริงแทนที่จะเป็นตัวแปรตัวนับ

s=""for c in(...):gmatch"."do s=s:gsub("\\"," "):gsub("/?$",c):gsub(" /","/")print(s)end

Ungolfed:

s = ""
for c in string.gmatch((...), ".") do --for each character in the input
  --s contains the output from the previous iteration
  s = s:gsub("\\", " ") --Replace backslash with space -> indent by 1
  s = s:gsub("/?$", c) --Remove any / at the end of the string and append c to the string
  s = s:gsub(" /", "/") --Remove a single space in front of any / -> un-indent by 1
  print(s)
end

มีสิ่งหนึ่งที่น่าสนใจในรหัส: (...):gmatch"."
สิ่งนี้ใช้นิสัยแปลก ๆ ในตัวแยกวิเคราะห์ Lua เมื่อ Lua พบชิ้นส่วนของรหัสในรูปแบบก็จะแปลงนี้func "string" func("string")นี่คือเพื่อให้หนึ่งสามารถเขียนprint "string"เพื่อพิมพ์สตริงคงที่และใช้งานได้กับสตริงตัวเดียวหลังจากฟังก์ชั่น สิ่งอื่นใดจะให้ข้อผิดพลาดทางไวยากรณ์ อย่างไรก็ตามน้ำตาล syntactic นี้ยังทำงานกับการเรียกใช้ฟังก์ชั่นในช่วงกลางของการแสดงออกและน่าแปลกใจมากขึ้นมันทำงานได้ดีพร้อมกับ:วิธีการเรียกน้ำตาล syntactic ดังนั้นในที่สุด Lua จะตีความรหัสเช่นนี้:

(...):gmatch"."
-> (...):gmatch(".")
-> string.gmatch((...), ".")

หากใครสามารถคิดวิธีลบหนึ่งในสามสาย gsub ได้โปรดบอกฉัน

Pyth - 33 ไบต์

ความพยายามครั้งแรกจะกอล์ฟ

jsMC,*L;+ZsM._*VqVtzztMxL"/ \\"zz

ลองมันออนไลน์ได้ที่นี่

Perl, 40 + 2 ไบต์

/\//&&$.--,say($"x$.,$_),/\\/&&$.++for@F

คุณต้องการ-Fธง

Perl, 34 38 + 1 ไบต์

เพื่อจัดการกับทั้งสองกรณี

s,(/)|.,$"x($1?$c&&--$c:$c++).$&.$/,ge

ที่จะทำงานด้วย-pตัวเลือก

s,(/)|.,$"x($1?--$c:$c++).$&.$/,ge

แก้ไข: ความคิดเห็นต่อไปนี้ใช้ไม่ได้เมื่ออักขระตัวแรกเป็น /

s,(/)|.,$"x($1?$c--:++$c).$&.$/,ge

อย่างไรก็ตามเอาต์พุตจะถูกเลื่อนไปหนึ่งอักขระทางด้านขวาถ้าอักขระตัวแรกคือ \

VBA (Excel) 181 ไบต์

Sub q()
a = Cells(1, 1)
For x = 1 To Len(a)
c = Mid(a, x, 1)
If c = "\" Then: Debug.Print b & c: b = b + " "
If c = "/" Then: b = Left(b, Len(b) - 1): Debug.Print b & c
Next
End Sub

Pyth , 24 21 ไบต์

พอร์ตจากก้านของคำตอบ

VQ=-Z<N\<+*ZdN=+Z>N\<

ลองออนไลน์!

SOGL V0.12 , 16 13 ไบต์

{└=-:↕PFoF┘=+

ลองที่นี่! - คาดว่าข้อมูลเกี่ยวกับสแต็คดังนั้นเพื่อความสะดวกในการใช้งาน,จะมีการเพิ่ม

Dyalog APL, 31 ไบต์

{↑⍵,¨⍨' '/¨⍨{⍵-⍨+\¯1+2×⍵}⍵='\'}

ลองที่นี่!