制作紧急走廊

46

在某些国家/地区，有关于如何在每个方向上有多个车道的街道上形成紧急通道的建议或法律。（在下文中，我们仅考虑沿行进方向行驶的车道。）以下是在德国适用的规则：

  • 如果只有一条车道，则每个人都应向右行驶，以使救援车辆可以从左侧驶过。
  • 如果有两个或更多车道，则最左侧车道上的汽车应向左行驶，其他所有人应向右行驶。

挑战

给定N>0常规车道的数量，使用一串N+1ASCII字符形成紧急通道时，输出车道的布局。您可以使用从ASCII码33到的任意两个字符126，一个代表紧急通道，一个代表汽车。允许尾随或前导空格，换行符等。

例子

在这里，我们E用于紧急通道和C汽车。

N  Output
1  EC
2  CEC
3  CECC
4  CECCC
5  CECCCC
6  CECCCCC
   etc
code-golf  ascii-art  number 
— 瑕疵
source
18
我不会为此而倒下！您只是在寻找一条自己的小路来溜溜溜溜地穿过蛇。
— orlp
16
@PmanAce我真的不认为骗子需要我们的帮助：P
— orlp
8
+1，因为它实际上在德国有效。上周末处于这种状况。
— ElPedro '18 -4-4
10
@ msh210我认为德国WP页面中的图片可以最好地说明这一点。
— 瑕疵的
9
你知道，在第一本看起来像一个到了点挑战，C和E，但有这么多漂亮的迎接这一挑战可能的办法！像C=1/ E=2或C=2/ E=3那样，对顶部或顶部使用数学运算；使用C=0/ E=1与10^(n-1); 使用C=0/ E=.通过十进制格式0.0; 使用C=1/ E=-通过利用-1; 等等。最初挑战如此之多的挑战有很多独特的可能性。太糟糕了，我只能+1。;）
— Kevin Cruijssen

Answers:

29

Python 2，29 26字节

lambda n:10**n*97/30-1/n*9

例：

>>> f(1)
23
>>> f(2)
323
>>> f(3)
3233
— 奥尔普
source
您需要在n = 1的情况下输出21
— DanielIndie '18
1
@DanielIndie :(已修复，但现在很丑
— 。– orlp
仍然是一个非常有创意的解决方案：）
— 更加糟糕的
1
@orlp抱歉：），但仍然是一个很好的解决方法：）
— DanielIndie
3
10**n*97/30-1/n*9节省了另一个字节，给人f(5) == 323333等
— 林恩
28

Python 3，35 33字节

lambda N:'C'*(N>1)+'EC'+'C'*(N-2)

编辑：删除f=以保存2个字节，这要感谢@dylnan的提醒。

在线尝试！

可视化它：

lambda N:'🚘'*(N>1)+'🚔🚘'+'🚘'*(N-2)

输出：

1 🚔🚘
2 🚘🚔🚘
3 🚘🚔🚘🚘
4 🚘🚔🚘🚘🚘
5 🚘🚔🚘🚘🚘🚘
6 🚘🚔🚘🚘🚘🚘🚘

在线尝试🚔！

Python 3，40个字节

一个简单的解决方案：

lambda N:str(10**N).replace('100','010')

在线尝试！

— 秦国阳
source
2
我认为，“直截了当”的解决方案在后面有多余的空格lambda N:
— 有人
@某人我不知道这一点，谢谢。
— Guoyang Qin
14

Japt，5个 4字节

用途q汽车和+用于走廊。

ç¬iÄ

试试吧

感谢Oliver，他像我一样同时打了4个字节。

说明

一个简短的解决方案，但一个棘手的解释！

首先是简单明了的东西：该ç方法应用于整数时，将其字符串参数重复该次数。该i方法采用2个参数（s＆n），并s在要n应用的字符串的索引处插入。

扩展所使用的2个unicode快捷方式将为我们提供çq i+1，将其转换为JS时U.ç("q").i("+",1)，U输入在哪里。所以我们要重复q U一次，然后+在索引1处插入一个。

最后一个诀窍是，由于Japt指数包裹的时候U=1，i将插入+索引0，任何价值，你给它的n。

— 毛茸茸
source
我打算发布ç0 iQ16个字节，但如果使用它会更好。
— 奥利弗
谢谢，@ Oliver。同时，将其压缩为5个字节。
— Shaggy
1
ç¬iÅ4字节;）我从来没有滥用Japt这么多。
— 奥利弗
我正要用Ä而不是Å:) 做同样的事情
— Shaggy
7

R，50个字节

