Це перша в серії, друга - Дві дороги, розійшлися в жовтому лісі (частина 2)

Цей виклик натхненний відомою поемою Роберта Фроста "Дорога не взята":

Дві дороги розходилися в жовтому лісі,
І вибачте, що я не міг подорожувати обома
І бути однією мандрівницею, довго я стояв
І дивився вниз, наскільки я міг,
куди вона зігнулася в підліску;

Тоді взяв інший, як справедливий,
І маючи, мабуть, кращу претензію,
Бо він був трав’янистий і хотів носити;
Хоча з приводу того, що проїжджаючи там,
насправді вони носили їх приблизно так само,

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

Я скажу про це зітханням
Десь віками і століттями, отже:
Дві дороги розійшлися в лісі, а я -
я взяв ту, яку менше проїжджав,
і це змінило все.

Зверніть увагу , що другий в останній рядок I took the one less traveled by,.

Ваш фактичний виклик

Ви будете приймати дані у такій формі, як:

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

і вам доведеться знайти тоншу дорогу.

Дорога починається внизу з а #. Інші 2 дороги, які завжди закінчуються у верхньому ряду, - це дороги, які ви повинні оглянути. Найбільше проїжджає найдорожча найдорожча дорога, а тому вона не є тим, чого хочеш. Інший - найменш проїжджаючий, і саме той, якого ти хочеш.

Вихідні дані

Ваша програма / функція повинна виводити одне з двох чітких значень (наприклад, 0 або 1, істинне або хибне), одне для кожного можливого положення дороги, не прийняте. Наприклад, ви можете вивести 0, якщо дорога не взята зліва від взятої дороги, а 1 в іншому випадку, або ви можете вивести рядок "ліворуч" або "праворуч", справжнє, помилкове і т.д.

Тестові приклади:

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

Можливий вихід "правильно".

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

Можливий вихід "правильно".

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

Можливий вихід "правильно".

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

Можливий вихід "правильно".

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

Можливий вихід "ліворуч"

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

Можливий вихід "ліворуч"

Примітки

• Це код-гольф , тому найкоротша відповідь у байтах виграє
• Стандартні лазівки заборонені
• Ви повинні вказати свої результати для "ліворуч" та "праворуч", і вони повинні бути різними
• Вхід буде одним великим рядком і може мати будь-яку кількість рядків
• Вам не потрібно турбуватися про дійсне введення.
• Дорога завжди має форму Y, тому вам потрібно лише дивитися на вершину.
• Є якісь питання? Коментар нижче:

Виграє найменший байт!

CJam , 1 байт

r

rПерекладає перший струнний сусідні символи непробельний з STDIN в стеці, так що відбитки ##для залишив і #для права .

Спробуйте в Інтернеті!

JavaScript (ES6), 19 12 байт

Редагувати:

Більш гольф версія

a=>a.trim[1]

Повертається #праворуч та пробіл ліворуч.

Оригінал:

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

Пояснення

Безголівки :

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.

Acc !! , 30 байт

Через спосіб Acc !! приймає введення, воно дасть вихід після введення лише одного рядка введення. Але якщо ви передаєте вхід або перенаправляєте його з файлу, різниці не слід помічати.

Count i while 35-N {
}
Write N

Бере вхід з stdin. Виходи, якщо ліва дорога менше проїжджає або #якщо права дорога менше проїжджає. Спробуйте в Інтернеті!

Пояснення

Nчитає значення ASCII символу зі stdin кожного разу, коли на нього посилається. Ми 35-Nпетляємо, поки несемо; тобто, поки 35-N != 0або N != 35. Тому, коли цикл виходить, ми щойно прочитали перший# символ у рядку. Потім читається наступний символ із Nі записується назад до stdout 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 байти. Зважаючи на рішення Девідса, я не розміщу його як основну відповідь.

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

Цей виводить 1 праворуч і 0ліворуч.

Піп , 8 6 байт

a~`#+`

Вводиться в якості аргументу командного рядка (для якого буде потрібно цитування та вихід нових рядків при запуску з фактичного командного рядка). Виходи, #якщо ліва дорога менше проїжджає і ##якщо права дорога менше проїжджає. Спробуйте в Інтернеті!

Пояснення

Для цього використовується нещодавно доданий Pip оператор першого матчу.

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в цьому випадку) на найменш значущий біт вихідного байта.

Все це означає, що ми отримуємо а, 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 ( #+) та надрукувати ( !) лише перший з них ( 1).

Haskell, 21 байт

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

або в стилі без точки:

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

"#" означає право, а "" означає ліворуч

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

EDIT: Збережено три байти завдяки Лайконі та Німі!

Brainfuck, 32 байти

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

Безголівки:

+[                       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 байт).

Вихід є (де ім'я файлу# 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 якщо дорога, яка проїжджається менш ліворуч, а в іншому випадку помилкова. Це моя перша відповідь на цьому веб-сайті, так що, напевно, можна було б більше пограти в гольф (можливо, регулярний вираз.)

Він працює, взявши верхній рядок введення та побачивши, чи відповідає він регулярному вираженню /^ *#( |$)/ (початок рядка, будь-яка кількість пробілів, # та пробіл чи кінець рядка.)

Це лише для того, щоб дати людям роз’яснення щодо формату та генерувати ідеї. Я впевнений, що це може бити і гольфу далі. Щасливого гольфу!

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]==' '}

Повертає справжнє для лівого, хибне для правого.