Сделать аварийный коридор

46

В некоторых странах существуют рекомендации или законы о том, как формировать аварийные коридоры на улицах с несколькими полосами движения в каждом направлении. (Далее мы рассматриваем только полосы, идущие в том направлении, в котором мы движемся.) В Германии действуют следующие правила:

  • Если есть только одна полоса движения, все должны ехать направо, чтобы спасательные машины могли проехать слева.
  • Если есть две или более полосы движения, машины на самой левой полосе должны двигаться влево, а все остальные должны двигаться вправо.

Вызов

Учитывая количество N>0регулярных дорожек, выведите расположение полос при формировании аварийного коридора, используя строку N+1символов ASCII. Вы можете использовать любые два символа от кода 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 flawr
источник
18
Я не влюблюсь в это! Вы просто ищете свою собственную полосу, чтобы скользить сквозь вас подлый змей.
orlp
16
@PmanAce Я действительно не думаю, что flawr нуждается в нашей помощи для этого: P
orlp
8
+1 потому что на самом деле это работает в Германии. Был в ситуации на прошлых выходных.
ElPedro
10
@ msh210 Я думаю, что картинки на немецкой странице WP объясняют это лучше всего.
flawr
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 один раз. ;)
Кевин Круйссен

Ответы:

29

Python 2, 29 26 байт

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

Пример:

>>> f(1)
23
>>> f(2)
323
>>> f(3)
3233
orlp
источник
вам нужно вывести 21 в случае n = 1
DanielIndie
1
@DanielIndie :( исправлено, но теперь это уродливо.
orlp
Все еще очень креативное решение :)
flawr
1
@ orlp извините :) но все же
отличное
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')

Попробуйте онлайн!

Гоян Цинь
источник
2
Я думаю, что у «простого» решения есть лишние пробелы послеlambda N:
кто-то
@ кто-то, я не знал об этом, спасибо.
Гоян Цинь
14

Japt, 5 4 байта

Используется qдля автомобилей и +для коридора.

ç¬iÄ

Попытайся

Благодарю Оливера, который играл в гольф на 4 байта одновременно, как и я.

объяснение

Краткое решение, но сложное объяснение!

Сначала простые вещи: çметод, когда применяется к целому числу, повторяет свой строковый аргумент столько раз. iМетод принимает 2 аргумента ( s& n) и вставки sв индексе nстроки она применяется.

Расширение двух используемых ярлыков Unicode дает нам çq i+1, что, когда передается в JS становится U.ç("q").i("+",1), где Uввод. Итак, мы повторяем q Uвремена, а затем вставляем +в индекс 1.

Последний трюк заключается в том, что благодаря переносу индекса Japt, когда U=1, iвставит +индекс at , для какого 0бы значения вы его ни указывали n.

мохнатый
источник
Я собирался опубликовать ç0 iQ1для 6 байтов, но было бы лучше, если бы вы использовали его.
Оливер
Спасибо, @Oliver. Тем не менее, до 5 байтов.
Лохматый
1
ç¬iÅза 4 байта;) Я никогда не злоупотреблял Джаптом так сильно.
Оливер
Я собирался сделать то же самое Äвместо Å:)
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
Punintended
источник
Сохраните 8 байтов, используя 21 = 12 + 9 и принудительно установив ИСТИНА / ЛОЖЬ на 1/0 без if tio.run/##K/r/v6CossjKKk0jObFEw1JLI8/…
JayCe
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
Кевин Круйссен
источник
1
Твой 10/3неудачник в 17 лет
Джо Кинг,
1
@JoKing Я только что разъяснил с помощью OP, и он сказал: « Достаточно использовать встроенный целочисленный тип». Это означает, что достаточно , n=16если 64-разрядное встроенное целое число достаточно, или в этом случае, n=16когда десятичное значение может по умолчанию достаточно более 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.
мнемонический
источник
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
Джо Кинг
источник
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

Прием, используемый здесь, заключается в том, чтобы 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)]

  • Сохранено 1 байт с помощью, n==1~=0:1а не 0:1~=(n<2). ~=имеет приоритет над <, следовательно , оригинальные скобки, но , кажется , что ~=и ==обрабатываются в порядке их появления путем сравнения с 1 мы можем сохранить байт.

  • Сохранено 2 байта путем изменения места выполнения отрицания 2:n. Это экономит пару скобок. Мы также должны изменить на, ~=чтобы ==учесть тот факт, что он будет отменен позже.

  • Сохранено 1 байт с помощью <снова. Оказывается, это <имеет тот же приоритет, что и в ==конце концов. Размещение <расчета до ==обеспечивает правильный порядок исполнения.

  • Сохранено 5 байт, не создавая два отдельных массива. Вместо этого полагайтесь на тот факт, что сравнение XNOR в любом случае преобразует один диапазон в логические.

Том Карпентер
источник
Очень умно :-)
Стьюи Гриффин,
@StewieGriffin Спасибо :). Удалось сбить еще 5 байтов больше.
Том Карпентер
4

Python 3, 32 байта

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

