挖一条边境战trench

59

背景：有太多来自布兰迪亚的非法移民越过边界前往阿斯坦。阿斯坦皇帝（Astan）曾命令您挖沟以将其拒之门外，而布兰迪亚（Blandia）必须支付费用。由于所有打字员都已休假直到安排好沟槽，因此您的代码必须尽可能短。*

任务：给定阿斯坦（Astan）和布兰迪亚（Blandia）之间边界的2D地图，让布兰兹（Blands）支付（带有土地）边界战trench。

例如：标记了Astanian单元，标记了ABlandic单元B和标记了Trench单元+（地图框仅是为了清楚起见）：

┌──────────┐ ┌──────────┐
│AAAAAAAAAA│ │AAAAAAAAAA│
│ABAAAAAABA│ │A+AAAAAA+A│
│ABBBAABABA│ │A+++AA+A+A│
│ABBBAABABA│ │A+B+AA+A+A│
│ABBBBABABA│→│A+B++A+A+A│
│ABBBBABBBB│ │A+BB+A++++│
│ABBBBABBBB│ │A+BB+A+BBB│
│ABBBBBBBBB│ │A+BB+++BBB│
│BBBBBBBBBB│ │++BBBBBBBB│
└──────────┘ └──────────┘

详细信息：该地图将至少具有三行三列。最上面的行将完全是Astanian，最下面的行将完全是Blandic。
 只要输入和输出保持一致，就可以使用任何三个值来表示阿斯坦领土，布兰迪领土和边界trench沟。

自动机公式：在摩尔邻域中具有至少一个Astanian细胞的Blandic细胞成为边界沟槽细胞。

测试用例

[
  "AAAAAAAAAA",
  "ABAAAAAABA",
  "ABBBAABABA",
  "ABBBAABABA",
  "ABBBBABABA",
  "ABBBBABBBB",
  "ABBBBABBBB",
  "ABBBBBBBBB",
  "BBBBBBBBBB"
]

变成：

[
  "AAAAAAAAAA",
  "A+AAAAAA+A",
  "A+++AA+A+A",
  "A+B+AA+A+A",
  "A+B++A+A+A",
  "A+BB+A++++",
  "A+BB+A+BBB",
  "A+BB+++BBB",
  "++BBBBBBBB"
]

[
  "AAA",
  "AAA",
  "BBB"
]

变成：

[
  "AAA",
  "AAA",
  "+++"
]

[
  "AAAAAAAAAA",
  "AAAABBBAAA",
  "AAAABBBAAA",
  "AAAABBBAAA",
  "AAAAAAAAAA",
  "BBBBBBABBB",
  "BBBBBBAABB",
  "BBBAAAAABB",
  "BBBBBBBBBB"
]

变成：

[
  "AAAAAAAAAA",
  "AAAA+++AAA",
  "AAAA+B+AAA",
  "AAAA+++AAA",
  "AAAAAAAAAA",
  "++++++A+++",
  "BB++++AA+B",
  "BB+AAAAA+B",
  "BB+++++++B"
]

*免责声明：任何对实际地缘政治的拒绝纯属巧合！

code-golf  matrix  cellular-automata 
— 亚当
source
23
以代码高尔夫的形式进行的政治讽刺，我喜欢它：o）
— Sok
4
-1表示<sup><sub><sup><sub><sup><sub><sup><sub>：-P
— Luis Mendo
25
python，4个字节：pass修建边界战plans的计划导致政府关闭，但没有任何反应。
— TheEspinosa
3
@TheEspinosa不，不，要等到沟渠排好为止。
— 阿达姆（Adám）
1
我投票只是因为背景故事。甚至没有继续阅读。
— 管道

Answers:

8

JavaScript（ES7）， 84  82字节

@Shaggy节省了2个字节

301个

a=>(g=x=>a.map(t=(r,Y)=>r.map((v,X)=>1/x?t|=(x-X)**2+(y-Y)**2<v:v||g(X,y=Y)|t)))()

在线尝试！

已评论

