前面的路涂

12

给定两个参数车道模式和道路长度，打印用于道路和交通服务的车道标记的ASCII表示形式以绘制道路。

输入/输出示例

输入： BTHMLRPHU，21

我不在乎您是否使用两个参数或将数字连接到字符串的末尾，这是明确的。

输入可能来自STDIN，作为函数参数，环境变量，无论您使用哪种语言都可以。

输出：

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

每个字符表示宽度0.5米，长度1公里。

规格

车道标记

对于每10公里的道路，在公里2、3、9和10（从输出的“顶部”开始）处绘制标记。标记在车道上居中。除了自行车道和中位数，所有车道的宽度均为3米（6个字符）。

ASCII金刚石和箭头字符不作为示例输出指示，以代替所述标记允许的。

  • B： 自行车道。B标记。宽1.5米（3个字符）。
  • T：过境。菱形标记
  • H：高占用车道。HOV3标记
  • L和R：转弯车道。箭头标记
  • P：通过车道。插入标记
  • U：无限制车道。无标记

分隔符（按优先顺序）

  • 中位数：（在输入字符串中以##表示M，替换包括沟渠在内的任何其他分隔符）
  • 沟渠（最左端和最右端）：!感叹号
  • HOV车道候补之间x和|每5公里
  • 正常： |

约束条件

您的函数或程序必须：

  • 打印到STDOUT（这意味着与System.out.printJava，console.logJavaScript等等效）
  • 能够打印1-9通道，中间值为0-10
  • 能够打印长达50公里的车道（50行输出）
  • 不使用任何标准漏洞
  • \n末尾的空格是不可接受的，除了输出末尾的可选字符

最大可能的输出：3700字节（74个字符* 50行）。

最小可能的输出：5个字节（使用input B，1）

假设条件

  • 没有相邻的中位数（MM不会出现子字符串）
  • 标记的第二行可能会被切除（例如，如果长度是9或12 km）
  • 车道在逻辑上可能没有意义（任何顺序都是可能的，例如，在道路左侧的右转车道）

这是代码高尔夫球，因此最短的代码（以字节为单位）获胜！

code-golf  ascii-art 
— 溜冰者6
source
1
在那儿，您喜欢等距字体
— WayToDoor

Answers:

4

红宝石，245

如果需要，打印车道分隔线，然后打印车道。

我不期望赢。

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

变更日志

245有效抑制stderr并拆分阵列。

263索引数组的更好方法

268只打印每一行，不计算规范版本。

330初次提交

— 不是那个查尔斯
source
我不希望Ruby获胜，但是如果下周没有其他答案，那么我猜你会获胜：-P在第二个注意事项上，我可以在任何地方进行测试而无需在计算机上安装Ruby？
— rink.attendant.15年
@ rink.attendant.6 ideone.com
— 不是查尔斯（Charles）
2

JavaScript（ES6），316个字节

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

演示版

在撰写本文时，它应可在Firefox和Edge中使用。Chrome/ Opera需要启用实验性功能。

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>
展开摘要

— 溜冰者6
source
1

05AB1E，175个 174 175 字节

ð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»

相当糟糕的方法，但是它有效并且制作起来很有趣。当然，可以打更多的球。

+1个字节作为两个相邻HH通道的错误修复。

在线尝试。

说明：

步骤1：建立大小为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

步骤2：将输入字符串转换为索引（我们将使用该索引将索引到在步骤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

步骤3：我们使用这些索引来索引车道列表。然后，我们将这些通道列表转换为正确的输出，包括将它们扩展/缩短为整数输入的大小：

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

看到这个05AB1E尖矿（部分如何压缩字符串不是字典的一部分吗？并且如何压缩大整数？）理解为什么Ž5E是1289; .•o¤[‹‡•是"tlrpbhmu"; ŽDý是10201; •δ~¬]•是1119188999; Ž\nÿ是19889。

— 凯文·克鲁伊森
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.