Это первое в серии, второе - это две дороги, разошедшиеся в желтом лесу (часть 2)

Этот вызов вдохновлен знаменитым стихотворением Роберта Фроста «Дорога не пройдена»:

Две дороги расходились в желтом лесу,
И мне жаль, что я не мог путешествовать обоими
И быть одним путешественником, долго я стоял
И смотрел вниз на одну так далеко, как мог,
На то, где оно согнулось в подлеске;

Тогда взял другой, столь же справедливый,
И имеющий, возможно, лучшую претензию,
Потому что он был травяной и хотел носить;
Хотя что касается того, что проходивший там
носил их действительно примерно одинаково,

И оба в то утро одинаково лежали
В листьях ни шагу не ступали черными.
О, я оставил первый на следующий день!
Все же зная, как путь ведет на путь,
я сомневался, должен ли я когда-нибудь вернуться.

Я расскажу это со вздохом
Где-то через века и века:
две дороги расходились в лесу, и я…
я выбрал ту, по которой меньше путешествовал,
И это имело все значение.

Обратите внимание на вторую и последнюю строку I took the one less traveled by,.

Ваш актуальный вызов

Вы примете участие в форме как:

#     ##
 #   ##
  # ##
   #
   #
   #

и вы должны найти более тонкую дорогу.

Дорога начинается внизу с # . Две другие дороги, которые всегда заканчиваются в верхнем ряду, - это дороги, которые вы должны исследовать. Дорога, которая является самой толстой, является наиболее пройденной, и, следовательно, это не то, что вы хотите. Другой меньше всего путешествует, и это тот, который вы хотите.

Выход

Ваша программа / функция должна вывести одно из 2 различных значений (например, 0 или 1, истина или ложь), по одному для каждого возможного положения дороги, которое не занято. Например, вы можете вывести 0, если не пройденная дорога находится слева от выбранной дороги, и 1 в противном случае, или вы можете вывести строку «left» или «right», true, false и т. Д.

Тестовые случаи:

 ##    #
  ##  #
   ###
    #
    #
    #

Мог бы вывести «правильно».

 ##  #   
  ## #  
   ###
    ##
     #
     #
     #

Мог бы вывести «правильно».

 ##  #   
  ## #  
   ###
    ##
   # 
  #  
 #   

Мог бы вывести «правильно».

 ##   #  
  ## #  
   ###
    #
   # 
  #  
  #  

Мог бы вывести «правильно».

 #    ## 
  #  ## 
   ###
    #
   # 
  #  
  #  

Мог бы вывести «влево»

 #    ## 
  #  ## 
   ###
    #
     #
     #
     #

Мог бы вывести «влево»

Примечания

• Это код-гольф , поэтому выигрывает самый короткий ответ в байтах
• Стандартные лазейки запрещены
• Вы должны указать свои выходы для «левого» и «правого», и они должны быть разными
• Ввод будет одной большой строкой и может иметь любое количество строк
• Вам не нужно беспокоиться о правильном вводе.
• Дорога всегда Y-образной формы, поэтому вам нужно только смотреть сверху.
• Есть вопросы? Комментарий ниже:

Побеждает меньшее количество байтов!

CJam , 1 байт

r

rПереводит первый струнный соседние символы непробельных из STDIN в стеке, так что отпечатки ##для оставил и #для права .

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

JavaScript (ES6), 19 12 байт

Редактировать:

Более гольф версия

a=>a.trim[1]

Возвращает #справа и пробел слева.

Оригинал:

a=>a.trim()[1]=='#'

объяснение

Ungolfed :

function(input) {
  return input.trim().charAt(1) === '#';
};

Первое, что делает эта функция, это убирает пробелы в начале и конце ввода. Это означает, что первый символ всегда #. Затем я проверяю второй символ (JavaScript начинается с 0) и проверяю, является ли он #символом. Это возвращает логическое значение. Если путь rightбудет true, он останется, он вернется false.

Как я играл в гольф

В ES6 есть сокращение от анонимной функции, называемое функцией стрелки . Это означает, что я могу взять свою функцию-обертку и превратить ее в:

input => ...;