a => (                      // a[] = input matrix
  g = x =>                  // g = function taking x (initially undefined)
    a.map(t =               //   initialize t to a non-numeric value
      (r, Y) =>             //   for each row r[] at position Y in a[]:
      r.map((v, X) =>       //     for each value v at position X in r[]:
        1 / x ?             //       if x is defined (this is a recursive call):
          t |=              //         set the flag t if:
            (x - X) ** 2 +  //           the squared Euclidean distance
            (y - Y) ** 2    //           between (x, y) and (X, Y)
            < v             //           is less than v (3 = Astan, 0 = Blandia)
        :                   //       else (this is the initial call to g):
          v ||              //         yield v unchanged if it's equal to 3 (Astan)
          g(X, y = Y)       //         otherwise, do a recursive call with (X, Y) = (x, y)
          | t               //         and yield the flag t (0 = no change, 1 = trench)
      )                     //     end of inner map()
    )                       //   end of outer map()
)()                         // initial call to g
— Arnauld
source
— 毛茸茸的
4
@Shaggy最近没有足够的问题。我不知道怎么打高尔夫球了。：D谢谢！
— Arnauld
我只是早些时候在想同样的事情！
— 毛茸茸的
7

K（ngn / k），23个字节

{x+x&2{++/'3'0,x,0}/~x}

在线尝试！

使用0 1 2的"AB+"

{ } 带参数的功能 x

~ 逻辑不

2{ }/ 两次做

  • 0,x,0 用0-s环绕（矩阵的顶部和底部）

  • 3' 连续行的三倍

  • +/' 每个加起来

  • + 转置

x&逻辑x与

x+添加x到

— ngn
source
5

APL（Dyalog Unicode），11字节SBCS

⊢⌈{2∊⍵}⌺3 3

这基于@dzaima 在chat中的12字节解决方案。感谢@Adám自己考虑∊在dfn 中使用，以及@ H.PWiz提醒我们对输入和输出使用相同的编码

在线尝试！

表示'AB+'作为2 0 1分别

{ }⌺3 3 将函数应用于输入的每个重叠3×3区域，包括在矩阵外部延伸1个单位并填充0的区域

2∊⍵参数中是否存在2？返回一个0/1布尔值

⊢⌈ 每个元素的最大值与原始矩阵

— ngn
source
当然，切换到Stencil可以节省一半以上的字节。
— 阿达姆，
@Adám可能是另一种语言的答案，因此无法与之相比或与之竞争。而且我觉得打高尔夫球不是特别有趣，对不起
— ngn
@Adám display我忘记删除的别名。现在删除
— ngn
5

PowerShell，220字节

它没有其他提交的文件那么小，但是我想我将其添加为参考。[前面！]

function m($i,$m){($i-1)..($i+1)|?{$_-in0..$m}}
$h=$a.count-1;$w=$a[0].length-1
foreach($i in 0..$h){-join$(foreach($j in 0..$w){if ($a[$i][$j]-eq'B'-and($a[(m $i $h)]|?{$_[(m $j $w)]-match'A'})){'+'}else{$a[$i][$j]}})}

在线尝试！

— 基思·S·加纳
source
1
欢迎来到PPCG。不错的第一答案，甚至还有TIO链接！不用担心代码长度。每种语言相互竞争。顺便说一句，您可以通过删除第一个换行符来节省一个字节，而不会产生不良影响。
— 亚当
最后一行可以变成0..$h|%{-join$(foreach($j in 0..$w){if ($a[$_][$j]-eq'B'-and($a[(m $_ $h)]|?{$_[(m $j $w)]-match'A'})){'+'}else{$a[$_][$j]}})}207个字节吗？
— 加布里埃尔·米尔斯
4

八度，37 31 26字节

该函数使用来对“图像” 的Astan（）部分执行形态侵蚀，然后使用某种算法使所有三个区域变为不同的符号。感谢@LuisMendo提供-5个字节！1-bconv2 imerode

@(b)2*b-imerode(b,ones(3))

在线尝试！

— 瑕疵
source
2
-1为无卷积：-P
— Luis Mendo
@LuisMendo一个较早的版本的确包含了卷积：）
— 更加模糊的
谢谢，更新！
— flawr
3

J，28个字节

>.3 3(2 e.,);._3(0|:@,|.)^:4

在线尝试！

'AB+' -> 2 0 1

受到ngn的APL解决方案的启发。12个字节，只是用零填充矩阵...

— 加伦·伊万诺夫（Galen Ivanov）
source
为什么APL解决方案无需进行零填充就能摆脱困境？
— 约拿（Jonah）
@Jonah：APL的⌺（Stencil）原子地做它：“矩形以Y的连续元素为中心，并且（除非矩形大小为1），用填充元素填充。”
— Galen Ivanov
这似乎比J的版本有用得多
— 乔纳
@Jonah是的，是的！
— Galen Ivanov
2

