テキストの対角線を描く


46

単語リストの入力が与えられた場合、文字を斜めに配置して単語を出力します。

p
 r
  o
p  g
 u  r
  z  a
a  z  m
 n  l  m
  d  e  i
c     s  n
 o        g
  d
g  e
 o
  l
   f

(上記は入力の出力になりますprogramming puzzles and code golf。)

正確には、各単語は前の単語の最初の列と3行下から始まり、連続する各文字は1列右に1行下に移動します。

入力は、1つのスペースで区切られた単語の単一の文字列、または単語のリスト/配列として提供されます。単語は小文字ののみで構成され、a-z常に少なくとも1文字の長さになります。

出力は、単一の文字列、行の配列、または文字の配列の配列です。単一の末尾の改行を除いて、先頭または末尾の空白は許可されません。

さらなるテストケース:

a bcd efgh i j

a


b
 c
  d
e
 f
  g
i  h


j

x

x

verylongword short

v
 e
  r
s  y
 h  l
  o  o
   r  n
    t  g
        w
         o
          r
           d

これはであるため、バイト単位の最短コードが勝ちます!


私はこのためのPythonプログラムを5分で作成できるはずだと感じていますが、常に失敗しているようです...; _;
ハイパーニュートリノ

うわー、タートルード用に設計されたと思われる多くの課題があるようです
破壊可能なレモン

ターミナルエスケープコードは許可されていますか?:)
クロム

回答:


17

VIM、85、76、66、52キーストローク/バイト

このチャレンジを初めて見たとき、「これはvimに最適です!」そして、私がそれを試みたとき、すべてがうまくいきませんでした。これは、すべてが乱雑でハッキーな栄光です。

:se ve=all|s/ /\r\r\r/g
qqGo<esc>?\<.\S
lDjP@qq@qG?.
jdG

(ほとんど)後方互換性のあるVインタープリターのおかげで、オンラインで試してください

説明:

最初は、この美しくシンプルな37バイトバージョンができると思いました。

:se ve=all
qq:g/\S\S/norm ^lDjP
@qq@q

残念ながら、それほど単純ではありません。行ごとに見てみましょう:

:se ve=all

これにより、「仮想編集」と呼ばれる機能が有効になります。これにより、カーソルはまだ存在しない列に移動できます。この答えは、それなしでは基本的に不可能です。

次に、単語を異なる行に分離する必要があります。したがって、各スペースを3つの改行で置き換えます。これはexコマンド:se ve=allであるため、バーで2つを分離することにより、最後のexコマンドと同時に実行できます。

|s/ /\r\r\r/g

バッファは次のようになります。

Programming


Puzzles


and


code-golf

ここからが楽しみの始まりです。伝統的な再帰マクロを:qqで設定し、これを呼び出します:

G               " Move to the last line
 o<esc>         " Append an extra newline

?               " Search backwards for
 \<.            " Any character at the beginning of a word
    \S          " Followed by a non-space character
l               " Move one character to the right
 D              " Delete eveything until the end of this line
  j             " Move down one line
   P            " Paste what we just deleted

次に、で再帰マクロを終了し@qq@qます。この時点で、すべての対角線があります。少しクリーンアップするだけです。

G                   " Move to the last line
 ?.                 " Search backwards for any character
j                   " Move down one line
 dG                 " Delete until the end of the buffer

うわー、JavaScriptは(現在)Vimよりも短いです。それは最近では非常にまれな
出来事

@ETHproductionsこれ以上はありません。:)
DJMcMayhem

6

タートルード28 26バイト

ああ、ゴルフのために特別に設計された言語を打ち負かしているようです。これは素晴らしい日です。

!_4[*.[ rd+.]ul[ ul]r;_+]_

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

説明

(書き込みはグリッド上のセルへの書き込みを意味し、先の尖った文字は文字列ポインタが指す入力の文字を意味します)

!                         Take string input into variable
 _                        Normally conditional, with >1 input (there will be), write ' '
  4                       set register to 4
   [*                   ] until the current cell is *
     .                    Write pointed char, initially first char
      [     ]             Until space is written on cell
        rd+.              move right, down, string pointer++, write pointed char
             ul[ ul]      Move back up to the top of the word
                    r;    Move right, down 4 (because this is register value)
                      _+  write * if end of input, else ' ', increment string pointer
                        _ will always write ' ', since it will always point at start char