Из-за правил функций стрелок он вернет остальную часть кода. Оттуда я перешел charAt(1)на [1]более короткий путь, хотя и не рекомендуется . Тогда я взял ===и превратил это в ==. Хотя в этом случае они разные, это не имеет значения. Наконец, я переименовал inputв aи удалить все пробелы.

Выведите направо и налево

Хотя головоломке на самом деле не нужна программа для вывода вправо и влево, вот пример других выводов:

a=>a.trim()[1]=='#'?'right':'left'

Единственная добавленная часть ?'right':'left'. Это создает троичный оператор , сжатый оператор if, это означает, что (не зачищенный) код равен *:

function(input) {
  let output = input.trim().charAt(1) === '#';
  if(output) {
    return 'right';
  } else {
    return 'left'
  }
};

пример

// Function assignment not counted in byte count
let f =
a=>a.trim()[1]=='#'

<textarea placeholder="Put path in here" id="path" rows="10" style="width:100%"></textarea>
<button onclick="document.getElementById('result').textContent = f(document.getElementById('path').value)">Submit</button>
<p id="result"></p>

Pyth, 2 байта

hc

Выходы #слева и ##справа.

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

объяснение

hc
 cQ     Split the (implicit) input on whitespace.
h       Get the first part.

Точность !!30 байтов

Из-за способа Acc! принимает ввод, он выдаст вывод только после ввода одной строки ввода. Но если вы передадите ввод или перенаправите его из файла, вы не должны заметить разницы.

Count i while 35-N {
}
Write N

Принимает ввод от стандартного ввода. Выводится, если левая дорога менее пройдена, или #если правая дорога менее пройдена. Попробуйте онлайн!

объяснение

Nчитает значение ASCII символа из stdin каждый раз, когда на него ссылаются. Пока 35-Nмы правдивы; то есть пока 35-N != 0или N != 35. Поэтому, когда цикл завершается, мы только что прочитали первый #символ в строке. Следующий символ затем читается Nи записывается обратно в стандартный вывод Write.

Сетчатка, 5 байт

Выходы, 1если справа, 0если слева.

^ *##

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

Если значения для положительного результата не должны быть различимы (5 байтов):

Выводит положительное целое число, если справа, ноль, если слева.

## +#

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

Язык формул IBM / Lotus Notes, 37 35 26 байт

Редактировать Я всегда забываю, что @Likeс подстановочными знаками на 2 байта дешевле, чем @Contains.

Редактировать 2 На самом деле не нужно, @ifпоскольку он просто печатает 1или 0зависит от того, приводит ли формула к @Trueили @False.

@Like(@Left(a;"##");"%#%")

Вычисляемая формула поля. Просто возьмите все слева от первого, который ##он находит в поле, aи, если есть #в нем, выводит 1для левого, иначе выводит 0для правого.

Благодаря @DavidArchibald, вот решение для 22 байтов. Из уважения к решению Davids я не буду публиковать его в качестве основного ответа.

@Left(@Trim(a);2)="##"

Этот вывод 1для правого и 0левого.

Пип , 8 6 байт

a~`#+`

Принимает ввод в качестве аргумента командной строки (который будет нуждаться в цитировании и экранировании новых строк при запуске из фактической командной строки). Выводится, #если левая дорога менее пройдена, и ##если правая дорога менее пройдена. Попробуйте онлайн!

объяснение

При этом используется недавно добавленный оператор регулярного выражения Пипа.

a         First cmdline arg
 ~        Regex match the first instance of...
  `#+`    ...one or more #s (i.e. a cross-section of the left-hand road)
          Print (implicit)

Простое решение регулярных выражений (порт ответа Retina от mbomb007 ) составляет 9 байтов:

`^ +##`Na

чип , 7 байтов

AZ~S
at

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

Выходы 0x0 слева и 0x1справа. (TIO включает флаг, -vчтобы вы могли видеть двоичные значения в stderr. Чтобы увидеть вывод в ASCII, e*fможно добавить в конец первой строки.)

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

Aявляется наименее значимым битом входного байта, а «#» - единственный символ ввода, для которого установлен этот бит. Когда этот бит встречается впервые, мы достигли первого «#» первой строки.

