介绍

因此，我一直在浪费时间来研究后缀排序算法，以手工和代码方式评估新的想法。但是我总是很难记住后缀的类型！能告诉我我的后缀是哪种类型？

最左边是什么？

许多后缀排序算法（SAIS，KA，我自己的daware）将后缀分为不同的类型，以便对其进行排序。有两种基本类型：S型和L型后缀。S型后缀是字典顺序以下（后缀小号比下面后缀和小光伏）L型，如果它是按字典顺序更大（大号 arger）。甲最左边的S型（LMS型）就是：甲S型，其由preceeded后缀L型后缀。

这些LMS类型后缀的特殊之处在于，一旦我们对它们进行了排序，就可以在线性时间内对所有其他后缀进行排序！那不是很棒吗？

挑战

给定一个字符串，假定它以小于该字符串中任何其他字符的特殊字符终止（例如，甚至小于空字节）。为每个后缀输出对应的char类型。

您可以自由选择使用哪种类型的字符哪个，但我更喜欢L, S and *的L-, S- and LMS-type，只要它们是所有可打印的（0x20 - 0x7E）。

例

给定字符串mmiissiissiippi输出（使用时L, S and *）：

 LL*SLL*SLL*SLLL

例如，第一个L是由于在mmiissiissiippi$字典上大于miissiissiippi$（$代表所添加的最小字符）的事实：

L - mmiissiissiippi$ > miissiissiippi$
L - miissiissiippi$  > iissiissiippi$
* - iissiissiippi$   < issiissiippi     and preceeded by L
S - issiissiippi$    < ssiissiippi$
L - ssiissiippi$     > siissiippi$
L - siissiippi$      > iissiippi$
* - iissiippi$       < issiippi$        and preceeded by L
S - issiippi$        < ssiippi$
L - ssiippi$         > siippi$
L - siippi$          > iippi$
* - iippi$           < ippi$            and preceeded by L
S - ippi$            < ppi$
L - ppi$             > pi$
L - pi$              > i$
L - i$               > $

其他示例：

"hello world" -> "L*SSL*L*LLL"
"Hello World" -> "SSSSL*SSLLL"
"53Ab§%5qS"   -> "L*SSL*SLL"

目标

我不是来惹恼Peter Cordes的（我有一段时间会在stackoverflow上这样做）；我很懒，所以这当然是代码高尔夫！以字节为单位的最短答案将获胜。

编辑：字符的顺序由其字节值给出。这意味着比较应该像C一样strcmp。

Edit2：如注释中所述，每个输入字符应为单个字符。虽然我认为这可以理解为“返回字符串”，但似乎至少有1个答案会返回单个字符的列表。为了不使现有答案无效，我将允许您返回一个单字符列表（或打印时仅产生1个字符的整数）。

线性时间提示：

1. 它可以在2个并行的正向迭代中或单个向后的迭代中完成。
2. 每个后缀的状态仅取决于前两个字符和第二个字符的类型。
3. 反向扫描输入，您可以像这样确定L或S：$t=$c<=>$d?:$t（PHP 7），$c当前字符$d是前一个和$t前一个类型。
4. 看到我的PHP答案。明天我将颁发赏金。

Haskell，64 53 48 42字节

(0!)
k!(x:y)|x:y>y=1:2!y|2>1=k:0!y
_![]=[]

在线尝试！

取消高尔夫，使用Char代替Int：

suffixes :: String -> String
suffixes = go 'S'
 where
   go :: Char -> String -> String
   go _ "" = ""
   go lorstar s | s > tail s = 'L' : go '*' (tail s)
                | otherwise  = lorstar : go 'S' (tail s)

果冻， 25 23 21 20  19 字节

Ṛ;\UỤỤIṠµI2n×ịØDṚ;0

使用以下命令打印字符列表的完整程序：

L: 0
S: 8
*: 9

（作为链接，它返回一个列表，其中所有项目都是除最后一个零（零）之外的字符。）

在线尝试！或查看测试套件（转换为LS*）。

怎么样？

