한 줄짜리 문자열을 사용하여 문자 만 포함한다고 가정하는 프로그램을 작성하십시오 /\_‾. (즉, 밑줄, 앞으로 그리고 백 슬래시 오버 라인은 . 당신이 사용할 수있는 ~당신이 윗줄 편리 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 바이트

@EriktheOutgolfer 덕분에 -1 바이트

~대신에 예상하십시오 ‾. $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

루비 -n , 30 바이트

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

온라인으로 사용해보십시오!

정규식 문자 클래스를 사용하여 모든 문자열 구분 시퀀스를 두 가지 경우로 줄입니다.

자바 스크립트 (ES6), 45 바이트

순진한 방법.

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

온라인으로 사용해보십시오!

R , 89 87 81 78 바이트

@Giuseppe 덕분에 -2 바이트

@Nick Kennedy 덕분에 -6 바이트

교체 -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)

온라인으로 사용해보십시오

파이썬 , 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 자를 제공하기 위해 합니다). 우리 not C는 어디에서 멈췄는지 나타내는 데 사용할 수 있으며이 프로그램 (13 바이트)을 제공합니다.

FZ!C~a
A}^]~t

그러나 우리는 여전히 "선행 0"(예 : \_/\제공 00 00 00 00 01)을 가지므로 이것은 맨 위에 주어진 답변으로 변환됩니다.

05AB1E , 29 14 9 바이트

ÇümŽb‘÷ÈP

@Arnauld 의 젤리 답변 포트 , 그래서 그를 투표 해야합니다!

로 입력하십시오 ‾.

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

원래 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 (또는 100I (100)를 추가 한 후), I는 제 인접한 중복 삭제~및 _ 상기 입력 문자열에서 이전 계산 페어 차이를 확인.

파이썬 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 바이트 ~ with 대신 ~

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

온라인으로 사용해보십시오!

파이썬 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])

하스켈 , 70 바이트

이 변형은 ~오버 라인 대신 사용 합니다. 8 개의 유효한 쌍을 모두 사용하여 문자열에 해당 쌍만 포함되어 있는지 확인합니다.

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 "__ _/ /~ ~~ ~\\ \\_ \\/ /\\"

펄 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을 빼십시오. 결국 카운터가 변경되면 문자열은 문자열이 아닙니다.

문자가 /(47) 또는~ (126) . 그렇지 않으면 낮습니다

문자가 \(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

파이썬 3 , 80 78 바이트

나는 많은 파이썬 코드 골프를 실제로하지 않지만 시도해 볼 수 있다고 생각했다.

• -2 바이트 : 실현 not (any ())은 all (not ())과 동일하며 not을 r-string으로 이동할 수 있습니다

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ỊẠ

문자 목록을 허용하는 모나 딕 링크는 ~ 는 ‾옵션 대신을 .

온라인으로 사용해보십시오!또는 시험 스위트를 참조하십시오 보아라.

이 공식은 손으로 주위를 둘러 보면서 발견되었습니다.

이것에 대해서도 나도 16 쌍의 문자 서수를 지수로 취급하고 3 바이트에 맞는 큰 모듈로를 찾고 1 바이트 모듈로 (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ỊẠ

온라인으로 사용해보십시오!

펄 5, 26 25 바이트

사용 ;종료 구분 기호 구분 기호로하여 제거 할 수 있습니다

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

TIO

26 바이트

Excel, 150 바이트

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

유효하지 않은 쌍을 제거한 다음 true이 결과가 원래 문자열 인 경우 반환 합니다.

하스켈, 42 바이트

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

이 솔루션은을 사용 ~하며 호출하는 함수는 h입니다 (예 :h string 답변 제공)

솔루션은 목록을 제공하는 함수 g를 사용하고 목록에서 인접한 값의 모든 튜플을 반환합니다.

그런 다음 g를 사용하여 허용 된 이웃 목록 (in g"__/~~\\/\\_")과 입력 목록의 모든 이웃 쌍 목록을 생성합니다. 그런 다음 각 인접 쌍이 허용 된 쌍인지 확인합니다.

C (gcc) , 41 36 바이트

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

온라인으로 사용해보십시오!

-5 Peter Cordes&1 의 아이디어에서 출발하지 않습니다 . 괄호를 제거하도록 변경된 연산자 (우선 순위)

사용합니다 ~. 처음 두 문자 이진 표현의 첫 번째 및 여섯 번째 비트를 확인합니다.

_ 1011111
\ 1011100
/  101111
~ 1111110
   ^    ^

문자열을 재귀 적으로 탐색합니다.

(*_ / 32) & 1높음으로 끝나는 *_ & 1문자에만 적용되고 낮게 시작하는 문자에만 적용됩니다. (x&1) ^ (y&1) == (x+y)&1. XOR은 캐리없이 추가되며 캐리는 가장 낮은 비트를 방해하지 않습니다. 는 1으로부터 오는 f(_)문자열의 나머지 부분은 힘줄 인 경우, 반환 값.

배쉬, 30 바이트

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

입력은 STDIN입니다. 종료 코드는 유효하면 1이고 유효하지 않으면 0입니다.

SNOBOL4 (CSNOBOL4) , 58 바이트

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

온라인으로 사용해보십시오!

허위에 대해서는 진리를 나타내지 않으며 양의 정수 (문자열에서 첫 번째 나누기의 위치를 ​​나타냄)를 출력합니다.

숯 , 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 시스템 V 호출 규칙과 같이 C에서 호출 가능합니다. 아니 bool전이 때문에 = 0 경우는 ASCII 코드가 아닌 1을 반환합니다.

RCX = len = strlen(s) - 1. 즉, 명시 적 길이의 문자열을 체크인하기위한 문자 경계의 수 = 전환의 수.

의 경우 transitions > 00 (미스 매치) 또는 1 (연결됨)을 반환하고 이에 따라 ZF를 그대로 둡니다. 내용 transitions == 0(비 - 제로 따라서도 truthy이다) 스트링의 단일 바이트를 리턴한다. 그 특별한 경우가 아니라면 조기 퇴장 JRCXZ를 취소 할 수 있습니다. AL이 0이 아니기 때문에 루프 내부에만 있습니다.

비트 위치 논리는 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 가지 경우에 정확합니다. (반환 값이 일치하지 않는 단일 문자 경우 포함) : 두 경우 모두 0이 아닌 다른 값으로 진실됩니다.

엑셀, 79 바이트

A1입력으로 셀

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

다트 , 94 바이트

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

온라인으로 사용해보십시오!

C ++, 132 바이트

ASCII 전용으로 -22 바이트

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 ← 2 2⊤ '_ / \ ~'⍳s ←, ⎕⋄ (1 + ⍴s) = + / ((↑ m [0;]), m [1;]) = m [0;], ¯ 1 ↑ m [1;]

문자열, 인덱스 원점 0을 입력하도록 프롬프트하고 ~를 사용하여 대문자

온라인으로 사용해보십시오! Dyalog Classic 제공