Đưa ra hai tham số mô hình làn đường và chiều dài đường , in một bản trình bày ASCII về các vạch kẻ đường cho Đường và Dịch vụ giao thông để vẽ đường.

Ví dụ đầu vào / đầu ra

Đầu vào : BTHMLRPHU , 21

Tôi không quan tâm nếu bạn lấy hai tham số hoặc ghép số vào cuối chuỗi, điều đó không rõ ràng.

Đầu vào có thể được lấy từ STDIN, như là một đối số chức năng, các biến môi trường, bất cứ điều gì có ý nghĩa trong ngôn ngữ của bạn.

Đầu ra:

!   |      x      ##      |      |      x      x      !
! B |  /\  x HOV3 ##  <-  |  ->  |  ^^  x HOV3 x      !
! B |  \/  x HOV3 ##   |  |  |   |  ^^  x HOV3 x      !
!   |      x      ##      |      |      x      x      !
!   |      x      ##      |      |      x      x      !
!   |      |      ##      |      |      |      |      !
!   |      |      ##      |      |      |      |      !
!   |      |      ##      |      |      |      |      !
! B |  /\  | HOV3 ##  <-  |  ->  |  ^^  | HOV3 |      !
! B |  \/  | HOV3 ##   |  |  |   |  ^^  | HOV3 |      !
!   |      x      ##      |      |      x      x      !
! B |  /\  x HOV3 ##  <-  |  ->  |  ^^  x HOV3 x      !
! B |  \/  x HOV3 ##   |  |  |   |  ^^  x HOV3 x      !
!   |      x      ##      |      |      x      x      !
!   |      x      ##      |      |      x      x      !
!   |      |      ##      |      |      |      |      !
!   |      |      ##      |      |      |      |      !
!   |      |      ##      |      |      |      |      !
! B |  /\  | HOV3 ##  <-  |  ->  |  ^^  | HOV3 |      !
! B |  \/  | HOV3 ##   |  |  |   |  ^^  | HOV3 |      !
!   |      x      ##      |      |      x      x      !

Mỗi ký tự biểu thị chiều rộng 0,5 mét và chiều dài một km.

Sự chỉ rõ

Đánh dấu làn đường

Đối với mỗi đoạn đường dài 10 km, các vạch kẻ được vẽ ở km 2, 3, 9 và 10 (từ "đỉnh" của đầu ra). Các dấu hiệu được tập trung trong làn đường. Ngoại trừ làn đường dành cho xe đạp và dải phân cách, tất cả các làn đường đều rộng 3 mét (6 ký tự).

Ký tự kim cương và mũi tên ASCII không được phép thay cho các dấu như được chỉ ra trong đầu ra ví dụ.

• B: Làn xe đạp. Bđánh dấu. Rộng 1,5 mét (3 ký tự).
• T: Quá cảnh. Đánh dấu kim cương
• H: Làn đường xe chở nhiều người. HOV3đánh dấu
• Lvà R: Làn đường rẽ. Mũi tên đánh dấu
• P: Đi qua làn đường. Dấu caret
• U: Làn đường không giới hạn. Không có dấu

Dấu phân cách (theo thứ tự ưu tiên)

• Trung vị: ##(được biểu thị bằng Mtrong chuỗi đầu vào, thay thế bất kỳ dấu phân cách nào khác bao gồm cả mương)
• Mương (cực trái và cực phải): !Dấu chấm than
• Làn đường HOV xen kẽ giữa xvà |cứ sau 5 km
• Bình thường: |

Những ràng buộc

Chức năng hoặc chương trình của bạn phải:

• In sang STDOUT (điều này có nghĩa là tương đương System.out.printvới Java, console.logcho JavaScript, v.v.)
• Có thể in 1 - 9 làn với 0 - 10 dải phân cách
• Có thể in tới 50 km đường bộ (50 dòng đầu ra)
• Không sử dụng bất kỳ sơ hở tiêu chuẩn
• Không thể chấp nhận lưu trữ khoảng trắng ngoại trừ tùy chọn \nở cuối đầu ra

Đầu ra lớn nhất có thể: 3700 byte (74 ký tự * 50 dòng).

Đầu ra nhỏ nhất có thể: 5 byte (với đầu vào B, 1)

Giả định

• Không có dải phân cách liền kề (chuỗi con MMsẽ không xảy ra)
• Dòng đánh dấu thứ hai có thể bị cắt (ví dụ: nếu chiều dài là 9 hoặc 12 km)
• Làn đường có thể không có ý nghĩa về mặt logic (bất kỳ trật tự nào đều có thể, ví dụ: làn đường rẽ phải ở bên trái đường)

Đây là mã golf , vì vậy mã ngắn nhất (tính bằng byte) sẽ thắng!

