编写一个程序，该程序采用一个单行字符串，您可以假定该字符串仅包含字符/\_‾。（这是正斜杠和反斜杠，下划线和上划线。~由于上划线不是方便的ASCII，因此如果需要，可以使用上划线代替。）

例如，一种可能的输入是：

__/‾‾\/\_/‾

您的程序需要输出真值或假值，具体取决于字符串的左边缘是否通过字符的行“连接”到了字符串的右边缘。因此，如果字距调整少了一点，那么从左边缘到右端将一直有一条纯黑色（尽管是扭曲的）线条，就像一条不间断的弦线或麻线。

上面示例的输出为true，因为连接了边：

要明确连接：

• / 连接在其左下角和右上角
• \ 连接在其左上方和右下方
• _ 连接在其左下角和右下角
• ‾（或~）连接在其左上角和右上角

也：

• 字符串的边缘是从顶部开始还是从底部开始都无关紧要，只需要在整个字符串的水平方向上水平连接即可。

• 您可以假设输入字符串为非空，当然只有一行。

以下是一些其他示例，如果已连接，则后面跟有1（真），否则则后面是0（虚假）：

__/‾‾\/\_/‾
1

_
1

\
1

/
1

‾
1

___
1

\/
1

/\/
1

/\/\
1

‾‾‾
1

\\
0

‾‾
1

_‾
0

‾_
0

\_____/
1

\/\\/\\___
0

\/\__/‾‾\
1

______/\_____
1

‾‾‾‾‾‾\\_____
0

‾‾‾‾‾‾\______
1

_____/‾‾‾‾‾
1

\___/‾‾‾\___/‾‾‾
1

\_/_\_
0

\_/\_
1

/\/\/\/\/\/\/\/\/\/\/\/
1

____________________
1

‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
1

‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾/
0

‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾\
1

/\‾/\‾___/\_\/__\/\‾‾
0

最短的代码是赢家。

果冻，9个字节

-1字节感谢@EriktheOutgolfer

期望~而不是‾。返回$0$或$1$。

O*Ɲ:⁽8ƇḂẠ

在线尝试！，Truthy测试套件，Falsy测试套件

使用此公式（但与下面的11字节版本类似）：

过渡是有效的，如果$n$是奇数或无效的，如果$n$是偶数。

已评论

O*Ɲ:⁽8ƇḂẠ     - main link, taking a string          e.g. "\_/"
O             - get ASCII codes                     -->  [92, 95, 47]
 *Ɲ           - exponentiation on all pairs         -->  [92**95, 95**47]
   :⁽8Ƈ       - integer division by 15145           -->  [23964828…8421, 59257069…0485]
       Ḃ      - least significant bit (i.e. parity) -->  [1, 1]
        Ạ     - all values equal to 1?              -->  1

果冻， 14 12  11字节

支持（并期望）‾输入字符串中的字符。返回$0$或$1$。

O*Ɲ%276%7ỊẠ

在线尝试！，Truthy测试套件，Falsy测试套件

怎么样？

给定两个连续的ASCII码$x$和$y$字符，我们需要一个函数来检查它们是否形成有效的过渡。

我们需要非交换操作，因为当字符反转时结果可能会改变。例如，_/有效但/_无效。

使用幂运算，可能的公式¹为：

的过渡是有效的，如果$n\le1$，或无效的，如果$n>1$。

 chars |    x |    y | (x**y)%276 | %7 | valid
-------+------+------+------------+----+-------
   __  |   95 |   95 |      71    |  1 |  yes
   _/  |   95 |   47 |     119    |  0 |  yes
   _‾  |   95 | 8254 |     265    |  6 |   no
   _\  |   95 |   92 |     265    |  6 |   no
   /_  |   47 |   95 |      47    |  5 |   no
   //  |   47 |   47 |      47    |  5 |   no
   /‾  |   47 | 8254 |       1    |  1 |  yes
   /\  |   47 |   92 |       1    |  1 |  yes
   ‾_  | 8254 |   95 |     136    |  3 |   no
   ‾/  | 8254 |   47 |      88    |  4 |   no
   ‾‾  | 8254 | 8254 |     196    |  0 |  yes
   ‾\  | 8254 |   92 |     196    |  0 |  yes
   \_  |   92 |   95 |      92    |  1 |  yes
   \/  |   92 |   47 |      92    |  1 |  yes
   \‾  |   92 | 8254 |     184    |  2 |   no
   \\  |   92 |   92 |     184    |  2 |   no

_{1.在Node.js中使用强力搜索找到（使用BigInts）}

已评论