Попробуйте онлайн!

Использует выражение ф-строку в формат либо '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
RootTwo
источник
4

Brain-Flak , 100 66 байт

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

Попробуйте онлайн!

Используется "как аварийная полоса и !как обычная полоса .

Джо Кинг
источник
+1 за использование этого языка всех вещей. XD
Алекс
2
@Alex, Ну, Brain-Flak - это язык месяца апреля
Джо Кинг,
Серьезно или в конце апреля дурацкая шутка? Где выбираются языки месяца?
Алекс
@Alex Номинации и голосование здесь , а затем делается пост на конкретный месяц, такой как этот
Камил Дракари
О, это на этой платформе. Ясно спасибо! :-)
Alex
4

05AB1E , 7 байтов

Î>∍1I≠ǝ

Попробуйте онлайн!

0 - это С, а 1 - это Е.

объяснение

Î>          # 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
Kaldo
источник
Ох ты хитрый лис. $<×TìsiRбыло, как я думал.
Волшебная Урна Осьминога
@MagicOctopusUrn Это интересный подход! Я тоже немного размышлял над конструкцией «если», но она требует как минимум 3 байта, поэтому нужен другой подход :-)
Kaldo
В новой версии 05AB1E, 1Iможно в гольф $.
Кевин Круйссен
5 байт (также работает в устаревшей версии).
Кевин Круйссен
4

APL (Dyalog Unicode) , 21 17 16 байтов

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

Попробуйте онлайн!

Спасибо Эрику за сохранение 4 байта и Адаму за еще один байт.

Как?

(-≠∘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.
Ж. Салле
источник
1
(⍵>1)не должно быть в скобках. И вы можете сохранить 4 байта с молчаливой функцией: (⊢×1<⊢)⌽'E',⍴∘'C'.
Эрик Outgolfer
@EriktheOutgolfer спасибо! У меня не было времени молчать после публикации, потому что у меня сегодня был урок. Я отредактирую, когда вернусь домой.
J. Sallé
(-≠∘1)⌽'E',⍴∘'C'или =∘1⌽¯1⌽'E',⍴∘'C'.
Адам
15 байтов с ⎕io = 0:'CE'[1(≠=∘⍳+)⎕]
ngn
@ngn Я даже не могу ... ты можешь дать мне ссылку TIO с тестовыми примерами? Не могу заставить его работать ...
J. Sallé
4

Haskell , 35 33 32 байта

2 байта сохранены благодаря Angs, 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для автомобилей. Мы можем добавить 1в конец, умножив на 10 и добавив 1. Это дешевле, потому что нам не нужно платить за все байты для конкатенации и строковых литералов.

Было бы дешевле использовать 0вместо, 1но нам нужны ведущие нули, которые в конечном итоге обрезаются.

Мастер пшеницы
источник
((blah)!!)может стать (!!)$blahсохранить байт в ваших первых двух ответах.
Линн
@ Линн Спасибо! Я пытался сделать это раньше, но я, должно быть, неправильно сосчитал байты.
Пшеничный волшебник
4

Python 3 , 30 29 байт

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

Попробуйте онлайн!

Хорошо, уже есть много ответов на Python, но я думаю, что это первый младший байт из тех, кто все еще использует символы "E" и "C", а не числа.

Кирилл Л.
источник
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

Запустите этот

рекурсивный
источник
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.
Деннис
источник
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 , предложив использовать 1и -1вместо 0и 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

Попробуйте онлайн (только с необработанными пробелами, вкладками и новыми строками).
Останавливается с ошибкой: выход не определен.

Кевин Круйссен
источник
Будет ли легче напечатать прозрачную полосу, как -злоупотребляя печатью -1?
Джо Кинг,
@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> <> для Пример вывода, который я имею в виду
Джо Кинг,
1
@JoKing Я пытался реализовать это, но в итоге я получил 107 байт (здесь тот же код с добавлением выделения и пояснения ). Это действительно экономит print_-1вместо печати 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 байт. :)
Кевин Круйссен
3

AutoHotkey 32 байта

Заменяет букву «C» на «EC», если количество C> 1, затем отправляет «CEC» и выходит из приложения.

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

C => EC
CC => CEC затем выходит из программы. Все дальнейшие C будут введены после выхода из программы.

nelsontruran
источник
3

APL + WIN, 20 16 байтов

4 байта сохранены благодаря Адаму

Запрашивает целое число n:

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

1 для аварийного коридора o для автомобилей.

Грэхем
источник
16:(-2≠⍴n)⌽n←1⎕/⍕10
Адам
@ Adám Спасибо. Я вижу, что трюк ngn, 1⎕ / ⍕, пригодится. Один для списка идиом?
Грэм
О каком идиоме ты говоришь?
Адам
@ Adám Чаще всего я использую два списка идиом: Finnapl и APL2idioms
Грэм,
Я не уверен, что здесь так идиоматично. Это просто гольф. В любом случае, мой список идиом может вас заинтересовать.
Адам
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
Кевин Круйссен
источник