Ṛ;\UỤỤIṠµI2n×ịØDṚ;0 - Link: list of characters, s  e.g. "cast"
Ṛ                   - reverse                           "tsac"
  \                 - cumulative reduce by:
 ;                  -   concatenation                   ["t","ts","tsa","tsac"]
   U                - upend (reverse each)              ["t","st","ast","cast"] (suffixes)
    Ụ               - sort indexes by value             [3,4,2,1] (lexicographical order)
     Ụ              - sort indexes by value             [4,3,1,2] (order of that)
      I             - incremental differences           [-1,-2,1] (change)
       Ṡ            - sign                              [-1,-1,1] (comparisons)
        µ           - monadic chain separation, call that x
         I          - incremental differences           [0,2] (only (-1,1) produce 2s)
          2         - literal 2                         2
           n        - not equal?                        [1,0] (indexes of * will be 0)
            ×       - multiply by x (vectorises)        [-1,0,1] (make indexes of *s 0)
              ØD    - decimal yield                     "0123456789"
             ị      - index into (1-indexed & modular)  ['8','9','0']
                Ṛ   - reverse                           ['0','9','8']
                 ;0 - concatenate a zero                ['0','9','8',0]
                    - implicit print                     0980
                    -                              i.e. "L*SL"

Python 3，92 87 74 69 65字节

s=input()
c=1
while s:d=s<s[1:];print(d+(c<d),end='');s=s[1:];c=d

用途0为L，1对S，和2为*。将输入字符串用引号引起来；我相信这是惯例所允许的。

在线尝试！

使用示例：

mmiissiissiippi
002100210021000

Leaky Nun节省了5个字节，ovs节省了4个字节

JavaScript（ES6），51 45字节

f=(c,d)=>c&&(d<(d=c<(c=c.slice(1))))+d+f(c,d)

@Neil节省了6个字节。

该练习的递归解决方案。

f=(c,d)=>c&&(d<(d=c<(c=c.slice(1))))+d+f(c,d)

console.log(f('mmiissiissiippi')); //LL*SLL*SLL*SLLL   002100210021000
console.log(f('hello world'));     //L*SSL*L*LLL       02110202000
console.log(f('Hello World'));     //SSSSL*SSLLL       11110211000
console.log(f('53Ab§%5qS'));       //L*SSL*SLL         021102100

JavaScript（ES6），52个字节

f=
s=>s.replace(/./g,_=>(c<(c=s<(s=s.slice(1))))+c,c=1)

<input oninput=o.textContent=f(this.value)><pre id=o>

@ L3viathan的答案的端口。

C（clang），88个字节

S(S,A,I)char*S,*A;{for(;strlen(S);A=S,S++,printf("%c",I=strcmp(A,S)>0?76:I==76?42:83));}

在线尝试！

Haskell，77 75字节，线性时间

f(a:b:c)|let g"L"|a<b="SL";g"S"|a>b="L*";g d=d++d;d:e=f$b:c=g[d]++e
f _="L"

在线尝试！

怎么运行的

这使用递归，从字符串的开头一次剥离一个字符。（Haskell字符串类型是一个单链接字符列表，因此每个步骤都是固定时间。）

• 对于字符串abc，其中a和b是单个字符，而c是任何（可能为空）字符串，
  • 如果f（bc）= L e并且a < b ; f（abc）= SL e ;
  • 如果f（bc）= S e且a > b ; f（abc）= L * e ;
  • ˚F（ABC）= LL È，如果˚F（BC）= L Ë和一个 ≥ b ;
  • ˚F（ABC）= SS È，如果˚F（BC）= S Ë和一个 ≤ b。
• 对于单字符字符串a，f（a）=L。

Python 2中，65 55个字节

递归版本，基于L3viathan的answer，012用作LS*：

def g(s,d=2):c=s<s[1:];return s and`c+(d<c)`+g(s[1:],c)

在线尝试！

Python 3中，65 59个字节

递归的解决方案使用L，S以及*：

f=lambda s:s and('LS'[s<s[1:]]+f(s[1:])).replace('LS','L*')

贯穿从前面的字符串，并且替换的所有实例LS与L*

在线尝试！

PHP，82字节，线性时间

for($a=$argn;a&$c=$a[$i-=1];$d=$c)$a[$i]=2+$t=$d<=>$c?:$t;echo strtr($a,[13=>12]);

从右到左遍历输入，并用类型替换每个字符。

$t=$d<=>$c?:$t

计算给定当前字符和上一个字符（-1或1）的类型。如果相等，则类型不变。

PHP，70字节

L = 1，S = 0，* = 2

多字节支持需要最后测试用例与§+3字节mb_substr，而不是substr

for(;$s=&$argn;$s=$u)$r.=$l=($l&1)+(1&$l^($s>$u=substr($s,1)));echo$r;

在线尝试！

PHP，71字节

L = 1，S = 0，* = 2

for(;$s=&$argn;$s=$u)$r.=+($s>$u=substr($s,1));echo strtr($r,[10=>12]);

在线尝试！

PHP，74字节

for(;$s=&$argn;$s=$u)$r.=SL[$s>$u=substr($s,1)];echo strtr($r,[LS=>"L*"]);

在线尝试！