木炭，20字节

≔⪫θ⸿θＰθＦθ⎇∧№ＫＭA⁼Bι+ι

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

≔⪫θ⸿θ

用回车符而不是通常的换行符将输入数组连接起来。这是必需的，以便可以单独打印字符。

Ｐθ

在不移动光标的情况下打印输入字符串。

Ｆθ

循环输入字符串的每个字符。

⎇∧№ＫＭA⁼Bι

如果Moore邻域包含A，并且当前字符是B...

+

......然后覆盖B用+...

ι

...否则，打印当前字符（如果当前字符是回车符，则移至下一行）。

— 尼尔
source
2

JavaScript，85个字节

昨晚深夜把它们扔在一起，却忘了它。在某个地方可能仍有改进的余地。

输入和输出是数字数组的数组3，0用于Astan ，Blandia和1Trench。

a=>a.map((x,i)=>x.map((y,j)=>o.map(v=>o.map(h=>y|=1&(a[i+v]||x)[j+h]))|y),o=[-1,0,1])

在线尝试（为方便起见，映射往返于挑战中使用的I / O格式）

— 毛茸茸
source
2

Javascript，126118字节

_=>_.map(x=>x.replace(/(?<=A)B|B(?=A)/g,0)).map((x,i,a)=>[...x].map((v,j)=>v>'A'&&(a[i-1][j]<v|(a[i+1]||x)[j]<v)?0:v))

传递问题中的一个字符串数组，您将获得一个字符串字符串数组（感谢@Shaggy！），使用0作为沟槽。可以或许被golfed多个（不切换到数字阵列），但我不认为此刻什么。

— 迪尔
source
我认为这适用于120个字节。
— 毛茸茸的
或116个字节返回字符数组的数组。
— 毛茸茸的
1
@Shaggy可悲的是，您的高尔夫球无法工作-它无法捕捉到A和B彼此对角的地方。另一方面，它确实指出了我错过的一些非常简单的高尔夫……
— M Dirr
1

视网膜0.8.2，92 80个字节

