文字のみを含むと想定できる1行の文字列を取るプログラムを作成します/\_‾。（これは下線と、前方と後方スラッシュだ上線。あなたが使用することができる~上線は便利ASCIIではないので、あなたが必要な場合は、上線の代わりに。）

たとえば、1つの可能な入力は次のとおりです。

__/‾‾\/\_/‾

プログラムは、文字列の左端が文字列を介して文字列の右端に「接続」されているかどうかに応じて、真の値または偽の値を出力する必要があります。そのため、カーニングが少し小さければ、左端から右端まで、黒または黒の線（ねじれはありますが）が途切れることがありません。

上記の例の出力は、エッジが接続されているため真になります。

接続を明確にするには：

• / 左下と右上で接続します
• \ 左上と右下で接続します
• _ 左下と右下で接続します
• ‾（または~）左上と右上で接続します

また：

• 弦の端が上から始まったのか下から始まったのかは問題ではなく、弦の長さ全体にわたって水平に接続されていることが重要です。

• 入力文字列は空ではなく、もちろん1行だけであると想定できます。

以下に、接続されている場合は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コードと 2つの連続した文字が与えられた場合、それらが有効な遷移を形成するかどうかをチェックする関数が必要です。$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 !/[_\\][\\‾]|[\/‾][_\/]/

オンラインでお試しください！

正規表現文字クラスを使用して、すべての文字列区切りシーケンスを2つのケースに減らします。

JavaScript（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）になります

オンラインで試す

Python、46バイト

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

オンラインでお試しください！

に連続して表示されることを確認することにより、隣接する各文字ペアが接続することを確認し__/~~\/\_ます。この文字列は、高/低位置のトリプルのDe_Bruijn_sequenceとして表示できます。$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ターミネータで停止したかを出力します（nullターミネータを追加-zするために追加します）。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のヒント（「大きな整数を圧縮する方法」および「整数リストを圧縮する方法」のセクション）を参照して、•6_üê{↕is 1781179816800959、ƵΔis 180および•6_üê{↕ƵΔвis を理解して[52,66,69,100,103,131,179]ください。

追加の説明：

検証する必要がある文字のペアは16（）あります。各文字をUnicode値に変換し、差を計算すると、これらの差が得られます。05AB1Eの圧縮整数リストには正の整数のみが必要なので、それぞれに100を追加します。無効なペアとそれに対応する値は次のとおりです。、、、、、、、私はこれらの値を含む私のコードで圧縮された整数のリストを持っている理由です。 以降とだけようになるとをもたらす（又はI 100を追加した後）、Iは最初の任意の隣接する重複を除去し、$2^4$["/_", 52]["\~", 66]["_~", 69]["//", 100]["\\", 100]["_\", 103]["~_", 131]["~/", 179]
__~~//\\0100~_ ペアの差を計算して検証する前に、入力文字列で。

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バイト

このバリアントは、上線の~代わりに使用します。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 "__ _/ /~ ~~ ~\\ \\_ \\/ /\\"

Perl 6、32バイト

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

オンラインでお試しください！

文字列に無効なシーケンスが含まれていないことを単純にチェックする正規表現ソリューション。

説明：

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

R、43文字、47バイト

これは、他の回答が使用するのと同じ正規表現ですが、Rに適合しています。

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

オンラインでお試しください！

そして、義務的なxkcd。

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

文字のリストを受け入れるモナドリンクは、オプションの~代わりに使用し‾ます。

オンラインでお試しください！または、テストスイートを参照してください（...ここで、8つの偽物を最後に配置するように並べ替えました）

この式は、手でいじることで見つかりました：p（以下のように）

これについても、べき乗として扱われる文字の序数の16組すべてが、3バイトの後に1バイトのモジュロ（1,2,3,4,5,6,7,8が続く）に適合する大きなモジュロを探しましたすべて私が知っているので、許容できる結果が1または0）（「重要でない」のいずれかであったのは16ように仕切られ、9,10,16,256）Ịよりも短くなっている<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;[/~][_/]|[\\_][~\\]

TIO

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を使用して、許可されたネイバー（in g"__/~~\\/\\_"）のリストと、入力リスト内のすべてのネイバーペアのリストを生成します。次に、各隣接ペアが許可されたペアであることを確認します。

C（gcc）、41 36バイト

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

オンラインでお試しください！

-5は&1、Peter Cordesのアイデアから始まりました。括弧を削除するために演算子（優先順位）を変更

を使用し~ます。最初の2文字のバイナリ表現の最初と6番目のビットを確認します。

_ 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バイト。

（または、単純に文字列の1文字の文字列を処理せずに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から呼び出し可能。booltransitions = 0ケースが1ではなくASCIIコードを返すためではありません。

RCX = len = strlen(s) - 1。つまり、文字境界の数=明示的な長さの文字列をチェックインする遷移。

の場合transitions > 0、0（ミスマッチ）または1（接続済み）を返し、ZFを設定したままにします。の場合transitions == 0、文字列の1バイトを返します（これはゼロではないため、真実です）。 その特別なケースでない場合は、早期終了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 ++、132 110バイト

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バイト

Regexを言語として使用するルールが見つかりませんでした。これを調整する必要がある場合はお知らせください。

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

ここで試してください：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提供