Ruby, 245

In làn đường phân chia nếu có liên quan, sau đó in làn đường.

Tôi không mong đợi chiến thắng.

->(n,i){i.times{|d,t|*e=''
g=e+%w{HOV3 ^^ B}
n.chars{|c|$><<(c==?M?'##':!t ??!:(t+c)[?H]&&d%10<5??x:?|)if(M=t!=?M)
$><<((e+[(%w{/\\ <- ->}+g)[v='TLRUHPB'.index(c)],(%w{\\/ \ | |\ }+g)[v]]+e*4)*2)[d%10].center(v>5?3:6)if(t=c)!=?M}
puts M ? e:?!}}

Thay đổi

245 sặc stderr và chia mảng một cách hiệu quả.

263 cách tốt hơn để mảng index

268 chỉ in mỗi dòng, không tính toán một phiên bản kinh điển.

330 cam kết ban đầu

JavaScript (ES6), 316 byte

f=(x,n)=>{for(i=0;n>i++;){b=!(r=i%10)|r==3;y=[...`! ${[...x].join` | `} !`[o='replace'](/[\W] ?M [\W]?/g,'##')].map(c=>~(q='LPRTU'.indexOf(c))?` ${'<- |^^^^->| /\\\\/    '.substr(4*q+2*b,2)} `:c=='H'?'HOV3':c).join``;y=r&&r<6?y[o](/\| H/g,'x H')[o](/3 \|/g,'3 x'):y;console.log(b|r==2|r==9?y:y[o](/[^!\|x#]/g,' '))}}

Bản giới thiệu

Nó sẽ hoạt động trong Firefox và Edge tại thời điểm viết, Chrome / Opera yêu cầu các tính năng thử nghiệm được bật.

console.log = x => O.innerHTML += x + '\n';

f = (x, n) => {
  for (i = 0; n > i++;) {
    b = !(r = i % 10) | r == 3;
    y = [...
      `! ${[...x].join` | `} !` [o = 'replace'](/[\W] ?M [\W]?/g, '##')
    ].map(c => ~(q = 'LPRTU'.indexOf(c)) ? ` ${'<- |^^^^->| /\\\\/    '.substr(4*q+2*b,2)} ` : c == 'H' ? 'HOV3' : c).join ``;
    y = r && r < 6 ? y[o](/\| H/g, 'x H')[o](/3 \|/g, '3 x') : y;
    console.log(b | r == 2 | r == 9 ? y : y[o](/[^!\|x#]/g, ' '))
  }
}

// Snippet stuff
var demo = () => {
  O.innerHTML = '';
  document.forms[0].checkValidity() && f(document.getElementById('P').value, document.getElementById('N').valueAsNumber);
};

document.getElementById('P').addEventListener('change', demo);
document.getElementById('N').addEventListener('change', demo);

demo();

<form action='#'>
  <p>
    <label>Lane pattern:
      <input type=text pattern=^M?([BHLPRTU]M?)+$ maxlength=19 required id=P value=MLTPUMHUTBR>
    </label>
  </p>
  <p>
    <label>Kilometres:
      <input type=number id=N min=1 value=21 max=50 step=1 required>
    </label>
  </p>
  <pre><output id=O></output></pre>
</form>

05AB1E , 175 174 175 byte

ðTиDU'|TиX'BŽ5ES©ǝX„\/TbSDVè®ǝ€ºX4×"HOV3"®ǝX'<18SǝX„|-Yè®ǝøJDí'<'>:X'^®ǝ2×'#Tи2×'x5и'|5и«'!Tи)I.•o¤[‹‡•uŽDýSтì€ûŽe1ª904ûª8ª₄«ª‡•δ~¬]•2ôDí«Ž
ÿT∍S:ð.ø8ðì‚8:1ðì‚ð:SðT:èεI∍}øJ»

Cách tiếp cận khá tệ, nhưng nó hoạt động và rất thú vị để thực hiện. Chắc chắn có thể được chơi golf nhiều hơn, mặc dù.

+1 byte dưới dạng sửa lỗi cho hai HHlàn liền kề .

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

Giải trình:

Bước 1: Tạo tất cả các làn có thể có kích thước 10:

ðTи               # Push a space character, repeated 10 times as list
   DU             # And store a copy in variable `X`
'|Tи             '# Push "|", repeated 10 times as list
X                 # Push the list of spaces of variable `X`
 'B              '# Push a "B"
   Ž5E            # Push compressed integer 1289
      S           # Converted to a list of digits: [1,2,8,9]
       ©          # Store it in variable `®` (without popping)
        ǝ         # Replace the spaces in the pushed `X` with the "B" at these (0-based)
                  # indices
X                 # Push `X` again
 „\/              # Push string "\/"
    TbS           # Push 10, converted to binary, as list: [1,0,1,0]
       DV         # Store a copy in variable `Y`
         è        # Index each into this string: ["/","\","/","\"]
          ®       # Push list `®` again ([1,2,8,9])
           ǝ      # And replace the spaces with these characters
            €º    # And then mirror each line (" "→"  "; "/"→"/\"; "\"→"\/")
X                 # Push `X` again
 4×               # Extend each space to four spaces
   "HOV3"         # Push string "HOV3"
         ®ǝ       # And replace the spaces with this string at the indices of `®` again
X                 # Push `X` again
 '<              '# Push string "<"
   18S            # Push 18 as list: [1,8]
      ǝ           # Replace the spaces with "<" at those indices
       X          # Push `X` yet again
        „-|       # Push string "-|"
           Yè     # Use list `Y` ([1,0,1,0]) to index into this string: ["-","|","-","|"]
             ®ǝ   # And replace the spaces at the indices of `®` again
               ø  # Then zip-pair the two lists together
                J # And join each pair of characters to a string
Dí                # Create a copy and reverse each string
  '<'>:           # And replace all "<" with ">"
X'^®ǝ            '# Push `X` with the spaces at indices `®` replaced with "^" 
     2×           # Extend each character to size 2
'#Tи             '# Push "#", repeated 10 times as list
    2×            # And extend each character to size 2
'x5и             '# Push "x" repeated 5 times as list
    '|5и         '# Push "|" repeated 5 times as list
        «         # And merge the lists together
'!Tи             '# Push "!", repeated 10 times as list
)                 # And finally wrap all lists of the stack into one big list of lanes

Bước 2: Chuyển đổi chuỗi đầu vào thành các chỉ mục (chúng tôi sẽ sử dụng để lập chỉ mục vào danh sách chúng tôi đã tạo ở bước 1):

I                 # Push the input-string
 .•o¤[‹‡•         # Push compressed string "tlrpbhmu"
         u        # And uppercase it
ŽDý               # Push compressed integer 3567
   S              # Converted to a list of digits: [3,5,6,7]
    тì            # Prepend each with "100": ["1003","1005","1006","1007"]
      €û          # And palindromize each: ["1003001","1005001","1006001","1007001"]
Že1               # Push compressed integer 10201
   ª              # And append it to the list
904ûª             # Push 904 palindromized to "90409", and also append it to the list
8ª                # Append 8 to the list
₄Â                # Push 1000, and bifurcate it (short for Duplicate & Reverse copy)
  «               # Merge them together: "10000001"
   ª              # And also append it to the list
‡                 # Now transliterate all uppercase characters in the input to these numbers
•δ~¬]•            # Push compressed integer 1119188999
      2ô          # Split into parts of size 2: [11,19,18,89,99]
        Dí        # Create a copy, and reverse each item: [11,91,81,98,99]
          «       # And merge the lists together: [11,19,18,89,99,11,91,81,98,99]
Ž\nÿ              # Push compressed integer 19889
    T∍            # Extended to size 10: 1988919889
      S           # As a list of digits: [1,9,8,8,9,1,9,8,8,9]
:                 # Replace all [11,19,18,89,99,11,91,81,98,99] with [1,9,8,8,9,1,9,8,8,9]
                  # in the converted string
ð.ø               # Surround the string with spaces
8ðì               # Push 8 with a prepended space: " 8"
   ‚             # Bifurcate and pair: [" 8","8 "]
     8:           # And replace all those for 8 in the string
1ðì‚ð:           # Do the same for [" 1","1 "] → " "
S                 # Convert the string to a list of characters (digits and space)
 ðT:              # Replace the spaces for 10

Bước 3: chúng tôi sử dụng các chỉ số đó để lập chỉ mục vào danh sách các làn đường. Và sau đó chúng tôi chuyển đổi danh sách các làn đó thành đầu ra chính xác, bao gồm mở rộng / rút ngắn chúng thành kích thước của đầu vào số nguyên:

è                 # Index the indices in the integer-list into the lanes-list
 ε                # Map over each lane
  I               #  Push the second integer-input
   ∍              #  Extend/shorten each 10-sized lane to this input-size
 }ø               # After the map: zip/transpose; swapping rows/columns
   J              # Join inner list together to a single string
    »             # And then join each string by newlines
                  # (after which the result is output implicitly)

Xem 05AB1E mẹo này của tôi (phần Làm thế nào để chuỗi nén không nằm trong từ điển? Và Làm thế nào để nén các số nguyên lớn? ) Để hiểu tại sao Ž5Elà 1289; .•o¤[‹‡•là "tlrpbhmu"; ŽDýlà 10201; •δ~¬]•là 1119188999; Ž\nÿlà 19889.