O*Ɲ%276%7ỊẠ   - main link, taking a string          e.g. "\_/"
O             - get ASCII codes                     -->  [92, 95, 47]
 *Ɲ           - exponentiation on all pairs         -->  [92**95, 95**47]
   %276       - modulo 276                          -->  [92, 119]
       %7     - modulo 7                            -->  [1, 0]
         Ị    - ≤1?                                 -->  [1, 1]
          Ạ   - all values equal to 1?              -->  1

Ruby -n，30个字节

p !/[_\\][\\‾]|[\/‾][_\/]/

在线尝试！

使用Regex字符类将所有断字符串序列减少为两种情况。

JavaScript（ES6），45个字节

天真的方式。

s=>!/\/\/|\\\\|_~|~_|~\/|_\\|\/_|\\~/.test(s)

在线尝试！

R，89 87 81 78字节

-2个字节，感谢@Giuseppe

-6个字节，感谢@Nick Kennedy

-3字节替换1:length(y)用seq(a=y)，其中a是用于短along.with

y=utf8ToInt(scan(,''));all(!diff(cumprod(c(1,y>93)*2-1)[seq(a=y)]*(y%%2*2-1)))

使用\ / _ ~。这可能不如基于正则表达式的解决方案那么短，但我想做的事情与其他人有所不同。

utf8ToInt('\\/_~')
# [1]  92  47  95 126

小于93的字符将状态从上切换为下（反之亦然），这样-1，其他1字符什么也不做，其行为与cumprod相对于开始跟踪状态。-1偶数处于上升状态（用表示），奇数处于下降状态（1）。如果字符串未中断，则跟踪状态与上/下位置相乘，不应更改，它始终是起始条件（-1或1）

在线尝试

Python，46个字节

f=lambda s:s==''or s[:2]in"__/~~\/\_"*f(s[1:])

在线尝试！

__/~~\/\_$2^3=8$

我尝试了其他一些不太复杂的方法来检查字符对，但是它们都不再像这样对所有合法对进行硬编码了。

C（gcc），93个字节

w,o,r;k(char*_){for(r=0;w=*_,o=*++_;)r|=w-126&&w>47?w-95&&w-92?0:o>47&&o-95:o-92&&o<126;_=r;}

在线尝试！

芯片 -z，17字节

FZ!C~aS
A}^]--^~t

在线尝试！（TIO包括-v以使其更易于理解输出。）

期待_/~\集。返回\x00（虚假）或\x01（真实）。

我的回答策略使用以下信息：

Symbol  Binary
   _    0101 1111
   /    0010 1111
   ~    0111 1110
   \    0101 1100
          ^   ^ ^
        HGFE DCBA

A：该位位置恰好1在符号左侧为低0时为高时
F：该位位置恰好0在符号右侧为低1时为高时
C：该位位置恰好在一直是1

使用此信息，我只需要检查F每个字符的与下一个字符的匹配not A。一xor门是实现了一个非常方便的方式。

下面的代码执行此操作，但是给出每个配对的输出（1在开头加上一个额外的输出）（7个字节）：

FZ!
A}a

我们想在第一次失败时暂停，并打印是否在字符串中暂停，还是在null终止符处终止（我们还添加-z了一个null终止符）。我们可以not C用来表示停止的地方，这给了我们这个程序（13个字节）：

FZ!C~a
A}^]~t

但是我们仍然有“前导零”（例如\_/\给定00 00 00 00 01），因此将其转换为顶部给出的答案。

05AB1E，29 14 9 字节

ÇümŽb‘÷ÈP

@Arnauld的Jelly答案端口，因此请确保也对他进行投票！

用输入‾。

在线尝试或验证所有测试用例。

原始29 个字节的答案：