(?<=¶(.)*)B(?=.*¶(?<-1>.)*(?(1)_)A|(?<=¶(?(1)_)(?<-1>.)*A.*¶.*))
a
iT`Ba`+`.?a.?

在线尝试！松散地基于我对我的回答是否能及时解决？说明：B紧接在As 之上或之下的s都将变成as。然后，将问题减少B到在As或as 的左侧或右侧检查s。该aš本身也需要得到转变成+当然的S，但幸运的是i标志T只影响正则表达式匹配，而不是实际的音译，所以AS保持。

— 尼尔
source
1

05AB1E，29 个字节

_2FIн¸.øVgN+FYN._3£})εøO}ø}*Ā+

矩阵并不是05AB1E的强项（也不是我的强项）。当然，可以打更多的高尔夫球。
受@ngn的K（ngn / k）启发，所以还使用I与2D整数矩阵的/ O 012为AB+分别。

在线尝试。（TIO中的页脚用于漂亮地打印输出。可以随意删除它以查看矩阵输出。）

说明：

_                # Inverse the values of the (implicit) input-matrix (0→1 and 1→0)
                 #  i.e. [[0,0,0,0],[0,1,0,0],[0,1,1,1],[1,1,1,1]]
                 #   → [[1,1,1,1],[1,0,1,1],[1,0,0,0],[0,0,0,0]]
 2F              # Loop `n` 2 times in the range [0, 2):
   Iн            #  Take the input-matrix, and only leave the first inner list of 0s
                 #   i.e. [[0,0,0,0],[0,1,0,0],[0,1,1,1],[1,1,1,1]] → [0,0,0,0]
     ¸           #  Wrap it into a list
                 #   i.e. [0,0,0,0] → [[0,0,0,0]]
      .ø         #  Surround the inverted input with the list of 0s
                 #   i.e. [[1,1,1,1],[1,0,1,1],[1,0,0,0],[0,0,0,0]] and [0,0,0,0]
                 #    → [[0,0,0,0],[1,1,1,1],[1,0,1,1],[1,0,0,0],[0,0,0,0],[0,0,0,0]]
        V        #  Pop and store it in variable `Y`
   g             #  Take the length of the (implicit) input-matrix
                 #   i.e. [[0,0,0,0],[0,1,0,0],[0,1,1,1],[1,1,1,1]] → 4
    N+           #  Add `n` to it
                 #   i.e. 4 and n=0 → 4
                 #   i.e. 4 and n=1 → 5
      F          #  Inner loop `N` in the range [0, length+`n`):
       Y         #   Push matrix `Y`
        N._      #   Rotate it `N` times towards the left
                 #    i.e. [[0,0,0,0],[1,1,1,1],[1,0,1,1],[1,0,0,0],[0,0,0,0],[0,0,0,0]] and N=2
                 #     → [[1,0,1,1],[1,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0],[1,1,1,1]]
            3£   #   And only leave the first three inner lists
                 #    i.e. [[1,0,1,1],[1,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0],[1,1,1,1]]
                 #     → [[1,0,1,1],[1,0,0,0],[0,0,0,0]]
              }  #  After the inner loop:
    )            #  Wrap everything on the stack into a list
                 #   → [[[0,0,0,0],[1,1,1,1],[1,0,1,1]],[[1,1,1,1],[1,0,1,1],[1,0,0,0]],[[1,0,1,1],[1,0,0,0],[0,0,0,0]],[[1,0,0,0],[0,0,0,0],[0,0,0,0]]]
     €ø          #  Zip/transpose (swapping rows/columns) each matrix in the list
                 #   → [[[0,1,1],[0,1,0],[0,1,1],[0,1,1]],[[1,1,1],[1,0,0],[1,1,0],[1,1,0]],[[1,1,0],[0,0,0],[1,0,0],[1,0,0]],[[1,0,0],[0,0,0],[0,0,0],[0,0,0]]]
       O         #  And take the sum of each inner list
                 #   → [[2,1,2,2],[3,1,2,2],[2,0,1,1],[1,0,0,0]]
        ø        #  Zip/transpose; swapping rows/columns the entire matrix again
                 #   i.e. [[2,1,2,2],[3,1,2,2],[2,0,1,1],[1,0,0,0]]
                 #    → [[2,3,2,1],[1,1,0,0],[2,2,1,0],[2,2,1,0]]
               } # After the outer loop:
                 #   i.e. [[3,5,5,4,2],[4,6,5,4,2],[2,3,2,2,1],[1,1,0,0,0]]
  *              # Multiple each value with the input-matrix at the same positions,
                 # which implicitly removes the trailing values
                 #  i.e. [[3,5,5,4,2],[4,6,5,4,2],[2,3,2,2,1],[1,1,0,0,0]]
                 #   and [[0,0,0,0],[0,1,0,0],[0,1,1,1],[1,1,1,1]]
                 #    → [[0,0,0,0],[0,1,0,0],[0,2,1,0],[2,2,1,0]]
   Ā             # Truthify each value (0 remains 0; everything else becomes 1)
                 #  i.e. [[0,0,0,0],[0,1,0,0],[0,2,1,0],[2,2,1,0]]
                 #   → [[0,0,0,0],[0,1,0,0],[0,1,1,1],[1,1,0,0]]
    +            # Then add each value with the input-matrix at the same positions
                 #  i.e. [[0,0,0,0],[0,1,0,0],[0,1,1,1],[1,1,0,0]]
                 #   and [[0,0,0,0],[0,1,0,0],[0,1,1,1],[1,1,1,1]]
                 #    → [[0,0,0,0],[0,2,0,0],[0,2,2,2],[2,2,1,1]]
                 # (and output the result implicitly)
— 凯文·克鲁伊森
source
1

C＃（Visual C＃交互式编译器），187字节

a=>a.Select((b,i)=>b.Select((c,j)=>{int k=0;for(int x=Math.Max(0,i-1);x<Math.Min(i+2,a.Count);x++)for(int y=Math.Max(0,j-1);y<Math.Min(j+2,a[0].Count);)k+=a[x][y++];return k>1&c<1?9:c;}))

而不是链接Take()s，Skip()s和Select()s，而是使用double for循环查找邻居。HUGE字节减少了，从392个字节减少到187个字节。Linq并不总是最短的！

在线尝试！

— 无知的体现
source
1

Perl 5，58 46字节

$m=($n=/$/m+"@+")-2;s/A(|.{$m,$n})\KB|B(?=(?1)A)/+/s&&redo

蒂奥

-12个字节感谢@Grimy

/.
/;s/A(|.{@{-}}.?.?)\KB|B(?=(?1)A)/+/s&&redo

蒂奥

  • -p喜欢，-n但也打印
  • -00 段落模式
  • 得到width-1 /.\n/匹配第一行的最后一个字符
  • @{-} 特殊数组，先前的匹配组的匹配开始的位置，被强制为字符串（第一个元素）
  • s/../+/s&&redo替代由比赛+而比赛
    • /s标记，以便.匹配换行符
  • A(|.{@{-}}.?.?)\KB 火柴
    • AB或A后面跟着（width-1）至（width + 1）个字符B
    • \K保持左边B不变
  • B(?=(?1)A)，
    • (?1) 递归递归，以引用先前的表达式 (|.{$m,$o})
    • (?=..) 前瞻，无需消耗输入即可进行匹配
— 纳韦尔·福耶勒（Nahuel Fouilleul）
source
-9个字节/. /,@m=@-while s/A(|.{@m}.?.?)\KB|B(?=(?1)A)/+/s（第一个正则表达式中的文字换行符）。TIO
— Grimy
1
降至46 ：/. /;s/A(|.{@{-}}.?.?)\KB|B(?=(?1)A)/+/s&&redo。TIO
— Grimy
谢谢，我也有这个主意，但是因为考虑到灾难性的回溯而放弃了，但是对于代码性能而言并不重要
— Nahuel Fouilleul
1

Java的8，169个 145字节

m->{for(int i=m.length,j,k;i-->0;)for(j=m[i].length;j-->0;)for(k=9;m[i][j]==1&k-->0;)try{m[i][j]=m[i+k/3-1][j+k%3-1]<1?2:1;}catch(Exception e){}}

-24个字节，感谢@OlivierGrégoire。

使用0代替A和1代替B，输入为2D整数矩阵。修改输入矩阵，而不是返回新的字节以节省字节。

单元格的检查与我对“ 全八”挑战的回答相同。

在线尝试。

说明：

m->{                            // Method with integer-matrix parameter and no return-type
  for(int i=m.length,j,k;i-->0;)//  Loop over the rows
    for(j=m[i].length;j-->0;)   //   Inner loop over the columns
      for(k=9;m[i][j]==1&       //    If the current cell contains a 1:
          k-->0;)               //     Inner loop `k` in the range (9, 0]:
        try{m[i][j]=            //      Set the current cell to:
             m[i+k/3-1]         //       If `k` is 0, 1, or 2: Look at the previous row
                                //       Else-if `k` is 6, 7, or 8: Look at the next row
                                //       Else (`k` is 3, 4, or 5): Look at the current row
              [j+k%3-1]         //       If `k` is 0, 3, or 6: Look at the previous column
                                //       Else-if `k` is 2, 5, or 8: Look at the next column
                                //       Else (`k` is 1, 4, or 7): Look at the current column
               <1?              //       And if this cell contains a 0:
                  2             //        Change the current cell from a 1 to a 2
                 :              //       Else:
                  1;            //        Leave it a 1
        }catch(Exception e){}}  //      Catch and ignore ArrayIndexOutOfBoundsExceptions
                                //      (try-catch saves bytes in comparison to if-checks)
— 凯文·克鲁伊森
source
1
我没有检查太多，但是有什么问题m[i+k/3-1][j+k%3-1]吗？145字节
— OlivierGrégoire
@OlivierGrégoireDang，这非常容易..谢谢！
— 凯文·克鲁伊森
我认为这对于您以前的挑战的答案也很有效，因为它们似乎具有相同的结构
— OlivierGrégoire
@OlivierGrégoire是的，我也想通过您的建议来打高尔夫，但随后又有另一条评论（和工作中的问题）出现。一会儿就会这样做。
— 凯文·克鲁伊森
1

的PowerShell，86 80字节

$p="(.?.?.{$(($args|% i*f '
')-1)})?"
$args-replace"(?s)(?<=A$p)B|B(?=$p`A)",'+'