Z задерживает этот сигнал на один цикл, так что теперь мы смотрим на следующий символ.

tтеперь активирован, что означает прекращение выполнения после завершения этого цикла. Нам не нужно смотреть дальше ширины первой дороги.

~Sподавляет вывод для всех циклов, кроме последнего. Если бы этого не было здесь, мы получили бы вывод на каждом цикле.

a ставит текущую стоимость своих соседей (только A в этом случае) в младший значащий бит выходного байта.

Все это означает, что мы получаем a, 0x1если за первым «#» сразу же следует другой «#», и в 0x0противном случае.

C 35 байт

f(char*s){while(35^*s++);return*s;}

Та же идея, что и в ответе PragmaticProgrammer : найти первое #и вывести то, что следует за ним - #для «правого» и <space>для «левого».

C (лазейка), 16 байт

Согласно тестовым примерам, похоже, что левая дорога всегда находится ровно в одном месте от левого поля. Так...

#define f(s)2[s]

Пакет, 46 байтов

@set/ps=
@for %%a in (%s%)do @echo %%a&exit/b

Читает одну строку из STDIN, разбивает ее на пробелы и печатает первое слово, поэтому выводит #для левого и ##для правого. Если массив цитируемых параметров командной строки является приемлемым, то для 36 байтов:

@for %%a in (%~1)do @echo %%a&exit/b

Снимите первый аргумент с кавычек, чтобы он был разбит на пробелы, и выведите его первое слово.

Python 2, 21 байт

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

lambda S:S.split()[0]

Выход #для левого и ##правого

Сетчатка , 5 байт