-11感谢朱塞佩！

pryr::f(cat("if"(x<2,12,c(21,rep(2,x-1))),sep=""))

紧急通道的输出1和普通车道的输出2

我的尝试，61个字节

这里没什么好看的，但让我们在记分板上得到R =）

q=pryr::f(`if`(x<2,cat("EC"),cat("CE",rep("C",x-1),sep="")))

用法：

q(5)
CECCCC
— 受牵制
source
使用21 = 12 + 9并使用if / tio.run
— ## K
6

Python 2中，30个 29 28字节

lambda n:`10/3.`[1/n:n-~1/n]

打印3代替C和.代替E。

说明：

在线尝试。

lambda n:    # Method with integer parameter and string return-type
  `10/3.`    #  Calculate 10/3 as decimal (3.333333333) and convert it to a string
  [1/n       #   Take the substring from index 1 if `n=1`, 0 otherwise
   ,n-~      #   to index `n+1` +
       1/n]  #    1 if `n=1`, 0 otherwise

Python 2，33 32 31 29 28字节

lambda n:1%n-1or'1-'+'1'*~-n

打印1代替C和-代替E。

-2个字节，感谢@ovs。
-1个字节，感谢@xnor。

说明：

在线尝试。

lambda n:    # Method with integer parameter and string return-type
  1%n-1      #  If `n` is 1: Return '-1'
  or         #  Else:
    '1-'+    #   Return '1-', appended with:
    '1'*~-n  #   `n-1` amount of '1's
— 凯文·克鲁伊森
source
1
您的10/3一个失败于17
— Jo King
1
@JoKing我刚刚用OP进行了澄清，他说“ 使用内置的整数类型就足够了。 ”，这意味着n=16您的整数内置是否为64位就足够了，或者在这种情况下n=16，十进制值可以默认情况下，t可以容纳超过15个十进制数字。（同样适用于许多其他使用任意数字大小的语言的答案，例如Java，C＃.NET等）
— Kevin Cruijssen
5

Pyth，10 9 8字节

Xn1Q*NQZ

用于0表示紧急走廊和"。
在这里尝试

说明

Xn1Q*NQZ
    *NQ     Make a string of <input> "s.
 n1Q         At index 0 or 1...
X      Z    ... Insert 0.
— 助记符
source
5

疯子，42字节

,[[>]+[<]>-]>>[<]<[<]>+>+<[<-[--->+<]>.,>]

在线尝试！

将输入作为字符代码，将输出作为V普通通道和W已清除通道。（为了方便测试，我建议将替换,为+多个）

这个怎么运作：

,[[>]+[<]>-] Turn input into a unary sequence of 1s on the tape
>>[<]<[<]    Move two cells left of the tape if input is larger than 1
             Otherwise move only one space
>+>+<        Add one to the two cells right of the pointer
             This transforms:
               N=1:  0 0' 1 0  -> 0 2' 1 0
               N>1:  0' 0 1 1* -> 0 1' 2 1*
[<-[--->+<]>.,>]  Add 86 to each cell to transform to Ws and Vs and print
— 乔·金
source
5

八度（MATLAB *），31 30 28 27 22字节

@(n)'CE'(1+(n>1==0:n))

在线尝试！

该程序的工作方式如下：

@(n)                   %Anonymous function to take input
            n>1==0:n   %Creates [1 0] if n is 1, or [0 1 (0 ...)] otherwise
         1+(        )  %Converts array of 0's and 1's to 1-indexed
    'CE'(            ) %Converts to ASCII by addressing in string

这里使用的技巧是，对X的种子数组进行XNOR运算，0:n检查输入是否大于1。结果是，n>1将种子转换为的逻辑数组，[0 1 (0 ...)]同时n==1将种子反转为[1 0]，从而实现了必要的反转。

剩下的只是将种子转换为带有足够附加汽车的字符串。

（*）TIO链接在页脚注释中提供了一种替代解决方案，用于在MATLAB和Octave中均可使用的相同数目的字节，但结果为序列“ 0”和“ 1”，而不是“ E”和“ C'。为了完整起见，替代方案是：

@(n)['' 48+(n>1==0:n)]

  • 使用n==1~=0:1而不是保存了1个字节0:1~=(n<2)。~=优先于<，因此是原始括号，但似乎~=并按==出现顺序处理，因此与1进行比较可以节省一个字节。

  • 通过更改取反的位置保存2个字节2:n。这样可以节省一对括号。我们还必须将更~=改为，==以解决稍后将被否定的事实。

  • <再次使用保存了1个字节。事实证明，毕竟<具有相同的优先级==。<在==确保正确的执行顺序之前放置计算。

  • 通过不创建两个单独的数组节省了5个字节。相反，它依赖于XNOR比较将无论如何将单个范围转换为逻辑的事实。