在线尝试！

该地图是带有换行符的字符串。该脚本替换B为+regexp(?<=A(.?.?.{$MapWidth-1})?)B|B(?=(.?.?.{$MapWidth-1})?A)。

少打高尔夫球的测试脚本：

$f = {
$l=($args|% indexOf "`n")-1
$p="(.?.?.{$l})?"
$args-replace"(?s)(?<=A$p)B|B(?=$p`A)",'+'
}

@(
,(@"
AAAAAAAAAA
ABAAAAAABA
ABBBAABABA
ABBBAABABA
ABBBBABABA
ABBBBABBBB
ABBBBABBBB
ABBBBBBBBB
BBBBBBBBBB
"@,@"
AAAAAAAAAA
A+AAAAAA+A
A+++AA+A+A
A+B+AA+A+A
A+B++A+A+A
A+BB+A++++
A+BB+A+BBB
A+BB+++BBB
++BBBBBBBB
"@)
,(@"
AAA
AAA
BBB
"@,@"
AAA
AAA
+++
"@)
,(@"
AAAAAAAAAA
AAAABBBAAA
AAAABBBAAA
AAAABBBAAA
AAAAAAAAAA
BBBBBBABBB
BBBBBBAABB
BBBAAAAABB
BBBBBBBBBB
"@,@"
AAAAAAAAAA
AAAA+++AAA
AAAA+B+AAA
AAAA+++AAA
AAAAAAAAAA
++++++A+++
BB++++AA+B
BB+AAAAA+B
BB+++++++B
"@)
) | % {
    $map,$expected = $_
    $result = &$f $map
    $result-eq$expected
    #$result # uncomment this line to display results
}

输出：

True
True
True
— 疯狂的
source
0

Python 2中，123个 119字节

lambda m:[[[c,'+'][c=='B'and'A'in`[x[j-(j>0):j+2]for x in m[i-(i>0):i+2]]`]for j,c in e(l)]for i,l in e(m)];e=enumerate

在线尝试！

I / O是列表列表

— 场
source
0

TSQL，252个字节

拆分字符串非常昂贵，如果拆分字符串并且已经在表中，则字节数将为127个字符。脚本包含在底部并且完全不同。很抱歉占用这么多空间。

打高尔夫球：

WITH C as(SELECT x,x/z r,x%z c,substring(@,x+1,1)v
FROM spt_values CROSS APPLY(SELECT number x,charindex(char(10),@)z)z
WHERE'P'=type)SELECT @=stuff(@,x+1,1,'+')FROM c WHERE
exists(SELECT*FROM c d WHERE abs(r-c.r)<2and
abs(c-c.c)<2and'AB'=v+c.v)PRINT @

取消高尔夫：

DECLARE @ varchar(max)=
'AAAAAAAAAA
ABAAAAAABA
ABBBAABABA
ABBBAABABA
ABBBBABABA
ABBBBABBBB
ABBBBABBBB
ABBBBBBBBB
BBBBBBBBBB';

WITH C as
(
  SELECT x,x/z r,x%z c,substring(@,x+1,1)v
  FROM spt_values
  CROSS APPLY(SELECT number x,charindex(char(10),@)z)z
  WHERE'P'=type
)
SELECT
  @=stuff(@,x+1,1,'+')
FROM c
WHERE exists(SELECT*FROM c d 
         WHERE abs(r-c.r)<2 
           and abs(c-c.c)<2 and'AB'=v+c.v)
PRINT @

试试看

TSQL，127字节（使用表变量作为输入）

在Management Studio中执行此脚本-使用“查询”-“文本结果”使其可读

--populate table variable
USE master
DECLARE @v varchar(max)=
'AAAAAAAAAA
ABAAAAAABA
ABBBAABABA
ABBBAABABA
ABBBBABABA
ABBBBABBBB
ABBBBABBBB
ABBBBBBBBB
BBBBBBBBBB'

DECLARE @ table(x int, r int, c int, v char)

INSERT @
SELECT x+1,x/z,x%z,substring(@v,x+1,1)
FROM spt_values
CROSS APPLY(SELECT number x,charindex(char(10),@v)z)z
WHERE'P'=type and len(@v)>number

-- query(127 characters)

SELECT string_agg(v,'')FROM(SELECT
iif(exists(SELECT*FROM @
WHERE abs(r-c.r)<2and abs(c-c.c)<2and'AB'=v+c.v),'+',v)v
FROM @ c)z

试试看 -警告输出已选择且不可读。可以通过打印读取，但是使用此方法不可能

— 克劳森
source
是什么使您认为您不能将表作为参数？
— 阿达姆（Adám）
@亚当不是一个坏主意，以创建一个使用一个表作为参数的代码，以及-我会马上就可以了
— t-clausen.dk
@Adám我想我错了，为了使脚本能处理120个字符，我需要表和varchar作为输入，但确实重写了它。它花了151个字符
— t-clausen.dk
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.