Diberikan dua parameter, pola lajur dan panjang jalan , cetak representasi ASCII dari marka jalan untuk Jalan dan Layanan Lalu Lintas untuk mengecat jalan.

Contoh input / output

Input:, BTHMLRPHU 21

Saya tidak peduli jika Anda mengambil dua parameter atau menyatukan angka ke akhir string, itu jelas.

Masukan dapat diambil dari STDIN, sebagai argumen fungsi, variabel lingkungan, apa pun yang masuk akal dalam bahasa Anda.

Keluaran:

!   |      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      !

Setiap karakter menunjukkan lebar 0,5 meter dan panjang satu kilometer.

Spesifikasi

Tanda jalur

Untuk setiap bentangan 10 km, marka dicat pada kilometer 2, 3, 9, dan 10 (dari "atas" keluaran). Tanda dipusatkan di jalur. Kecuali jalur sepeda dan median, semua jalur memiliki lebar 3 meter (6 karakter).

Karakter berlian dan panah ASCII tidak diizinkan sebagai pengganti tanda-tanda seperti yang ditunjukkan dalam contoh output.

• B: Jalur sepeda. Bmenandai. Lebar 1,5 meter (3 karakter).
• T: Transit. Penandaan berlian
• H: Jalur kendaraan dengan okupansi tinggi. HOV3menandai
• Ldan R: Turning lane. Tanda panah
• P: Passing lane. Tanda caret
• U: Jalur tidak terbatas. Tidak ada tanda

Pemisah (sesuai urutan)

• Median: ##(dilambangkan oleh Mdalam string input, menggantikan pemisah lainnya termasuk parit)
• Parit (ekstrem kiri dan kanan ekstrem): !Tanda seru
• Jalur HOV bergantian antara xdan |setiap 5 km
• Normal: |

Kendala

Fungsi atau program Anda harus:

• Cetak ke STDOUT (ini artinya setara dengan System.out.printuntuk Java, console.loguntuk JavaScript, dll.)
• Dapat mencetak 1 - 9 jalur dengan 0 - 10 median
• Mampu mencetak hingga 50 km jalan (50 garis output)
• Tidak menggunakan celah standar apa pun
• Trailing white space tidak dapat diterima dengan pengecualian opsional \ndi akhir output

Output terbesar yang mungkin: 3700 byte (74 karakter * 50 baris).

Output sekecil mungkin: 5 byte (dengan input B, 1)

Asumsi

• Tidak ada median yang berdekatan (substring MMtidak akan terjadi)
• Garis tanda kedua mungkin terpotong (misalnya jika panjangnya 9 atau 12 km)
• Jalur mungkin tidak masuk akal secara logis (urutan apa pun dimungkinkan, misalnya jalur belok kanan di kiri jalan)

Ini adalah kode-golf , jadi kode terpendek (dalam byte) menang!

Ruby, 245

Cetak lajur yang dibagi jika relevan, kemudian cetak lajur.

Saya tidak berharap untuk menang.

->(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:?!}}

Changelog

245 tersedak stderr dan membagi array secara efektif.

263 cara yang lebih baik untuk mengindeks array

268 cukup cetak setiap baris, jangan hitung versi kanonik.

330 komit awal

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,' '))}}

Demo

Ini harus berfungsi di Firefox dan Edge pada saat penulisan, Chrome / Opera memerlukan fitur eksperimental untuk diaktifkan.

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»

Pendekatan yang sangat buruk, tetapi berhasil dan menyenangkan untuk dibuat. Pasti bisa bermain golf lagi.

+1 byte sebagai perbaikan bug untuk dua HHjalur yang berdekatan .

Cobalah online.

Penjelasan:

Langkah 1: Buat semua jalur yang mungkin dengan ukuran 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

Langkah 2: Konversi string input ke indeks (yang akan kita gunakan untuk mengindeks ke daftar yang kita buat di langkah 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

Langkah 3: kami menggunakan indeks tersebut untuk mengindeks ke dalam daftar jalur. Dan kemudian kita mengonversi daftar lajur tersebut ke output yang benar, termasuk memperluas / memperpendeknya ke ukuran input integer:

è                 # 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)

Lihat ini 05AB1E ujung tambang (bagian Cara string kompres bukan bagian dari kamus? Dan Cara kompres bilangan bulat besar? ) Untuk memahami mengapa Ž5Eadalah 1289; .•o¤[‹‡•adalah "tlrpbhmu"; ŽDýadalah 10201; •δ~¬]•adalah 1119188999; Ž\nÿadalah 19889.