!1`#+

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

Альтернативное 5-байтовое решение. Отпечатки #слева и ##справа. Идея состоит в том, чтобы сопоставить все прогоны #s ( #+) и print ( !) только с первым из них ( 1).

Haskell, 21 байт

f n=snd$span(==' ')n!!1

или в бессмысленном стиле:

(!!1).snd.span(' '==)

«#» означает право, а «» означает слева

Функция просто берет строку, удаляет начальные пробелы, а затем принимает второй символ (пробел, если левый тощий, и #, если левый толстый)

РЕДАКТИРОВАТЬ: Сохранено три байта благодаря Лайкони и Ними!

Brainfuck, 32 байта

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

Ungolfed:

+[                       while 1
>,>+++++[<------>-]<--     3 if hash; 0 if space
[,.>>]                     print next char and break iff current char is hash
<]

Отпечатки #на право и слева.

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

Perl 5 , 8 + 1 = 9 байт

die$F[0]

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

Бежать с -a (штраф 1 байт).

Вывод (где filename является именем скрипта), если левая дорога менее пройдена, или# at filename line 1, <> line 1## at filename line 1, <> line 1 если правая дорога меньше пройдена.

объяснение

-aОпция автоматически считывает информацию и разбивает ее на столбцы вокруг пробельных, игнорируя ведущие пробелы. Таким образом, первый источник данных - это то, что нам нужно; что - х $F[0]. Это также помещает программу в неявный цикл, который мы не хотим. Однако использование dieпозволяет вывести строку и выйти из неявного цикла одновременно (и не более чем в символах, чем sayпри более обычном способе печати строки).

C 54 байта

char*strchr();char c(char*s){return*(strchr(s,35)+1);}

C ++ 58 байт

#include<cstring>
char c(char*s){return*(strchr(s,35)+1);}

Поскольку OP указывает, что это может быть «программа / функция», я решил написать функцию для сохранения символов. Тем не менее, я по-прежнему включал в число символов оператор "#include" и сопровождающий разрыв строки, поскольку они необходимы для компиляции функции.

Выход

Возвращает пробел " "для обозначения слева или хеш- "#"символ для обозначения справа.

объяснение

Функция strchr () обходит заданную строку и возвращает указатель на первое вхождение указанного символа. Он имеет перегрузку, которая принимает целое число в качестве второго аргумента, в отличие от символа, который сохраняет мне 1 символ. Например, «#» можно заменить на 35. Затем я добавляю единицу к указателю, возвращенному из функции, чтобы получить сразу следующий символ, и разыменовываю его, а затем возвращаю полученный символ.

Заметка

Я также хотел бы воспользоваться этой возможностью, чтобы формально выразить свое раздражение в Visual Studio, автоматически форматируя мой код, когда я пытаюсь играть в гольф (╯ ° □ °） ╯︵ ┻━┻.

Изменить: Спасибо Рэй за указание на некоторые различия в C и C ++ и где я мог сохранить символы <3.

JavaScript (ES6), 37 байт

p=s=>/^ *#( |$)/.test(s.split("\n")[0])

Объяснение:

p это функция, которая возвращает true если дорога, по которой меньше следуют, находится слева и false в противном случае. Это мой первый ответ на этом сайте, так что, вероятно, это может быть больше в гольфе (может быть, регулярное выражение).

Он работает, беря верхнюю строку ввода и проверяя, соответствует ли она регулярному выражению /^ *#( |$)/(начало строки, любое количество пробелов, # и пробел или конец строки.)

Это просто, чтобы дать людям разъяснения о формате и генерировать идеи. Я уверен, что это может быть разбито и играть в гольф дальше. Удачного игры в гольф!

p=s=>/^ *#[^#]/.test(s.split("\n")[0])

<textarea rows = "8" cols = "8" oninput = "console.log(p(this.value))"></textarea>

Japt , 3 байта

x

(2 байта для -g1флага) Выходы #справа и пробел слева. Основано на ответе JavaScript Дэвида Арчибальда.

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

Excel, 17 байт

=left(trim(A1),2)

Предполагает ввод в ячейку A1.

Возвращает ##справа и #( #и пробел) слева.

Дивиль , 12 байт

s=>s.trim[1]

Объяснение:

s=>          // lambda expression
   s.trim    // removes leading (and trailing) whitespace
         [1] // gets the second character

Использование:

let f: String -> char = s=>s.trim[1]
print f('...')

Возвращает (пробел) слева и #справа.

Java 7, 166 66 63 52 43 байта

int c(String s){return s.trim().charAt(1);}

Выходы 35справа и 32слева.
Основано на ответе @Clashsoft 's Dyvil .

Объяснение:

int c(String s){   // Method with String parameter and integer return-type
  return s.trim()  //  Remove leading and trailing whitspaces
   .charAt(1);     //  and return the second character (as int value)
}                  // End of method

Тестовый код:

class M{
  static int c(String s){return s.trim().charAt(1);}

  public static void main(String[] a){
    System.out.println(c(" ##    #\n  ##  #\n   ###\n    #\n    #\n    #"));
    System.out.println(c(" ##  #   \n  ## #  \n   ###\n    ##\n     #\n     #\n     #"));
    System.out.println(c(" ##  #   \n  ## #  \n   ###\n    ##\n   # \n  #  \n #   "));
    System.out.println(c(" ##   #  \n  ## #  \n   ###\n    #\n   # \n  #  \n  #  "));
    System.out.println(c(" #    ## \n  #  ## \n   ###\n    #\n   # \n  #  \n  #  "));
    System.out.println(c(" #    ## \n  #  ## \n   ###\n    #\n     #\n     #\n     #"));
  }
}

Попробуй это здесь.

Выход:

35
35
35
35
32
32

Befunge 98, 11 байт

-!jv~'
@.~<

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

Печать 32для левой и 35правой стороны, с одним пробелом в конце.

объяснение

-!jv      This is a no-op the first time through, but used later

    ~'    Pushes the ASCII value of the next character, and pushes 32
-!        Subtracts the 2, and nots. If the character was a space, the top will be 1
  jv      Goes to the second line if the character was not a space

  ~<      Pushes the next characer's ASCII value
 .        Prints it (32 for " " and 35 for "#")
@         Ends the program

Один трюк, который я использовал, ставил -!jvпервый, хотя он ничего не делал. Это позволило мне избавиться от пробела после 'и сохранить некоторые отступы. С этим последним код будет

~' -!jv
   @.~<

для 15 байтов.

Рубин, 20 байтов

->r{r.strip[1]==' '}

Возвращает true для левого, false для правого.