— 汤姆·卡彭特
source
非常聪明:-)
— 斯蒂夫·格里芬
@StewieGriffin谢谢:)。设法再敲除5个字节。
— 汤姆·卡彭特
4

Python 3，32个字节

lambda n:f"{'CE'[n<2:]:C<{n+1}}"

在线尝试！

使用f字符串表达式来设置格式'E'或'CE'在右侧进行填充，'C'因此宽度为n+1。

f"{          :       }    a Python 3 f-string expression.
   'CE'[n<2:]             string slice based on value of n.
             :            what to format is before the ':' the format is after.
              C           padding character
               <          left align
                {n+1}     minimum field width based on n
— 根二
source
4

Brain-Flak，100 66字节

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

在线尝试！

用途"为应急车道，并!作为普通车道。

— 乔·金
source
+1以使用万物的这种语言。XD
— Alex
2
@Alex，那么，脑Flak是本月的月的语言
— 乔金
严重还是愚人节的玩笑？本月的语言在哪里选举？
— Alex
@Alex提名并在这里投票，然后制作一个月特定的帖子，例如这样
— Kamil Drakari 18-4-5
哦，它在这个平台上。我明白了，谢谢！:-)
— Alex
4

05AB1E，7个字节

Î>∍1I≠ǝ

在线尝试！

0是C，1是E。

说明

Î>          # Push 0 and input incremented            -- [0, 4]
  ∍         # Extend a to length b                    -- [0000]
   1I≠      # Push 1 and input falsified (input != 1) -- [0000, 1, 1] 
      ǝ     # Insert b in a at location C             -- [0100]
            # Implicit display
— 卡尔多
source
哦，狡猾的狐狸。$<×TìsiR是我的想法
— 魔术章鱼缸
@MagicOctopusUrn这是一个有趣的方法！我也徘徊在“ if”构造上，但是它至少需要3个字节，因此需要一种不同的方法：-)
— Kaldo
在新版本的05AB1E中，1I可以打高尔夫球$。
— 凯文·克鲁伊森
5个字节（在旧版本中也适用）。
— 凯文·克鲁伊森
4

APL（Dyalog Unicode），21 17 16字节

(-≠∘1)⌽'E',⍴∘'C'

在线尝试！

感谢Erik节省了4个字节，Adám又节省了一个字节。

怎么样？

(-≠∘1)⌽'E',⍴∘'C' ⍝ Tacit function
           ⍴∘'C' ⍝ Repeat 'C', according to the input
       'E',      ⍝ Then append to 'E'
      ⌽          ⍝ And rotate
    1)           ⍝ 1
  ≠∘             ⍝ Different from the input? Returns 1 or 0
(-               ⍝ And negate. This rotates 0 times if the input is 1, and once if not.
— J·萨莱
source
1
(⍵>1)不需要放在括号中。您可以使用默认功能保存4个字节：(⊢×1<⊢)⌽'E',⍴∘'C'。
— Erik the Outgolfer
@EriktheOutgolfer谢谢！发布后，我没有时间默契，因为我今天有课。到家后我会编辑。
— J.Sallé18年
— 亚当
15个字节与⎕io= 0：'CE'[1(≠=∘⍳+)⎕]
— NGN
@ngn我什至不能...你能给我一个测试用例的TIO链接吗？似乎无法使其正常工作……
— J.Sallé18年
4

Haskell，35 33 32字节

Angs节省了2个字节，Lynn节省了1个字节

(!!)$"":"EC":iterate(++"C")"CEC"

在线尝试！

Haskell，32 30 29字节

该索引为零，因此不符合挑战

g=(!!)$"EC":iterate(++"C")"CEC"

在线尝试！

Haskell，30个字节

这不起作用，因为输出必须是字符串

f 1=21
f 2=121
f n=10*f(n-1)+1

在线尝试！

在这里，我们2在紧急通道，1汽车中使用数字而不是字符串。我们可以将a 1乘以10并加到最后1。这样比较便宜，因为我们不必为连接和字符串文字支付所有字节。

使用它会更便宜0，1但是我们需要前导零，最终将其修剪掉。

— 小麦巫师
source
((blah)!!)可以(!!)$blah在您的前两个答案中节省一个字节。
— Lynn '18
@琳恩谢谢！我试图尽早这样做，但是我一定对字节数有误。
— 小麦巫师
4

Python 3中，30 29个字节

lambda n:"CEC"[~n:]+"C"*(n-2)

在线尝试！

好的，已经有很多Python答案，但是我认为这是仍然使用“ E”和“ C”字符而不是数字的人中第一个30位以下的人。

— 基里尔
source
3

Stax，7 个字节

ü♣àj#F

运行并调试

它使用字符“ 0”和“ 1”。之所以起作用，是因为旋转大小为1的数组时，它不会改变。

拆开包装，松开包装并进行评论，看起来像这样。

1]( left justify [1] with zeroes. e.g. [1, 0, 0, 0]
|)  rotate array right one place
0+  append a zero
$   convert to string