末尾のスペースに注意してください。

入力には末尾スペースも必要です。Pythonがリストを取ることができるので、これはTurtlèdでリストを取るのとよく似ています


5

MATL、28バイト

c!t&n:q3_*ts_b+5M4$XdZ!cZ{Zv

入力は文字列のセル配列であり、オプションのセパレーターとしてコンマを使用します。

{'programming' 'puzzles' 'and' 'code' 'golf'}

または

{'programming', 'puzzles', 'and', 'code', 'golf'}

オンラインでお試しください!またはすべてのテストケースを検証:1234

説明

例として次の入力を検討してください。

{'aaaa' 'bb' 'ccc'}

%コードの任意の位置にコメント記号を挿入して、部分的な結果(スタックの内容)を表示できます。たとえば、4番目の関数()の後のスタックの内容を表示します&n

c        % Input cell array of strings implicitly. Convert to 2D char array,
         % right-padding with spaces
         % STACK: ['aaaa'; 'bb  '; 'ccc']
!        % Transpose
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  ']
t        % Duplicate
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '],
                  ['abc'
                   'abc'
                   'a c'
                   'a  '],
&n       % Number of rows and of columns
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '], 4, 3
:q       % Range, subtract 1
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '], 4, [0 1 2]
3_*      % Multiply by -3
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '], 4, [0 -3 -6]
ts_      % Duplicate, sum, negate
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '], 4, [0 -3 -6], 9
b        % Bubble up in stack
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '], [0 -3 -6], 9, 4
+        % Add
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '], [0 -3 -6], 13
5M       % Push second input of last function again
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '], [0 -3 -6], 13, 4
4$Xd     % Buld numerical sparse matrix from the above four arguments. The
         % columns of the first input argument will be the diagonals of the
         % result, with indices given bu the second input (negative is below
         % main diagonal). The matrix size is the third and fourth arguments
         % STACK: [97  0  0  0
                    0 97  0  0
                    0  0 97  0
                   98  0  0 97
                    0 98  0  0
                    0  0 32  0
                   99  0  0 32
                    0 99  0  0
                    0  0 99  0
                    0  0  0 32
                    0  0  0  0
                    0  0  0  0
                    0  0  0  0]
Z!c      % Convert from sparse to full, and then to char. Character 0 is
         % displayed as space
         % STACK: ['a   '
                   ' a  '
                   '  a '
                   'b  a'
                   ' b  '
                   '    '
                   'c   '
                   ' c  '
                   '  c '
                   '    '
                   '    '
                   '    '
                   '    ']
Z{       % Split into cell array, with each row in a cell
         % STACK: {'a   ', ' a  ', '  a ', 'b  a', ' b  ', '    ', 'c   ', ' c  ', '  c ', '   ', '   ', '   ', '   '}
Zv       % Deblank: remove trailing space from each string. Implicitly display,
         % each string on a different line. Empty strings do not generate
         % a newline
         % STACK: {'a   ', ' a', '  a', 'b  a', ' b', '', 'c', ' c', '  c', '', '', '', ''}

4

JavaScriptの(ES6)、118の 109 84バイト

入力を単語の配列として受け取ります。文字の配列の配列を返します。

s=>s.map((w,y)=>[...w].map((c,x)=>(a[p=y*3+x]=a[p]||Array(x).fill(' '))[x]=c),a=[])&&a

代替バージョン、109バイト

文字列を返します。


2

Common Lisp、673 668 597バイト

ひどい解決策、私は知っています。しばらくスリープした後、おそらくこれを編集します。

(defun f(&rest z)(let((l)(a 0)(s)(o)(b)(c 0))(loop(setf b(length l))(setf l"")(loop for w in z for i from 0 do(if(>(+(length w)(* i 3))c)(setf c(+(length w)(* i 3))))(setf s(+(* i -3)a))(when(and(>= s 0)(< s(length w)))(setf o(format nil"~v@{~a~:*~}"s" "))(if(and(>=(- s 3)0)(not(equal i(-(length z)1))))(setf o(subseq o(- s 2))))(setf l(concatenate'string o(string(char w s))l)))(when(>= s(length w))(setf l(concatenate'string"   "l))))(if(<=(length l)b)(setf l(concatenate'string(format nil"~v@{~a~:*~}"(- b(length l)-1)" ")l)))(print(string-right-trim" "l))(if(>= b c)(return))(setf a(1+ a)))))

使用法:

* (f "ppcg" "is" "pretty" "ok")

"p" 
" p" 
"  c" 
"i  g" 
" s" 
"" 
"p" 
" r" 
"  e" 
"o  t" 
" k  t" 
"     y" 
""
NIL

これにより、指定されたリスト内のすべての単語がループされ、現在の行に適切な文字が追加されます。適切なパディングは、のサブパー使用法によって提供されformatます。

注:私はCommon Lispを初めて使用しますが、これにより多くの改善が見込めることを十分に理解しています。


2
> :( "ppcg ... ok" !?
破壊可能なレモン

2

C#、336バイト:

ゴルフ:

string D(string[]s){int x=0,y=0,r=0,q=2*(s.Max().Length+s.Length)+1;var a=new char[q, q];for(int i=0;i<s.Length;i++){y=r;for(int j=0;j<s[i].Length;j++){a[y,x]=s[i][j];x+=1;y+=1;}x=0;r+=3;}var o="";for(x=0;x<q;x++){var t="";for(y=0;y<q;y++)t+=a[x,y];o+=t==string.Join("",Enumerable.Repeat('\0',q))?"":(t.TrimEnd('\0')+"\r\n");}return o;}

ゴルフをしていない:

public string D(string[] s)
{
  int x = 0, y = 0, r = 0, q = 2 * (s.Max().Length + s.Length) + 1;
  var a = new char[q, q];
  for (int i = 0; i < s.Length; i++)
  {
    y = r;
    for (int j = 0; j < s[i].Length; j++)
    {
      a[y, x] = s[i][j];
      x += 1;
      y += 1;
    }
    x = 0;
    r +=3;
  }
  var o = "";
  for (x = 0; x < q; x++)
  {
    var t = "";
    for (y = 0; y < q; y++)
      t += a[x, y];
    o += t == string.Join("", Enumerable.Repeat('\0', q)) ? "" : (t.TrimEnd('\0') + "\r\n");
  }
  return o;
}

テスト:

  var codeGolf = new DrawDiagonalLinesOfText();
  Console.WriteLine(codeGolf.E(new string[] { "programming", "puzzles", "and", "code", "golf" }));
  Console.WriteLine(codeGolf.E(new string[] { "a", "bcd", "efgh", "i", "j" }));
  Console.WriteLine(codeGolf.E(new string[] { "verylongword", "short" }));

p
 r
  o
p  g
 u  r
  z  a
a  z  m
 n  l  m
  d  e  i
c     s  n
 o        g
  d
g  e
 o
  l
   f


a
b
 c
  d
e
 f
  g
i  h
j


v
 e
  r
s  y
 h  l
  o  o
   r  n
    t  g
        w
         o
          r
           d

これは、行末に末尾の空白を出力するように見えますが、これはチャレンジ仕様では許可されていません。また、入力配列内の単語を区切るためにスペースの文字列を要求することは、許可された入力形式ではありません。
ドアノブ

@Doorknobおっと、すみません...修正、2バイトしかかかりません:)
ピートアーデン

1
にコンパイルし、Func<string[], string>297バイトのさまざまな変更s=>{int i=0,x=0,y=0,r=0,l=s.Length,q=2*(s.Max().Length+l)+1,j;var a=new char[q,q];for(;i<l;i++){y=r;for(j=0;j<s[i].Length;)a[y++,x++]=s[i][j++];x=0;r+=3;}var o="";for(;x<q;x++){var t="";for(y=0;y<q;)t+=a[x,y++];o+=t==string.Join("",Enumerable.Repeat('\0',q))?"":(t.TrimEnd('\0')+"\n");}return o;};を加えますが、18バイトを追加する必要がありますusing System.Linq;
-TheLethalCoder

@TheLethalCoderありがとう、しかし、私は本当にあなたのソリューション全体を取りたいとは思わない:)
ピートアーデン

それは私がちょうど離れてものの一部をgolfedそのあなたがすなわちthwe移動鉱山ではありませんiし、j上部にあるint型の宣言にするとの一部を移動する++彼らは、変数の最後の使用に使用されるように
TheLethalCoder

2

Python 2、146バイト

s=input()
k=max(map(len,s))
a=[k*[' ']for x in range(k+len(s)*3+3)]
for x in range(len(s)):
 for y in range(len(s[x])):a[x*3+y][y]=s[x][y]
print a

注:最後の2行のインデントは<space>and <tab>であり、ダブルインデントする必要がないため、1バイト節約されます。

入力は、そのような文字列の配列として入力する:["hello", "world"]または['hello', 'world']。出力は、文字の配列の配列です。

これを行うにはおそらくもっと良い方法があります...

編集不足している閉じた角かっこを指摘してくれたDoorknobに感謝します。*k...3行目の前に配置しました。


コードの3行目に構文エラーがあります。2つのオープンブラケットがありますが、クローズブラケットは1つだけです。しかし、私はそれを修正します(追加の閉じ括弧を追加するか、余分な開き括弧を削除することにより)、プログラムは実行時にエラーを出します。
ドアノブ

これにより、行末および出力の末尾に末尾の空白が出力されるようになりましたが、これはチャレンジ仕様では許可されていません。
ドアノブ


@LeakyNunありがとう。私の答えをすべて通り抜けてゴルフをしているだけですか?:P
ハイパーニュートリノ

1

Mathematica、146バイト

P=PadRight;T=Transpose;R=Riffle;Select[Rest@T@P@MapIndexed[""~Table~#2~Join~#1&,T@P@R[Characters/@#~R~{},{},3]]//.{0->"",{x__,""}->{x}},#!={""}&]&

このバイトカウントには失望していますが、まあまあです。

単語のリスト(例:)を取り、{"this","that","these"}文字の2次元配列を返す匿名関数を定義します。グリッド形式で表示するに//Gridは、最後にを追加します。

文字列を配列に変換し、余分な行を追加し、配列を転置し、必要なシフトを追加してから、再度転置します。

結果の例(グリッド形式): 結果例


1

ゼリー、24 バイト

z⁶j€⁾  µJ’⁶ẋ;"z⁶œr€⁶Yœr⁷

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

どうやって?

z⁶j€⁾  µJ’⁶ẋ;"z⁶œr€⁶Yœr⁷ - Main link: a list of strings
z                        - transpose with filler...
 ⁶                       -     space character
  j€                     - join €ach with
    ⁾                    -     two spaces
       µ                 - monadic chain separation, call the result x
        J                - range(length(x)) [1,2,...,x]
         ’               - decrement (vectorises) [0,1,...x-1]
           ẋ             - repeat (vectorises)
          ⁶              - a space ['', ' ',...,'x spaces']
             "           - zip with
            ;            - concatenation (prefixes with the space strings)
              z          - transpose with filler...
               ⁶         -     space character
                œr€⁶     - trim spaces from the right of €ach
                    Y    - join with line feeds
                     œr⁷ - trim line feeds from the right
                         - implicit print

1

Python 2、182バイト

def f(s):
 M=max(map(len,s));p=' '*M;L=[p]+s+M*[p];r='';k=0
 while k/M<len(s)*3+M:
  i=k%M;w=k/M-i+1;r+=(L[(w/3+1)*(w%3==1)]+p)[i];k+=1
  if i==M-1:r=r.rstrip()+'\n'
 return r.strip()

少し長めですが、プラス側では、各行の末尾に空白がない文字列を返し、末尾に空白がないか、末尾に戻ります。他のいくつかのエントリが従わない制約。

単語のリストが関数に渡されます。一部の「空白」はこのリストに追加され、アルゴリズムは行と列のペアを展開リストのwordNumber、characterNumberにマップします。(これは、他のソリューションで見られる通常の戦略の少し逆です)。

最後の行を除くすべての行で末尾の空白を許可する場合、少し改善することができます(163バイト):

def f(s):
 M=max(map(len,s));p=' '*M;L=[p]+s+M*[p];r='';k=0
 while k/M<len(s)*3+M:i=k%M;w=k/M-i+1;r+=(L[(w/3+1)*(w%3==1)]+p)[i]+'\n'*(i==M-1);k+=1
 return r.strip()

1

Q / KDB +、130の 109 94 90 86 84バイト

解決:

f:{-1(+)a rtrim(til(#)E){raze(x#" "),y,\:"  "}'E:(+)(a:{(max(#:)each x)$x})" "vs x;}

例:

q)f "programming puzzles and code golf"
p          
 r         
  o        
p  g       
 u  r      
  z  a     
a  z  m    
 n  l  m   
  d  e  i  
c     s  n 
 o        g
  d        
g  e       
 o         
  l        
   f 
q)f "a bcd efgh i j"
a   


b   
 c  
  d 
e   
 f  
  g 
i  h


j  
q)f (),"x"
x
q)f "verylongword short"
v           
 e          
  r         
s  y        
 h  l       
  o  o      
   r  n     
    t  g    
        w   
         o  
          r 
           d

説明(変更なし):

基本的な要点は、入力文字列から同じ長さの文字列の束を作成し、それらを反転(回転)してから、適切な空白を追加して次のようなものを取得することです。

"p  p  a  c  g   "
" r  u  n  o  o  "
"  o  z  d  d  l "
"   g  z     e  f"
"    r  l        "
"     a  e       "
"      m  s      "
"       m        "
"        i       "
"         n      "
"          g     "

これは再び反転され、標準出力に出力されます。

概念の行ごとの内訳は次のとおりです。

A:"programming puzzles and code golf"; // original input
B:" " vs A;                            // split on " "
C:max count each B;                    // find length of the longest string
D:C$B;                                 // pad each string to this length
E:flip D;                              // flip (rotate) string
F:{raze(x#" "),y,\:"  "};              // appends each char with "  " and prepends an increasing number of " "
G:(til count E)F'E;                    // execute function F with each pair of 0..n and item in list E
H:max count each rtrim G;              // find longest string (ignoring right whitespace)
I:H$G;                                 // pad each of the strings to this length
J:flip I;                              // flip to get result
-1 J;                                  // print to stdout, swallow return value

ノート:

本当にしたい場合、いくつかの簡単なバイトを削るいくつかの方法:

  • をドロップf:して匿名関数として残すことで2バイト節約できます
  • -1and ;をドロップして、stdoutに出力するのではなく、文字列のリストを返すことで3バイトを節約できます
  • スペースで区切られた文字列ではなく文字列のリストを渡すと、6バイト節約できます

編集:

  • -11バイト、埋め込みのrtrim最大長を見つけるために使用、C変数を格納する必要性を削除
  • -15バイト、1回作成されて2回使用されるmax count eachラムダ関数の切り替えa
  • -4バイト、をrazeラムダ関数に移動して保存しますraze each
  • -4バイト、空白を追加するコアラムダ関数を簡略化
  • -2バイト、の(+)省略形として使用flip

1

16 9 バイト

WS«P↘ιM³↓

私の最初の炭の答え。@DLoscの提案に感謝し代わりにand (Jump)を使用して行の先頭(および3つ下)に戻ります。

(詳細)オンラインそれを試してみたり(純粋)オンラインそれを試してみてください

説明:

次の入力文字列がまだある間にループします。

While(InputString()){ ... }
WS« ...

カーソルを右下方向に移動せずにこの文字列を印刷します。

Multiprint(:DownRight, i);
P↘ι

そして、次の反復のために3つの位置を下に移動します。

Move(3, :Down);
M³↓

チャレンジが配列で構成される単一の入力を必要とする場合、Charcoalは、入力文字列を分割してすべての単語を個別の入力として取得するため、失敗します。しかし、Charcoalではθ変数は最初の入力を表しているので、ヘッダー内のその変数にテスト入力を割り当ててから残りのコードを記述するだけで、α変数を削除しての分割された項目を反復処理できますθオンラインでお試しください!(先行スペースによる非競合。)
チャーリー

少なくとも、私がここでそのトリックを使用したときに文句を言う人はいませんでした。:
チャーリー

@CarlosAlejo既存のチャコールの答えにインスピレーションを求めていたとき、私は確かにあなたの答えに出会いました。:)
ケビンクルーイッセン

IDK任意のPythonの配列として入力後、複数行ある場合は、この方法は、私は通常の使用では、末尾に文字列だけで+空の文字列です
ASCIIのみの

@CarlosAlejoしばらく経ちましたが、今回は複数の行を使用して、空の行でwhileを中断しました(同時に7バイトをゴルフしました)。Neilの回答の1つで使用されているのを見たところ、ASCIIのみが同じことを示唆していることがわかりました(なんとなくそのコメントを見逃しました)。
ケビンCruijssen

1

Japt -Rx17 16 13バイト

入力を単語の配列として受け取ります。各行の末尾の空白が許可されている場合、最後の4文字を削除してCharcoalソリューションと関連付けることができます。

yÈmú3)iYçÃmx1

試してみるかすべてのテストケースを実行してください


説明

y                 :Transpose
 È                :Map each word at 0-based index Y
  m               :  Map each character
   ú3             :    Right pad with spaces to length 3
     )            :  End mapping
      i           :  Prepend
       Yç         :   Space repeated Y times
         Ã        :End mapping and transpose
          m       :Map
           x1     :  Trim right
                  :Implicitly join with newlines, trim and output

1

K4、58バイト

解決:

+(|/{0+/|\|~^x}@'x)$x:(2-(!c)+3*#x)$"  "/:'$+(c:|/#:'x)$x:

例:

q)k)+(|/{0+/|\|~^x}@'x)$x:(2-(!c)+3*#x)$"  "/:'$+(c:|/#:'x)$x:("programming";"puzzles";"and";"code";"golf")
"p          "
" r         "
"  o        "
"p  g       "
" u  r      "
"  z  a     "
"a  z  m    "
" n  l  m   "
"  d  e  i  "
"c     s  n "
" o        g"
"  d        "
"g  e       "
" o         "
"  l        "
"   f       "
q)k)+(|/{0+/|\|~^x}@'x)$x:(2-(!c)+3*#x)$"  "/:'$+(c:|/#:'x)$x:(,"a";"bcd";"efgh";,"i";,"j")
"a   "
"    "
"    "
"b   "
" c  "
"  d "
"e   "
" f  "
"  g "
"i  h"
"    "
"    "
"j   "
q)k)+(|/{0+/|\|~^x}@'x)$x:(2-(!c)+3*#x)$"  "/:'$+(c:|/#:'x)$x:("verylongword";"short")
"v           "
" e          "
"  r         "
"s  y        "
" h  l       "
"  o  o      "
"   r  n     "
"    t  g    "
"        w   "
"         o  "
"          r "
"           d"

説明:

同じ長さになるように文字列を右詰めし、転置し、で結合し" "、左パッドで対角線を生成し、次に右パッドで長さを修正し、元に戻します。文字列のリストを取り、文字列のリストを返します。おそらくゴルフはできますが、それでも私のq / kdb +ソリューションよりは短いです。

+(|/{0+/|\|~^x}@'x)$x:(2-(!c)+3*#x)$"  "/:'$+(c:|/#:'x)$x:
                                                        x:      / save as variable x
                                                       $        / pad
                                             (        )         / do this together
                                                  #:'x          / count (#:) each (') x
                                                |/              / max
                                              c:                / save as variable c
                                            +                   / flip / transpose
                                           $                    / string ($)
                                    "  "/:'                     / join each with "  "
                                   $                            / pad
                      (           )                             / do this together
                                #x                              / count (#) x
                              3*                                / multiply by 3
                             +                                  / add to
                         (  )                                   / do this together
                          !c                                    / range 0..c
                       2-                                       / subtract from 2
                    x:                                          / save as x:
                   $                                            / pad
 (                )                                             / do all this together
    {         }@'x                                              / apply (@) lambda {} to each x
            ^x                                                  / null (^) x (" " is considered null)
           ~                                                    / not
          |                                                     / reverse
        |\                                                      / max (|) scan (\), maxs
     0+/                                                        / sum (+) over (/) starting with 0
  |/                                                            / max (|) over (/), max
+                                                               / transpose


弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.