Liên quan.

Đưa ra một chuỗi ASCII có thể in, chia nó thành một danh sách các chuỗi không trống với một chuỗi con mới bắt đầu mỗi khi một ký tự, mà trước đây không thấy trong cùng một trường hợp, xảy ra.

Ví dụ

"mississippi" → ["m","i","ssissi","ppi"]

"P P & C G" → ["P"," P ","& ","C ","G"]

"AAA" → ["AAA"]

"Adam" → ["A","d","a","m"]

"" → []

Thạch , 4 byte

QƤĠị

Hãy thử trực tuyến!

Giải trình

QƤĠị  Input is a string, say s = "adam"
 Ƥ    For each prefix of s: ["a","ad","ada","adam"]
Q     remove duplicates: ["a","ad","ad","adm"]
  Ġ   Group indices by equal values: [[1],[2,3],[4]]
   ị  Index into s: ["a","da","m"]

Biểu diễn bên trong của các chuỗi, mà liên kết TIO hiển thị, hơi khác nhau.

Võng mạc , 9 byte

q1,`.
¶$&

Hãy thử trực tuyến!

Giải trình

Khớp từng ký tự ( .), loại bỏ các kết quả khớp lặp lại ( q), loại bỏ kết quả khớp đầu tiên ( 1,) và chèn một nguồn cấp dữ liệu trước mỗi trận đấu ¶$&.

05AB1E , 11 byte

ÙSk¥sg¸«£õK

Hãy thử trực tuyến!

Giải trình

Ù             # remove duplicates in input
 S            # split to a list of characters
  k           # get the (first) index of each character in the input
   ¥          # calculate delta's
    sg¸«      # append the length of the input
        £     # split the list into pieces of these sizes
         õK   # remove empty string (for the special case "" -> [])

C,  75   65  63 byte

Cảm ơn @Digital Trauma vì đã tiết kiệm 10 byte và cảm ơn cả @gastropner và @ l4m2 vì đã tiết kiệm được một byte mỗi byte!

f(char*s){for(int l[128]={};*s;putchar(*s++))l[*s]++||puts(l);}

In một dòng mới hàng đầu.

Hãy thử trực tuyến!

Không có dòng mới hàng đầu (71 byte):

f(char*s){int l[128]={};for(l[*s]=1;*s;putchar(*s++))l[*s]++||puts(l);}

Hãy thử trực tuyến!

Perl 6 ,  58 52  40 byte

{$/={};.comb.classify({$+=!$/{$_}++}).sort».value».join}

Thử nó

*.comb.classify({$+=!(%){$_}++}).sort».value».join

Thử nó

*.classify({$+=!(%){$_}++}).sort».value

Hãy dùng thử
(đầu vào là danh sách các ký tự và đầu ra là danh sách các danh sách các ký tự)

Mở rộng:

*                   # parameter for WhateverCode lambda

  .classify(        # classify that list
    {
        $           # anonymous scalar state variable (accumulator)

      +=            # increment it if:

        !           # Bool invert the following
          (
            %       # anonymous hash state variable
          ){ $_ }++ # look to see if the character was seen already
    }
  ).sort\           # sort the Pairs by key (makes the order correct)
  ».value           # get the value from each Pair

Đầu ra từ classifylà

{ # Hash
  1 => ['m'],
  2 => ['i'],
  3 => ['s','s','i','s','s','i'],
  4 => ['p','p','i'],
}

Và .sortchỉ cần biến nó thành:

[
  1 => ['m'],
  2 => ['i'],
  3 => ['s','s','i','s','s','i'],
  4 => ['p','p','i'],
]

».value loại bỏ các phím

[
  ['m'],
  ['i'],
  ['s','s','i','s','s','i'],
  ['p','p','i'],
]

J , 7 byte

~:<;.1]

Hãy thử trực tuyến!

Giải trình

Cơ hội của Nub sàng để tỏa sáng!

~: <;.1 ]
        ]  Input
~:         Nub sieve (1 if the character is the first instance in string)
    ;.1    Split input on 1s in nub sieve
   <       And box each

APL (Dyalog Unicode) , 8 byte ^SBCS

(≢¨∪\)⊆⊢

Hãy thử trực tuyến!

05AB1E , 8 byte

Ùvyy¶ì.;

Hãy thử trực tuyến!

Luôn luôn xuất 1 dòng mới trước, không đổi và không phải là dấu hiệu phân tách, thay thế 10 byte không xuất ra dòng mới trước đó Ùvyy¶ì.;}¦, bạn có thể thử ở đây . Theo Adam, một dòng mới trước hoặc sau là chấp nhận được.

Input      = mississippi                               | Stack
-----------#-------------------------------------------+----------------------------------
Ù          # Push unique letters of first input.       | ['misp']
 v         # Iterate through each unique letter.       | []
  yy       # Push 2 copies of the letter (or yD)       | ['m','m']
    ¶      # Push a newline char.                      | ['m','m','\n']
     ì     # Prepended to the letter.                  | ['m','\nm']
      .;   # Replace first instance with '\n + letter' | ['\nmississippi']

Sau mỗi lần lặp, chúng tôi nhận được:

['\nmississippi'] > ['\nm\nississippi'] > ['\nm\ni\nssissippi'] > ['\nm\ni\nssissi\nppi']

Đó là:

m
i
ssissi
ppi

Haskell , 39 byte

foldl(\s c->s++['\n'|all(/=c)s]++[c])""

Hãy thử trực tuyến!

Chèn một biểu tượng dòng mới trước mỗi ký tự xuất hiện lần đầu tiên, dẫn đến một chuỗi phân tách dòng mới, với một dòng mới hàng đầu. Chuẩn bị lines.để tạo ra một danh sách.

Haskell , 55 byte

(""%)
_%[]=[]
p%s|(a,b)<-span(`elem`s!!0:p)s=a:(a++p)%b

Hãy thử trực tuyến!

Lặp đi lặp lại lấy tiền tố ký tự đầu tiên cộng với các ký tự không duy nhất theo sau nó.

APL (Dyalog) , 9 byte

Cảm ơn, Erik Outgolfer đã tiết kiệm 1 byte!

⊢⊂⍨⍳∘≢∊⍳⍨

Hãy thử trực tuyến!

Giải trình:

⍳⍨: Đối với mỗi ký tự, hãy lấy chỉ số của lần xuất hiện đầu tiên. ví dụmississippi -> 1 2 3 3 2 3 3 2 9 9 2

⍳∘≢: Phạm vi từ 1 đến chiều dài của đầu vào.

∊: Thành viên. ví dụ1 2 3 4 5 6 7 8 9 10 11∊1 2 3 3 2 3 3 2 9 9 2 -> 1 1 1 0 0 0 0 0 1 0 0

⊢⊂⍨: Phân vùng chuỗi đầu vào với các phân vùng mới bắt đầu từ 1s trong vectơ trên

Japt , 11 byte

‰ r@=iRUbY

Kiểm tra nó trực tuyến!

Giải trình

Điều này đã được lấy cảm hứng từ ma thuật Octopus Urn 's giải pháp 05AB1E .

‰ r@=iRUbY    Implicit: U = input string
‰             Split U into chars, and keep only the first occurrence of each.
   r@          Reduce; for each char Y in this string...
        UbY      Find the first index of Y in U.
      iR         Insert a newline at this index in U.
     =           Set U to the result.
               As reduce returns the result of the last function call, this gives the
               value of U after the final replacement, which is implicitly printed.

JavaScript (ES6), 37 byte

Đã lưu 7 byte: một dòng mới hàng đầu đã được cho phép rõ ràng (Cảm ơn @Shaggy!)

Đưa đầu vào như một mảng các ký tự. Xuất ra một chuỗi phân tách dòng mới.

s=>s.map(c=>s[c]=s[c]?c:`
`+c).join``

Các trường hợp thử nghiệm

let f =

s=>s.map(c=>s[c]=s[c]?c:`
`+c).join``

;[
  [..."mississippi"],
  [..."P P & C G"],
  [..."AAA"],
  [..."Adam"],
  [...""]    
]
.forEach(s => console.log('{' + f(s) + '}\n'))

Brainfuck, 66 byte

,[>+[<[>+<<-<+>>-]>[>]<<[[+]++++++++++.>>>]<]<[>+<-]>>>[>>]<<-.>,]

Định dạng:

,
[
  >+
  [
    <[>+< <-<+>>-]
    >[>]
    <<[[+]++++++++++.>>>]
    <
  ]
  <[>+<-]
  >>>[>>]
  <<-.>,
]

Dùng thử trực tuyến

Dòng mới hàng đầu trong đầu ra (chỉ được in nếu đầu vào không trống) có thể được loại bỏ với chi phí 5 byte bằng cách thay thế phần thân xcủa vòng lặp chính (ngoài cùng) bằng .>,[x].

Thạch , 6 byte

ŒQœṗ⁸Ḋ

Hãy thử trực tuyến!

K4 , 19 byte

Giải pháp:

$[#x;(*:'.=x)_;,]x:

Ví dụ:

q)k)$[#x;(*:'.=x)_;,]x:"mississippi"
,"m"
,"i"
"ssissi"
"ppi"
q)k)$[#x;(*:'.=x)_;,]x:"P P & C G"
,"P"
" P "
"& "
"C "
,"G"
q)k)$[#x;(*:'.=x)_;,]x:"AAA"
"AAA"
q)k)$[#x;(*:'.=x)_;,]x:"Adam"
,"A"
,"d"
,"a"
,"m"
q)k)$[#x;(*:'.=x)_;,]x:""
,[""]

Giải trình:

8 byte chỉ để xử lý ""...

$[#x;(*:'.=x)_;,]x: / the solution
                 x: / save input as variable x
$[  ;         ; ]   / $[condition;true;false]
  #x                / length of x ("" has length 0, i.e. false)
             _      / cut right at left indices
     (      )       / do together
          =x        / group x into key/value (char!indices)
         .          / return value (get indices)
      *:'           / first (*:) each
               ,    / enlist, "" => [""]

Python 2 , 81 74 byte

def f(s):d=sorted(map(s.find,set(s)));print map(lambda a,b:s[a:b],d,d[1:])

Hãy thử trực tuyến!

Python 2 , 47 byte

lambda s:reduce(lambda r,c:r+'\n'[c in r:]+c,s)

Hãy thử trực tuyến!

Xuất ra một chuỗi phân tách dòng mới. Hoàn toàn đánh bại phiên bản chương trình:

Python 2 , 48 byte

r=''
for c in input():r+='\n'[c in r:]+c
print r

Hãy thử trực tuyến!

Perl, 30 byte

Bao gồm +1chop

Cung cấp đầu vào mà không theo dõi dòng mới trên STDIN. Đầu ra cũng không có dòng mới:

echo -n adam | perl -pE 's%.%$v{$&}+++!pos?$&:$/.$&%eg'; echo

Nếu bạn không quan tâm đến ở đầu và đuôi dòng mới này 25( +3cho -pvì mã chứa ') cũng làm việc:

#!/usr/bin/perl -p
s%%$/x!$v{$'&~v0}++%eg

JavaScript, 61 54 52 byte

Đưa đầu vào như một mảng các ký tự.

s=>s.map(x=>a[x]?a[y]+=x:a[x]=a[++y]=x,a=[],y=-1)&&a

Thử nó

o.innerText=JSON.stringify((f=
s=>s.map(x=>a[x]?a[y]+=x:a[x]=a[++y]=x,a=[],y=-1)&&a
)([...i.value=""]));oninput=_=>o.innerText=JSON.stringify(f([...i.value]))

<input id=i><pre id=o></pre>

R , 94 87 byte

function(s,n=nchar(s),g=substring)g(s,d<-which(!duplicated(g(s,1:n,1:n))),c(d[-1]-1,n))

Hãy thử trực tuyến!

Trả về một danh sách (có thể trống) của các chuỗi con.

Cảm ơn Michael M vì đã tiết kiệm 7 byte!

Stax , 8 byte

ç↓‼►▐NVh

Chạy và gỡ lỗi trực tuyến

Đại diện ascii của cùng một chương trình là đây.

c{[Ii=}(m

Đối với mỗi ký tự, nó sẽ phân chia khi chỉ mục của ký tự hiện tại là vị trí hiện tại.

c            copy the input
 {    }(     split the string when the result of the enclosed block is truthy
  [          duplicate the input string under the top of the stack
   I         get the character index of the current character
    i=       is it equal to the iteration index?
        m    print each substring

> <> , 22 17 14 byte

-1 byte nhờ Emigna

i:::a$1g?!o1po

Hãy thử trực tuyến!

In một dòng mới hàng đầu và dấu.

Nó theo dõi những chữ cái nào đã xuất hiện bằng cách pđặt một bản sao của ký tự ở vị trí tương ứng trên hàng thứ hai và in một dòng mới nếu giá trị được tìm nạp từ vị trí đó không phải là 1. Kết thúc lỗi khi nó cố in-1

Haskell, 62 byte

r#c|any(elem c)r=init r++[last r++[c]]|1<2=r++[[c]]
foldl(#)[]

Hãy thử trực tuyến!

JavaScript (ES6), 68 byte

s=>s.map(c=>o[c]?t+=c:(t&&m.push(t),t=o[c]=c),t='',o=m=[])&&[...m,t]

Đưa đầu vào dưới dạng danh sách các ký tự.

Các trường hợp thử nghiệm:

let f=
s=>s.map(c=>o[c]?t+=c:(t&&m.push(t),t=o[c]=c),t='',o=m=[])&&[...m,t]

console.log(f([...'mississippi']));
console.log(f([...'P P & C G']));
console.log(f([...'AAA']));
console.log(f([...'Adam']));
console.log(f([...'']));

PHP, 317 byte

function SplitOnFirstUnique($s){
    $len = strlen($s); 
    $output = [];
    $newstring = '';
    for ($i=0; $i < $len ; $i++) { 
        $newstring = $newstring.$s[$i];
        if(!in_array($s[$i] , $output  )){
            $output[] = $newstring;
            $newstring = '';
        }
    }
    return $output;
}

Hãy thử trực tuyến!

Đỏ , 79 byte

func[s][foreach c next unique/case append s"^@"[print copy/part s s: find s c]]

Hãy thử trực tuyến!

Ung dung:

f: func [s] [
    b: next unique/case append s "^@"  ; append `null` to the end of the string, than
                                       ; find the unique characters and 
                                       ; store all except the first to b  
    foreach c b [                      ; for each character in b
        print copy/part s s: find s c  ; print the part of the string to
                                       ; where the character is found and
                                       ; set the beginning of the string to that position
    ]
] 

SNOBOL4 (CSNOBOL4) , 115 91 77 byte

	N =INPUT
S	N LEN(1) . Y	:F(END)
	S =S Y
	N SPAN(S) . OUTPUT REM . N	:(S)
END

Hãy thử trực tuyến!

In các chuỗi con được phân tách bằng dòng mới.

Giải trình:

dòng S(for SPLIT) không thực sự phân tách, mà thay vào đó trích xuất ký tự đầu tiên của Nvà lưu nó ( .) vào Y. Trên Failure, nó nhảy đến END. Trận đấu chỉ nên thất bại khi Nchuỗi trống. Vì vậy, khi đầu vào trống, nó nhảy trực tiếp ENDvà không xuất ra gì.

S = S Ynối Yvào S.

SPAN(S)tham lam khớp với một chuỗi các ký tự trong Svà gửi nó ( .) đến OUTPUT, đặt ( .) Ncho các REMký tự aining của N(nếu có). Sau đó, nó nhảy trở lại S.

PowerShell, 73 byte

{$r=@();$h=@{};[char[]]$ARGS[0]|%{if(!($h[$_]++)){$r+=""};$r[-1]+=$_};$r}

Sử dụng

PS> & {$r=@();$h=@{};[char[]]$ARGS[0]|%{if(!($h[$_]++)){$r+=""};$r[-1]+=$_};$r} "mississipi" | ConvertTo-Json -Compress
["m","i","ssissi","pi"]

Ruby , 65 62 58 byte

->s,*a{s.size.times{|i|(i==s.index(c=s[i])?a:a[-1])<<c}
a}

Hãy thử trực tuyến!

Một lambda chấp nhận một chuỗi và trả về một chuỗi các chuỗi.

Cách tiếp cận: Đối với mỗi chỉ mục, hãy thêm ký tự tại chỉ mục đó vào smảng kết quả hoặc vào chuỗi cuối cùng trong mảng kết quả. String#indextrả về chỉ mục của phiên bản đầu tiên của đối số.

-2 byte: Khởi tạo anhư một đối số splat thay vì trên dòng riêng của nó. Cảm ơn, giá trị mực !

-1 byte: Sử dụng c=s[i]... cthay vì s[i]... s[i]. Cảm ơn, giá trị mực !

-4 byte: Sử dụng .timesthay vì.map

Java 8, 193 169 155 151 byte

s->{for(int l=s.length(),i=0,j;i<l;i++)if(s.indexOf(s.charAt(i))==i){for(j=i;++j<l&&s.indexOf(s.charAt(j))!=j;);System.out.println(s.substring(i,j));}}

-14 byte nhờ @raznagul (vì điều gì đó rõ ràng tôi bằng cách nào đó đã bỏ lỡ bản thân mình ..)
-3 byte nhờ @OOBalance (một lần nữa vì điều gì đó rõ ràng tôi bằng cách nào đó đã bỏ lỡ chính mình ..: S)

Giải trình:

Hãy thử trực tuyến.

s->{                    // Method with String parameter and no return-type
  for(int l=s.length(), //  The length of the input-String
          i=0,j;        //  Index integers
      i<l;i++)          //  Loop `i` from 0 to `l` (exclusive)
    if(s.indexOf(s.charAt(i))==i){
                        //   If the character at index `i` hasn't occurred yet:
      for(j=i;++j<l     //    Inner loop `j` from `i` to `l` (exclusive),
          &&s.indexOf(s.charAt(j))!=j;);
                        //     as long as the character at index `j` has already occurred
      System.out.println(//    Print:
        s.substring(i,j));}}
                        //     The substring of the input from index `i` to `j` (exclusive)