运行这个

— 递归的
source
3

果冻，6字节

⁵*ṾṙỊṙ

将车道显示为0，紧急车道显示为1。

在线尝试！

这个怎么运作

⁵*ṾṙỊṙ  Main link. Argument: n

⁵*      Compute 10**n.
  Ṿ     Uneval; get a string representation.
   ṙỊ   Rotate the string (n≤1) characters to the left.
     ṙ  Rotate the result n characters to the left.
— 丹尼斯
source
3

空格，141个 104 103字节

[S S S N
_Push_0][S N
S _Duplicate_0][T   N
T   T   _Read_STDIN_as_number][T    T   T   _Retrieve][S S S T  S N
_Push_2][T  S S T   _Subtract][S N
S _Duplicate_input-2][N
T   T   N
_If_negative_Jump_to_Label_-1][S S S T  N
_Push_1][S N
S _Duplicate_1][T   N
S T _Print_as_integer][S S T    T   N
_Push_-1][T N
S T _Print_as_integer][T    S S T   _Subtract][N
S S T   N
_Create_Label_LOOP][S N
S _Duplicate][N
T   T   S N
_If_negative_Jump_to_EXIT][S S S T  N
_Push_1][S N
S _Duplicate_1][T   N
S T _Print_as_integer][T    S S T   _Subtract][N
S N
T   N
_Jump_to_LOOP][N
S S N
_Create_Label_-1][T N
S T _Print_as_integer][N
S S S N
_Create_Label_EXIT]

字母S（空格），T（制表符）和N（换行符）仅作为突出显示而添加。
[..._some_action]仅作为说明添加。

1代替C和-代替打印E。

-1字节感谢@JoKing通过建议使用1and -1代替0and 1。

伪代码中的解释：

Integer i = STDIN-input as integer - 2
If i is negative (-1):
  Print i (so print "-1")
Else:
  Print "1-1"
  Start LOOP:
    If i is negative:
      EXIT program
    Print "1"
    i = i-1
    Go to the next iteration of the LOOP

示例运行：

输入： 1

Command   Explanation                 Stack      Heap    STDIN   STDOUT   STDERR

SSSN      Push 0                      [0]
SNS       Duplicate top (0)           [0,0]
TNTT      Read STDIN as integer       [0]        {0:1}   1
TTT       Retrieve heap at 0          [1]        {0:1}
SSSTSN    Push 2                      [1,2]      {0:1}
TSST      Subtract top two            [-1]       {0:1}
SNS       Duplicate input-2           [-1,-1]    {0:1}
NTSN      If neg.: Jump to Label_-1   [-1]       {0:1}
NSSN      Create Label_-1             [-1]       {0:1}
TNST      Print top as integer        []         {0:1}           -1
NSSSN     Create Label_EXIT           []         {0:1}
                                                                         error

在线尝试（仅使用空格，制表符和换行符）。
因错误而停止：未定义退出。

输入： 4

Command   Explanation                   Stack      Heap    STDIN   STDOUT   STDERR

