Предыстория

Познакомьтесь с моим другом Джимми:

/o\

Джимми - маленький персонаж, который любит стоять на платформах. Вот Джимми, благополучно стоящий на платформе:

         /o\
  -------------

Теперь у Джимми хорошее чувство равновесия, поэтому он может спокойно стоять одной ногой с платформы, вот так:

   /o\
    -------------------

Хотя, если он стоит с двумя или более частями тела с платформы, он упадет. Оба из этих примеров, где Джимми упадет:

/o\                                       /o\
  ----------        ----------------------   

Соревнование

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

• Входные данные: две строки, показывающие положение Джимми и положение платформы под ним. Это может быть два отдельных входа, один вход или какой-то массив.

  1. Вы можете принять ввод через любую разумную форму, включая функции и стандартный ввод. Используйте жесткое кодирование только в том случае, если ваш язык не поддерживает другие методы ввода.

• Вывод: логические значения true и false или целые числа 1 или 0 для представления true / false соответственно.

  1. Логическое значение основано на том, может ли Джимми оставаться на платформе или нет - истина, если Джимми может оставаться на платформе, или ложь, если он упадет.

• Размер платформы произвольный и может быть изменен по желанию. Ваша программа должна учитывать это.

  1. Платформа не может иметь нулевую длину, и платформа должна быть полной (в платформе нет отверстий).

  2. Помните, что Джимми падает, когда две его части тела свисают с платформы. Часть тела является одним из символов ASCII его тела.

  3. Конечный пробел в конце платформы не требуется, но ваша программа должна учитывать обе ситуации, когда после платформы есть пробел, а где нет.

• Помните о стандартных лазейках , которые запрещены.

Контрольные примеры

         /o\               ✔️ TRUE
  -------------

/o\                        ✔️ TRUE
 ----------

                    /o\    ❌ FALSE
  ------------------

               /o\         ❌ FALSE
  -------

    /o\                    ❌ FALSE
     -

счет

Это код-гольф , поэтому выигрывает меньшее количество байтов.

Leaderboard