„_~SD2×s:Çü-т+•6_üê{↕ƵΔвåO_

输入~而不是‾。

它的声音听起来更短。. 将尝试从这里向下打高尔夫球。

在线尝试或验证所有测试用例。

说明： “

„_~S                          # Push the characters ["_","~"]
    D2×                       # Duplicate it, and increase each to size 2: ["__","~~"]
       s:                     # Swap and replace all "__" with "_" and all "~~" with "~"
                              #  in the (implicit) input-string
         Ç                    # Convert the remaining characters to unicode values
          ü-                  # Calculate the difference between each pair
            т+                # Add 100 to each
              •6_üê{↕       # Push compressed integer 1781179816800959
                       ƵΔ     # Push compressed integer 180
                         в    # Convert the larger integer to Base-180 as list: 
                              #  [52,66,69,100,103,131,179]
                          å   # Check for each if it's in the difference-list
                              # (1 if present; 0 if not)
                           O  # Sum the truthy values
                            _ # Check if this sum is exactly 0 (1 if 0; 0 otherwise)
                              # (and output this result implicitly)

见我这个05AB1E尖端（部分如何comrpess大的整数？以及如何压缩整数列表？）理解为什么•6_üê{↕是1781179816800959，ƵΔ是180和•6_üê{↕ƵΔв是[52,66,69,100,103,131,179]。

附加说明：

$2^4$["/_", 52]["\~", 66]["_~", 69]["//", 100]["\\", 100]["_\", 103]["~_", 131]["~/", 179]
__~~//\\导致0（或100在我加100之后），因此我首先删除的所有相邻重复项~并_ 在输入字符串中计算和验证对差异。

Python 3中，79个 70 63字节

感谢Arnauld和Jo King，节省了16个字节，谢谢！

p=lambda s:len(s)<2or((ord(s[-2])%13>5)^ord(s[-1])%2)&p(s[:-1])

在线尝试！

Python 3中，67 60个字节〜代替〜

p=lambda s:len(s)<2or(~(ord(s[-2])//7^ord(s[-1]))&p(s[:-1]))

在线尝试！

Python 3，126个字节

lambda s,d={'‾':'\‾','_':'/_','/':'\‾','\\':'/_'}:len(s)<2or all([s[i+1] in d[s[i]]for i in range(len(s)-1)if s[i]in d])

Haskell，70个字节

此变体使用~而不是上划线。它采用所有八个有效对，并检查字符串是否仅包含那些对：

f(a:b:x)=[a,b]`elem`words"__ _/ /~ ~~ ~\\ \\_ \\/ /\\"&&f(b:x)
f _=1>0

在线尝试！

取消高尔夫：

validate :: String -> Bool
validate xs = all valid $ zip xs (tail xs)
  where
    valid (a,b) = [a,b] `elem` starts
    starts      = words "__ _/ /~ ~~ ~\\ \\_ \\/ /\\"

Perl 6，32个字节

{!/< \\\ \~ ~/ // _~ ~_ _\ /_>/}

在线尝试！

一个正则表达式解决方案，仅检查字符串是否包含无效序列。

说明：

{                              }   # Anonymous code block
  /<                         >/    # Find the longest sequence from
     \\\                           # \\
         \~                        # \‾
            ~/                     # ‾/
               //                  # //
                  _~               # _‾
                     ~_            # ‾_
                        _\         # _\
                           /_      # /_
 !                                 # And logically negate the match

R，43个字符，47个字节

其他答案使用相同的正则表达式，但适用于R。

!grepl('[/‾][/_]|[\\\\_][\\\\‾]',scan(,''))

在线尝试！

和强制性的xkcd。

第四（gforth），100 98字节

: x = swap '~ = + ;
: f 1 tuck ?do over i + >r i 1- c@ r> c@ dup 92 x swap dup 47 x <> + loop 0> ;

在线尝试！

说明

遍历该字符串，并确定每个字符是否与前一个字符在同一位置（顶部或底部）开始。如果它们不匹配，则从计数器中减去1。最后，如果计数器已更改，则该字符串不是字符串。

如果char为/（47）或~（126），则结束位置较高。否则就低

如果char为\（92）或~（126），则开始位置为高。否则就低

代码说明

\ x is basically just extracting some common logic out into a function to save a few bytes
\ it checks if the first number is equal to the second number
\ or the third number is equal to 126   
: x                \ start a new word definition
  = swap           \ check if the first two numbers are equal then swap with the third
  '~ =             \ checks if the third number is equal to 126
  +                \ adds results together (cheaper version of or)
;                  \ end the word definition

: f                \ start a new word definition
  1 tuck           \ set up parameters for a loop (and create a bool/counter)
  ?do              \ start counted loop from 1 to string-length -1, 
                   \ ?do will skip if loop start and end are the same
    over i +       \ copy the string address and add the loop index to get the char address
    >r i           \ place char address on return stack and place a copy back on the stack
    1- c@          \ subtract 1 to get previous char address and grab ascii from memory
    r> c@          \ move char address back from return stack, then grab from memory
    dup 92 x       \ get the "output" position of the prev character
    swap dup 47 x  \ get the input position of the current character
    <> +           \ check if they aren't equal and add the result to the counter
                   \ the counter won't change if they're equal
  loop             \ end the loop
  0>               \ check if counter is less than 1 (any of the "links" was not valid)
;                  \ end word definition

Python 3中，80 78个字节

我并不是真的有很多python代码高尔夫，但是我想我可以试试看

• -2字节：实现的not（any（））与all（not（））相同，并且可以将not移到r字符串中

def f(x):*l,=map(r'_/\~'.find,x);return 1-any((i^j//2)%2for i,j in zip(l,l[1:]))

在线尝试！

Python 3.8（预发行版），71字节

我想尝试新的:=表情分配

lambda x:all((i^j//2)%2for i,j in zip(l:=[*map(r'\~_/'.find,x)],l[1:]))

在线尝试！

果冻， 13 12  11 字节

O*Ɲ%⁽wḃ%5ỊẠ

接受字符列表的单子链接使用~代替‾选项。

在线尝试！或查看测试套件（...我已重新排序，将8个虚假的对象放置在最后）

这个公式是通过用手：p摆弄而发现的（如下图所示）

为此，我也将所有16对字符的序数都视为一个幂，并寻找一个大的模，该模将适合三个字节，然后是一个字节的模（1,2,3,4,5,6,7,8 ，9,10,16,256）对16进行分区，以使所有可接受的结果为1或0（“无关紧要”），因为我知道Ị比<5在我以前的解决方案中查找的要短，该解决方案正在寻找所有可接受的结果小于所有不可接受的。

O*Ɲ%⁽wḃ%5ỊẠ - Link: list of characters
O           - ordinals
  Ɲ         - for each pair of neighbours:
 *          -   exponentiate
    ⁽wḃ     - 30982
   %        - modulo (vectorises)
        5   - five
       %    - modulo (vectorises)
         Ị  - insignificant? (abs(x) <=1) (vectorises)
          Ạ - all truthy?

可能的相邻字符及其内部评估：

(Ɲ)         (O)            (*%⁽wḃ)        (%5)      (Ị)
pair   a,b=ordinals   c=exp(a,b)%30982   d=c%5   abs(d)<=1
__       95,  95         28471             1         1
_/       95,  47         29591             1         1
/~       47, 126         19335             0         1
/\       47,  92          9755             0         1
~~      126, 126         28000             0         1
~\      126,  92         26740             0         1
\_       92,  95          9220             0         1
\/       92,  47         13280             0         1
~_      126,  95          3024             4         0
~/      126,  47         12698             3         0
\~       92, 126         27084             4         0
\\       92,  92         17088             3         0
_~       95, 126         28169             4         0
_\       95,  92          4993             3         0
/_       47,  95         22767             2         0
//       47,  47          7857             2         0

上一个@ 12：

O*Ɲ%⁽?K%⁴<8Ạ

在线尝试！

上一个@ 13：

O%7ḅ6$Ɲ%⁵%8ỊẠ

在线尝试！

Perl 5 26 25个字节

使用;定界符可以删除结束定界符

$_=!m;[/~][_/]|[\\_][~\\]

蒂奥

26字节

Excel，150字节

=SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(A1,"_\",),"_‾",),"‾_",),"‾/",),"/_",),"//",),"\‾",),"\\",)=A1

删除所有无效对，然后返回true原始字符串，然后返回。

Haskell，42个字节

g=tail>>=zip
h=all(`elem`g"__/~~\\/\\_").g

该解决方案使用 ~，并且要调用的函数为h（即h string给出答案）

该解决方案使用给定列表的函数g，返回列表中相邻值的所有元组。

然后，我们使用g生成允许的邻居列表（在中g"__/~~\\/\\_"），以及输入列表中所有邻居对的列表。然后，我们检查每个相邻对是否是允许的对。

C（gcc），41 36字节

f(char*_){_=!_[1]||*_/32+*++_&f(_);}

在线尝试！

-5消除&1了Peter Cordes的想法；更改了运算符（优先级）以删除括号

用途~。检查前两个字符的二进制表示形式的第一和第六位：

_ 1011111
\ 1011100
/  101111
~ 1111110
   ^    ^

并递归遍历字符串。

(*_ / 32) & 1仅对以高结尾的字符*_ & 1为真，而仅对以低开头的字符为真。 (x&1) ^ (y&1) == (x+y)&1。XOR是无进位加法，并且进位不会干扰最低位。在1来自f(_)返回值，如果该字符串的其余部分是粘性。

Bash，30个字节

grep -E '//|\\\\|_~|~_|~/|_\\|/_|\\~'

输入为STDIN。如果有效，则退出代码为1；如果无效，则退出代码为0。

SNOBOL4（CSNOBOL4），58字节

	INPUT '/_' | '_\' | '\\' | '//' | '~/' | '\~' @OUTPUT
END

在线尝试！

对于true，不输出任何内容；对于false，则不输出正整数（指示字符串中第一个中断的位置）。

木炭，32 18字节

⌊⭆θ∨¬κ⁼№_/ι№\_§θ⊖κ

在线尝试！链接是详细版本的代码。说明：

  θ                 Input string
 ⭆                  Map over characters and convert to string
     κ              Current index
    ¬               Logical Not (i.e. is zero)
   ∨                Logical Or
          ι         Current character
       №            Count (i.e. contained in)
        _/          Literal _/ (i.e. begins at bottom)
      ⁼             Equals
               θ    Input string
              §     Indexed by
                 κ  Current index
                ⊖   Decremented (i.e. previous character)
           №        Count (i.e. contained in)
            \_      Literal \_ (i.e. ended at bottom)
⌊                   Minimum (i.e. if all true)
                    Implicitly print

x86机器代码，13个字节。

（或者11个字节，不处理琐碎的单字符字符串。）

使用@attinat的C答案中的位位置检查

相同的机器代码可以在16位，32位和64位模式下工作。源是用于64位模式的NASM。

nasm -felf64 -l/dev/stdout  listing
    17   addr                  global string_connected
    18           code          string_connected:
    19           bytes         ;;; input: char *RSI, transitions to check=RCX
    20                         ;;; output: AL=non-zero => connected.  AL=zero disconnected
    21                         .loop:                      ; do {
    22 00000000 AC                 lodsb                   ;   al = *p++
    23 00000001 E309               jrcxz  .early_exit        ; transitions=0 special case.  Checking before the loop would require extra code to set AL.
    24 00000003 C0E805             shr    al, 5
    25 00000006 3206               xor    al, [rsi]          ; compare with next char
    26 00000008 2401               and    al, 1
    27 0000000A E0F4               loopne .loop            ; }while(--rcx && al&1);
    28                         .early_exit:
    29 0000000C C3                 ret

unsigned char string_connected(int dummy_rdi, const char *s, int dummy_rdx, size_t transitions);与x86-64 System V调用约定一样，可以从C 调用。不是bool因为Transitions = 0情况返回的是ASCII码，而不是1。

RCX = len = strlen(s) - 1。也就是说，字符边界的数量=要检查显式长度字符串的转换。

对于transitions > 0，返回0（不匹配）或1（已连接），并相应地设置ZF。对于transitions == 0，返回字符串的单个字节（非零，因此也是真实的）。 如果不是那种特殊情况，我们可以放弃早退的JRCXZ。 它之所以在循环内，是因为那里的AL不为零。

位位置逻辑基于以下观察结果：ASCII码的位0告诉您起始高度，而位5告诉您终止高度。

;;;  _ 1011111
;;;  \ 1011100
;;;  /  101111
;;;  ~ 1111110
;;;     ^    ^

    ; end condition (c>>5) & 1 =>  0 = low
    ; start cond: c&1 => 0 = high
    ; (prev>>5)&1 == curr&1  means we have a discontinuity
    ; ((prev>>5) ^ curr) & 1 == 0  means we have a discontinuity

测试工具（从attinat的TIO链接进行了修改，当心该C参考功能中的C序列点UB）。 在线尝试！。此功能对所有30种情况都是正确的。（包括返回值不匹配的单字符情况：这两种情况都是正确的，在这种情况下具有不同的非零值。）

Excel，79个字节

单元格A1作为输入

=1---SUMPRODUCT(--ISNUMBER(FIND({"//","/_","\~","\\","~/","~_","_\","_~"},A1)))

飞镖，94字节

f(s)=>!(r'//,\\,~/,_\,~_,_~,/_,\~'.split(',').map((t)=>s.contains(t)).fold(false,(p,e)=>p|e));

在线尝试！

C ++ 132110字节

-22个字节（仅使用ASCII）

int f(char*s){int t[128];t[95]=0;t[47]=1;t[92]=2;t[126]=3;for(;*++s;)if(t[s[-1]]%2^t[*s]/2)return 0;return 1;}

使用位掩码了解开始和结束是向上还是向下

视网膜，26字节

C`[_\\][\\~]|[~\/][_\/]
^0

在线尝试！

使用~而不是‾，因为这使键入更容易。

正则表达式，34个字节

我找不到使用正则表达式作为语言的规则。请让我知道是否需要调整此设置。

^(‾+|(‾*\\)?(_*\/‾*\\)*_*(\/‾*)?)$

在这里尝试：https : //regex101.com/r/s9kyPm/1/tests

APL + WIN，58个字节

m←22⊤'_ / \〜'⍳s←，⎕⋄（1 +⍴s）= + /（（（↑m [0;]），m [1;]）= m [0;]， 1↑m [1;]

提示输入字符串，索引原点为0，并使用〜表示大写字符

在线尝试！由Dyalog Classic提供