SSSN      Push 0                        [0]
SNS       Duplicate top (0)             [0,0]
TNTT      Read STDIN as integer         [0]        {0:4}   4
TTT       Retrieve heap at 0            [4]        {0:4}
SSSTSN    Push 2                        [4,2]      {0:4}
TSST      Subtract top two              [2]        {0:4}
SNS       Duplicate input-2             [2,2]      {0:4}
NTSN      If neg.: Jump to Label_-1     [2]        {0:4}
SSSTN     Push 1                        [2,1]      {0:4}
SNS       Duplicate top (1)             [2,1,1]    {0:4}
TNST      Print as integer              [2,1]      {0:4}           1
SSTTN     Push -1                       [2,1,-1]   {0:4}
TNST      Print as integer              [2,1]      {0:4}           -1
TSST      Subtract top two              [1]        {0:4}
NSSTN     Create Label_LOOP             [1]        {0:4}
 SNS      Duplicate top (1)             [1,1]      {0:4}
 NTTSN    If neg.: Jump to Label_EXIT   [1]        {0:4}
 SSSTN    Push 1                        [1,1]      {0:4}
 SNS      Duplicate top (1)             [1,1,1]    {0:4}
 TNST     Print as integer              [1,1]      {0:4}           1
 TSST     Subtract top two              [0]        {0:4}
 NSNTN    Jump to Label_LOOP            [0]        {0:4}

 SNS      Duplicate top (0)             [0,0]      {0:4}
 NTTSN    If neg.: Jump to Label_EXIT   [0]        {0:4}
 SSSTN    Push 1                        [0,1]      {0:4}
 SNS      Duplicate top (1)             [0,1,1]    {0:4}
 TNST     Print as integer              [0,1]      {0:4}           1
 TSST     Subtract top two              [-1]       {0:4}
 NSNTN    Jump to Label_LOOP            [-1]       {0:4}

 SNS      Duplicate top (-1)            [-1,-1]    {0:4}
 NTTSN    If neg.: Jump to Label_EXIT   [-1]       {0:4}
NSSSN     Create Label_EXIT             [-1]       {0:4}
                                                                            error

在线尝试（仅使用空格，制表符和换行符）。
因错误而停止：未定义退出。

— 凯文·克鲁伊森
source
是否会像-通过滥用打印来打印畅通通道一样容易-1？
— Jo King
@JoKing不幸的是，这会更长。在线尝试112字节。确实改变了push_0; print_as_integer; push_1; print_as_integer到push_-1; print_as_integer，但是作为交换push_0; print_as_integer被取代push_45; print_as_character，其中push_0= SSSN和push_45= SSSTSTTSTN。并且push_45还必须添加一个附加项，因为对于输入，n=1我现在打印0我已经在堆栈上的副本，因此我不必0再次推送，因为0已经在堆栈上。
— 凯文·克鲁伊森
我的意思-是替换1和1替换0。这样一来，您就不必再按45，而据我所知，这将节省在有条件的前半部分中打印数字的费用，但是将按1而不是0的成本稍微提高了。请检查我的Gol> <>答案我的意思是输出示例
— Jo King
1
@JoKing我尝试实现它，但最终得到了107个字节（这是相同的代码，带有突出显示和说明）。实际上，它可以节省print_-1打印时间，而不是print 0和1，但是print_-1在循环之外还需要其他操作。编辑：能够通过更改将其减少到103个字节subtract_1；if_0_jump_to_ONE; push_-1; print_integer到subtract_2; if_negative_jump_to_ONE; print_integer，因为-1已经在堆栈中了。因此，感谢-1个字节。:)
— Kevin Cruijssen
3

AutoHotkey 32字节

除非C的数量大于1，否则将字母“ C”替换为“ EC”，然后发送“ CEC”并退出应用程序。

::C::EC
:*:CC::CEC^c
^c::ExitApp

C => EC
CC => CEC然后退出程序。程序退出后，将再输入其他C。

— 纳尔森特鲁兰
source
3

APL + WIN，20 16字节

多亏了Adám，节省了4个字节

提示输入整数n：

(-2≠⍴n)⌽n←1⎕/⍕10

1用于紧急通道o用于汽车。

— 格雷厄姆
source
16：(-2≠⍴n)⌽n←1⎕/⍕10
— 亚当
@Adám谢谢。我看到ngn的技巧1⎕/⍕很有用。一个成语列表？
— 格雷厄姆
您在说什么成语列表？
— 阿达姆（Adám）'18年
@Adám我最常使用的两个成语列表是Finnapl和APL2成语
— Graham
我不确定这里有什么惯用语。这只是高尔夫球。无论如何，我的成语清单可能会让您感兴趣。
— 亚当
3

MathGolf，7 6 个字节

ú░\┴╜╪

在线尝试。

输出1为E和0的C。

说明：

ú         # 10 to the power of the (implicit) input
          #  i.e. 1 → 10
          #  i.e. 4 → 10000
 ░        # Convert it to a string
          #  i.e. 10 → "10"
          #  i.e. 10000 → "10000"
  \       # Swap so the (implicit) input is at the top of the stack again
   ┴╜     # If the input is NOT 1:
     ╪    #  Rotate the string once towards the right
          #   i.e. "10000" and 4 → "01000"
          # Output everything on the stack (which only contains the string) implicitly
— 凯文·克鲁伊森
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.