Вы можете просмотреть список лидеров этого поста, развернув виджет / фрагмент ниже. Чтобы ваше сообщение было включено в рейтинг, вам нужен заголовок ( # header text) со следующей информацией:

• Название языка (заканчивайте его запятой ,или тире -), а затем ...

• Количество байтов, как последнее число в заголовке.

Например, JavaScript (ES6), 72 bytesдопустимо, но Fortran, 143 bytes (8-bit)недопустимо, потому что число байтов не является последним числом в заголовке (ваш ответ будет распознан как 8 байтов - не используйте это в своих интересах).

<!-- Run the snippet to see the leaderboard. Report any bugs to @xMikee1 on Github -->    <iframe src="https://xmikee1.github.io/ppcg-leaderboard/?id=187586" width="100%" height="100%" style="border:none;">Oops, your browser is too old to view this content! Please upgrade to a newer version of your browser that supports HTML5.</iframe><style>html,body{margin:0;padding:0;height:100%;overflow:hidden}</style>

Желе , 6 байт

n⁶Sċ2Ẓ

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

Объяснение:

n⁶Sċ2Ẓ  args: z (e.g. [['/', 'o', '\\'], [' ', '-']] => 0)
        implicit return value: z ([['/', 'o', '\\'], [' ', '-']])
n⁶      dyad-nilad pair ([[1, 1, 1], [0, 1]])
 ⁶       4th command-line argument or space [4th CLA assumed absent] (' ')
n        vectorized inequality ([[1, 1, 1], [0, 1]])
  S     reduction by addition with base case 0 ([1, 2, 1])
   ċ2   dyad-nilad pair (1)
    2    literal (2)
   ċ     number of occurrences of right in left (1)
     Ẓ  primality (0)

JavaScript (ES6), 38 байт

Принимает вход как (a)(b). Возвращает или .$0$$1$

a=>b=>b[a.search`o`]=='-'&/--/.test(b)

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

Как?

Мы ищем положение средней части "o"тела Джимми в первой строке и тестируем, есть ли черта во второй строке в той же позиции.

b[a.search`o`] == '-'

Единственный случай, когда Джимми был бы небезопасен в этой ситуации, это платформа с одним штрихом:

/o\
 -

Поэтому мы дополнительно следим за тем, чтобы ширина платформы была не менее :$2$

/--/.test(b)

JavaScript (ES6), 36 байт

Альтернативная версия, если мы предполагаем, что под Джимми всегда есть или тире, или пробелы (т. Е. Ввод прямоугольный).

a=>b=>b[a.search`o`]!=0&/--/.test(b)

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

Использует тот факт, что приведение к числовому значению равно для пробела и NaN для тире.$0$

Excel, 67 45 44 байта

=(MID(A2,FIND("o",A1),1)="-")*(TRIM(A2)>"-")

Положите Джимми A1на платформу A2.

2 условия проверены:

• Туловище Джимми ( o) на платформе?
• Платформа больше, чем просто -?

Python 3, 88 43 байта

Входные данные даны в виде списка, содержащего две строки: первая строка - первая строка; вторая строка - вторая строка.

lambda a:sum(1-(" "in i)for i in zip(*a))>1

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

Другая версия, привязанная к 43 байтам (я не смог получить ее короче 43):

lambda a,b:b[a.find("/"):][:3].count("-")>1

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

Уменьшено на 42 байта благодаря совету от Джо Кинга.

Старая версия:

lambda s:sum((s.split("\n")[1]+" "*len(s))[i]=="-"and s[i]!=" "for i in range(len(s)))>1

-2 байта благодаря сриотчизму О'Зайку.

Это работает, принимая два отдельных ввода, затем соединяя соответствующие буквы. Он подсчитывает количество пар, в которых ни один символ не является пробелом, а затем возвращает True, если это число больше 1.

Perl 6 , 18 байт

{?/''B|Bq/}o&[~^]

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

Принимает два параметра и возвращает логическое значение того, останется ли Джимми на платформе. Это работает, соединяя две строки вместе и проверяя, все ли части Джимми все еще находятся на платформе.

Объяснение:

             &[~^]   # String XOR operator
{          }o        # Combined with the anonymous function
 ?/       /          # That checks for the regex match
   ''B              # Unprintable, B, which is "/o" ~^ "--"
       |Bq           # Or B, q, which is "o\" ~^ "--"

Python 2 , 42 37 байт

lambda j,p:'--'in p[j.find('/'):][:3]

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

5 байтов спасибо минус семь

Haskell , 34 байта

a#b=[1|(p,'-')<-zip a b,p>' ']>[1]

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

Я получил это, объединив мою технику ниже с другим ответом на Haskell .

Haskell , 45 байт

x#'-'|x/=' '=1
x#y=0
(((>1).sum).).zipWith(#)

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

Это подсчитывает количество частей тела (непробельные символы), которые находятся на вершине платформы, а затем проверяет, что оно больше 1. Причина, по которой мы считаем части тела на платформе, а не части тела, состоит в том, что zipWithбудет разделять верхнюю строку быть длиной дна и, таким образом, может отрубить части тела Джимми. Это избавляет нас от необходимости делать что-то вроде cycle" "дополнения списка.

MathGolf , 6 14 байтов

`^@╞^αmÆû-oñ╧╙

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

8 байтов пришлось добавить для учета крайнего случая, представленного Ником Кеннеди.

Проверяет, "-o-"является ли подстрока заархивированной строки обеих строк и заархивированной строки, где в первой строке ввода удален первый символ. Принимает ввод как две отдельные строки, единственное изменение заключается в том, что символ вводится как /o\\, поскольку \\это правильный способ ввода обратной косой черты в строку в MathGolf.

объяснение

`                duplicate the top two items
 ^               zip top two elements on stack
  @              rrot3
   ╞             discard from left of string/array
    ^            zip top two elements on stack
     α           wrap last two elements in array
      mÆ         explicit map using 5 operators
        û-oñ     push "-o" and palindromize to make "-o-"
            ╧    pop a, b, a.contains(b)
                 map block ends here
             ╙   max of list

05AB1E (наследие) , 9 8 7 байт

ζðм2ùgp

-1 байт благодаря @ Mr.Xcoder с приближением ðм2ù.

Ввод в виде списка из двух строк.

Работает только в устаревшей версии 05AB1E, поскольку ζможет транспонировать список строк, а также 2D-список символов, тогда как ζв новой версии 05AB1E работает только с 2D-списком символов.

Попробуйте онлайн или проверьте все контрольные примеры .

Объяснение:

ζ        # Zip/transpose; swapping rows/columns, with space as default filler
 ðм      # Remove all spaces from each string
   2ù    # Only leave strings of size 2
     g   # Count how many there are left
      p  # Check if this is a prime (2 or 3)
         # (after which the result is output implicitly)

Рубин , 28 байт

->a,b{!(/--/!~b[a=~/\//,3])}

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

Dyalog APL Extended, 11 10 8 байт

2≤1⊥∧⌿⍤<

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

Объяснение:

2≤1⊥∧⌿⍤<  a monadic train
       <  Compare the input with the implicit prototype element - a space.
          Returns a boolean matrix of characters that are greater than 0x20
    ∧⌿⍤   and-reduce that, i.e. places where both Jimmy and a platform is
  1⊥      base 1 decode, aka sum - the amount of body parts over the platform
2≤        is that greater-or-equal to 2?

-2 благодаря Адаму.

Excel, 36 байт

=LEN(TRIM(MID(A2,FIND("/",A1),3)))>1

Джимми A1, на платформе A2.

Находит позицию Джимми, берет 3 байта платформы и усекает пробелы. Если полученная длина платформы достаточно велика, Джимми встает.

EXCEL, 94 71 байт. VBA (Excel), 87 байт

A1= Джимми, A2= платформа

-23 байта. Спасибо @Wernisch.

=(FIND("-",A2)-FIND("/",A1)<2)*(FIND("\",A1)-LEN(A2)<2)*(TRIM(A2)<>"-")

?[(FIND("-",A2)-FIND("/",A1)<2)*(FIND("\",A1)-LEN(A2)<2)]*(len(replace([A2]," ",""))>1)

/// , 85 93 87 байт

/~/\/\///\/o\\/(o)~ 
/
~
~/ (o) /(o)~ (o)-/(o)~- -/--~(o) - ~/) ~/)-~/o~/(-/1~-~/(~/)~ 

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

Вывод равен 1, если Джимми в безопасности. В противном случае ничего не выводит. (Унарные 1 и 0.) Поскольку нет другого способа получить ввод в ///, он должен быть жестко закодирован:

/~/\/\///\/o\\/(o)~ 
/
~
~/ (o) /(o)~ (o)-/(o)~- -/--~(o) - ~/) ~/)-~/o~/(-/1~-~/(~/)~ //<INPUT HERE> 

Например:

/\/o\\/(o)// 
/
//
/// (o) /(o)// (o)-/(o)//- -/--//(o) - ///) ///)-///o///(-/1//-///(///)//         /o\
  ------------- 

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

Обратите внимание на пробел после <INPUT HERE>.

Объяснение:

НОТА! Код объяснения не может быть выполнен из-за комментариев. Комментарии заключены в фигурные скобки. Кроме того, оригинальный код использует гольф, где //заменяется ~. Этот код опущен в объяснении.

/\/o\\/(o)/            {replace Jimmy with a Jimmy with curvy arms, because slashes are hard to manipulate in this language}
/ 
/
/                      {remove unneeded spaces after Jimmy, but before the floor}

/
//                     {get rid of the line break

/ (o) /(o)/            {remove all the spaces before both Jimmy and the floor}
/ (o)-/(o)/            {for each floor tile, remove it and one space before Jimmy. This detects whether Jimmy lines up with the floor.}
                       {If Jimmy is before the floor, then there will be extra floor.}
                       {If Jimmy is behind the floor, then there will be extra spaces before Jimmy.}
/- -/--/               {Handle the case where there is a hole beneath Jimmy but he is still well-supported}

/(o) - //              {Handle the case where only Jimmy's head is on the floor. The space at the end of the code is necessary for this.}
/) //                  {The rest of the substitutions clean up the result and handle each of the possible results that could exist at this point}
/)-//
/o//
/(-/1/
/-//
/(//
/)//


              /o\   
               --
 {there is a space right before this comment. The comment is only here to make the space visible and explain itself.}

• +8 байт, чтобы исправить ошибку
• -6 байт, применяя стандартную ///игру в гольф.

R 35 байт

function(x)sum(colSums(x!=" ")>1)>1

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

На основании превосходного ответа Jelly от @ EriktheOutgolfer, пожалуйста, добавьте его тоже!

Ввод представляет собой двумерную матрицу символов.

Haskell, 59 байт

f a b=sum[1|(p,q)<-zip a$b++cycle" ",elem p"/o\\",q==' ']<2

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

Функция называется так: f "/o\\ " " -- "

Как это работает (для f "/o\\" " -"):

b++cycle" "- Добавляет бесконечное количество пробелов после, bчтобы убедиться, что Джимми всегда выше a -или ( " -"→" - ..."

zip a$b++cycle" "- Застегивает две строки вместе ( [('/',' '), ('o','-'), ('\\',' ')])

(p,q)<-zip a$b++cycle - для каждой пары в заархивированном списке

[1|(p,q)<-zip a$b++cycle" ",elem p"/o\\",q==' ']- Создает список 1s, длина которого является количеством пар, удовлетворяющих условиям:

elem p"/o\\"- Символ в верхней строке является одной из частей тела Джимми. (Удовлетворено всеми тремя парами в этом примере)

q==' '- Символ в нижней строке является пробелом. (Удовлетворен ('/', ' ')и ('\\', ' '))

Итак, пара должна быть такой, где одна из частей тела Джимми находится над пробелом.

Поскольку в этом примере две пары удовлетворяют обоим условиям, список [1,1]

sum[1|(p,q)<-zip a$b++cycle" ",elem p"/o\\",q==' ']- Возьмите сумму тех 1s (то есть длину списка), который в этом примере есть 2.

sum[1|(p,q)<-zip a$b++cycle" ",elem p"/o\\",q==' ']<2- Проверьте, не превышает ли количество частей тела над пробелом 2. В этом примере это не так, поэтому Джимми отвалится. :(

C (gcc) , 73 байта

f(s,t,c)char*s,*t;{for(t=strchr(s,c=10);*s%5**t;)c-=*++t%2**s++%8;c=c<0;}

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

Котлин, 60 байт

fun String.c(b:String)=zip(b){i,j->i>' '&&j>' '}.count{it}>1

Объяснение:

fun String.c  # Define an extension function on string, so we don't have to provide a first argument (and we also have string method calls for free)
(b:String)    # Pass the second string as argument
=             # Shorthand syntax for fun body
zip(b)        # Essentially a.zip(b). Creates a List<Pair> by joining both arrays. 
              # Takes care of trailing whitespace, because it will be the size of the smaller array
{i,j->        # Declare a transformer lambda as second function argument
i>' '&&j>' '} # This essentially translates to: If i!=' ' and j=='-'
.count{it}    # Count the true values
>1

/// , 57 байт

/|/\/\///\/o\\/J| J/J*|
/|* /|  -/  | /|*-/|--/!|-/|*/|J|

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

Добавьте ввод в конец программы для запуска. Возвращает пустую строку, если Джимми падает с платформы, в противном случае - строка восклицательных знаков.

• /|/\/\//заменяет |на //, что делает код более коротким и более читаемым ( |используется для разграничения каждой замены)
• /\/o\\/J| J/J*/заменяет Джимми Jна краткость и меняет пространство слева от него *справа от него
• Следующая замена избавит от новых строк.
• /* /| -/ | //отменяет *s и с пробелом слева от платформы. Если осталось два или более пробелов, Джимми падает влево, и платформа удаляется. Эта часть также удаляет любые пробелы справа от платформы.
• /*-/|--/!/отменяет *с и с длиной платформы. Если осталось хотя бы два -, Джимми не падает справа, поэтому они заменяются на !.
• /-/|*/|J// удаляет все оставшиеся символы, которые не !

Japt , 8 байт

Õ·kèS Êz

Попытайся

Сетчатка 0.8.2 , 16 байт

 (.*¶).
$1
¶ ?--

Попробуйте онлайн! Ссылка включает тестовый набор. Объяснение:

+`^ (.*¶).
$1

Хотя в первой строке все еще есть пробел, а в обеих строках по-прежнему содержится более одного символа, удалите пробел и первый символ следующей строки. Примечание: предполагается, что после Джимми нет пробела. +1 байт необходим, если необходимо разрешить завершающий пробел.

¶ ?--

Убедитесь, что под Джимми есть как минимум две части платформы.

Perl 5 -pl , 42 байта

/o/g;$_=(($_=<>)=~/./g)[-1+pos]eq'-'&&/--/

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

Ruby 2.5.3, 44 байта

->a,b{a.zip(b).map(&:join).grep(/\S-/).size>1}

Ввод принимается как два массива. Определенно не самый удобный подход к игре в гольф (см. Ответ GB), но мне нравится любое оправдание использованию этой zipфункции.

PowerShell , 63..55 53 байта

^{-1 байт благодаря маззи}

param($j,$f)''+($f|% t*y|?{$j[$i++]-gt32})-match'- -'

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

Принимает ввод в виде двух строк.

раскатали:

param($j,$f)            #Take $jimmy and $floor
''+                     #Implicitly converts next part to string
($f |% ToCharArray      #Convert $f to a char[] and...
    |?{                 #Only take the chars where...
        $j[$i++]-gt32   #The same indexed char in $j's ASCII # is > ' ' i.e. only get /o\
     }
)-match'- -'            #Arrays.ToString are joined with a space and we need 2 -'s

C # (интерактивный компилятор Visual C #) , 44 40 39 байт

-4 байта благодаря Джо Кингу

a=>b=>a.Zip(b,(x,y)=>x>y?y:0).Sum()>109

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

Python 3,7 , 71 56 байт

lambda s:sum(j in'/o\\'and p=='-'for j,p in zip(*s))>1

Очень простая версия и самая короткая, которую я мог придумать, используя этот подход. Ввод s- это список из двух строк: первая для строки Jimmy, вторая для платформы. Застегните символы, которые находятся выше друг друга, а затем проверьте, -находится ли ниже части Джимми хотя бы в двух случаях.

РЕДАКТИРОВАТЬ: Уменьшено на несколько байтов благодаря Blue!

Шеврон, 84 87 байт

>^__>^j
^i<<0
^i<<^i+1
^h<^i>^j
->+2??^h=/
->-3
>^__>^p
^q<^i|2>^p
->+2??^q<--
><0
><1

Это довольно новый язык моего собственного создания - интерпретатор прототипов, документация и примеры программ можно найти по адресу https://github.com/superloach/chevron .

Объяснение:

• >^__>^j - принять Джимми в качестве ввода TXT
• ^i<<0 - инициализировать индекс до 0
• ^i<<^i+1 - индекс приращения
• ^h<^i>^j - получить символ Джимми по индексу
• ->+2??^h=/ - выпрыгнуть из петли на левой ноге Джимми
• ->-3 - вернуться к началу цикла
• >^__>^p - принять платформу в качестве ввода TXT
• ^q<^i|2>^p - вырезать 3 символа под Джимми
• ->+2??^q<-- - если 2 черты под Джимми, перейти к правдивому выходу
• ><0 - ложный выход
• ><1 - правдивый выход

C (gcc), 103 байта

i,j,l;f(char*s){for(i=0;*s-10;j=*s++-47?j:i)++i;l=strlen(s)>j+1;s+=j;return l&&*s+s[1]+(s[2]?:32)>109;}

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

Будет намного короче ( 75 байт ), если предположить, что после платформы есть пробелы.

Japt -¡, 9 байт

-1 байт, если вход может быть изменен.

VtUao)è-²

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

V , 18 байт

0vt/"_dj.d3lVkp0#x

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

Выведите пробел, только если Джимми упадет с платформы. Выведите что-нибудь незаполненное, если Джимми останется на платформе.