Geben Sie bei einer gegebenen Zeichenfolge eine Tabelle zurück, in der die ersten Spalten die eindeutigen Buchstaben der Zeichenfolge in der Reihenfolge ihres Auftretens enthalten. In den nachfolgenden Spalten werden die Indizes dieses Buchstabens in der Zeichenfolge mit einer auf Null oder Eins basierenden Indizierung aufgelistet. Horizontale Leerzeichen spielen keine Rolle, solange die Spalte ganz links vertikal ausgerichtet ist. Die Indizes müssen von links nach rechts aufsteigend sortiert sein.

Beispiele

Verwenden Sie die nullbasierte Indizierung und geben Sie "abracadabra" zurück

a 0 3 5 7 10
b 1 8       
r 2 9       
c 4         
d 6   

Wenn Sie eine einseitige Indizierung verwenden und "3141592653589793238462643383279503" angeben, geben Sie Folgendes zurück:

3  1 10 16 18 25 26 28 34
1  2  4                  
4  3 20 24               
5  5  9 11 32            
9  6 13 15 31            
2  7 17 22 29            
6  8 21 23               
8 12 19 27               
7 14 30                  
0 33                     

APL (Dyalog) , 4 Bytes

,⌸

Probieren Sie es online!

( ⌸ist 3 Bytes)

Verwendet 1-basierte Indizierung.

⌸ist der Key Operator. Hier verhält es sich wie ein monadischer Operator. Es wendet die Funktion ,, das linke Argument mit dem rechten Argument zu verketten, auf jedes eindeutige Element in seinem rechten Argument und auf die Indizes dieses eindeutigen Elements im ursprünglichen Argument an.

Haskell , 86 Bytes

import Data.List
f s=unlines[x:concat[' ':show i|i<-[0..length s-1],s!!i==x]|x<-nub s]

Definiert eine Funktion, fdie einen String mit dieser Ausgabe zurückgibt.

Probieren Sie es online!

Wie?

import Data.List                                                            -- Imports Data.List. This contains the nub method which is necessary
f s =                                                                       -- Define a function, f, which takes one argument, s
            [                                               |x<-nub s]      -- Loop through nub s with the variable x. Nub removes duplicates from a list, in this case the input.
                     [          |i<-[0..length s-1]        ]                -- Go thourgh the list [0,1,2...] until the length of the input - 1. Basically a indexed for-loop
                                                   ,s!!i==x                 -- Filter out everything where the char at this index isn't x
                      ' ':show i                                            -- i as a string with a space before it
               concat                                                       -- Flatten the whole list
             x:                                                             -- Append x before it
     unlines                                                                -- Insert newlines between every element in the list and flatten it, effectively putting every element on it's own line

kdb + / q , 5 Bytes

group

Builtins sind fabelhaft

q)group"abracadabra"
a| 0 3 5 7 10
b| 1 8
r| 2 9
c| ,4
d| ,6

Normalerweise spiele ich Golf in k , aber die 2-Byte-k-Version ( =:) formatiert die Ausgabe nicht gut

k)=:"abracadabra"
"abrcd"!(0 3 5 7 10;1 8;2 9;,4;,6)

Die Ergebnisse sind exakt gleich, aber die Formatierung geht verloren. Um das Rückgabeobjekt zu formatieren und zu entfernen, nehmen wir tatsächlich mehr Bytes auf als die q-Version

k)f:{[email protected] x;} //11 bytes!
k)f"abracadabra"
a| 0 3 5 7 10
b| 1 8
r| 2 9
c| ,4
d| ,6

Python, 96 Bytes

def f(s,r=[]):
 for c in s:
  if c not in r:print(c,*(i for i,l in enumerate(s) if l==c));r+=[c]

versuche es online!

MATL , 11 Bytes

u"@0hG@=fVh

Ausgabeindizes basieren auf 1.

Probieren Sie es online!

Pyth , 13 Bytes

jmj;+dxCdCMQ{

Probieren Sie es online!

Gelee , 7 Bytes

Q;"ĠṢ$G

Probieren Sie es online!

05AB1E , 14 Bytes

ÙvSyQƶ0Ky¸ìðý,

Probieren Sie es online!

Erläuterung

Ùv              # for each unique char y in input
  S             # split input into a list of chars
   yQ           # compare each to y for equality
     ƶ          # multiply each by its 1-based index
      0K        # remove zeroes
        y¸ì     # prepend y to the list of indices
           ðý,  # join by spaces and print

Mathematica, 85 Bytes

Verwenden einer einseitigen Indizierung

(t=#;j=First/@t~StringPosition~#&/@(s=First/@Tally@Characters@t);Row[Column/@{s,j}])&

JavaScript (ES Draft), 77 Byte

s=>s.replace(/./g,(c,i)=>a[c]=(a[c]||c)+` `+i,a={})&&Object.values(a).join`
`

88 Bytes in älteren Browsern:

f=
s=>s.replace(/./g,(c,i)=>a[c]=(a[c]||c)+` `+i,a={})&&Object.keys(a).map(c=>a[c]).join`
`

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

PHP , 82 Bytes

for(;~$c=$argn[$i];)$r[$c].=str_pad(++$i,5," ",0);foreach($r as$k=>$v)echo"$k$v
";

Probieren Sie es online!

QBIC , 95 Bytes

dim X(126)[_l;||i=asc(_sA,a,1|)┘X(i)=X(i)+@ `+!a$][_lA||_SA,b,1|i=asc(C)~X(i)<>D|?C,X(i)┘X(i)=@

Erläuterung

Dies kopiert wesentliche Teile meiner Antwort auf diese Herausforderung :

dim x(126)      Create an array of 126 elements (one for each ASCII element)
[_l;||          Read cmd line input, loop over its length
i=asc(_sA,a,1|) Read the next char's ascii value
┘               (Syntactic linebreak)
X(i)=           Set the value for this ascii-codepoint to
 X(i)             everything we've put in before
 +@ `             and a literal space
 +!a$             and the current (1-based) index cast as string
 ]              close the FOR loop
 [_lA||         Loop over the original string again (to preserve order of appearance)
 _SA,b,1|       Read 1 char, assign to C$ (note the capital S in the function call,
                this auto-creates C$ abd assigns it the value of the substring-call)
 i=asc(C)       Get the index in our storage array from C$'s ascii value
 ~X(i)<>D       IF the storage array holds data for i (<> D$, which we'll set to "" in a second), 
 |?C,X(i)       THEN PRINT the character, followed by the indices saved for this char
 ┘              (Syntactic linebreak)
 X(i)=@         Clear out the data stored for C$
                @ declares a string lit, ` would close it and that gets auto-added at EOF, 
                creating the literal @`, which gets assigned to D$

Probelauf:

Command line: abracadabra
a              1 4 6 8 11
b              2 9
r              3 10
c              5
d              7

C (klirrend) , 176 Bytes

G(S,V,c,g,i,H,L)char*S,*V;{for(V=malloc(8),H=strlen(S),c=g=-1;++g<H;){if(strchr(V,L=S[g]))continue;printf("%c ",V[c++]=L);for(i=-1;++i<H;printf(S[i]==L?"%d ":"",i));puts("");}}

Natürlich ist dies die längste Antwort hier ...

Probieren Sie es online!

Python 3, 111 106 Bytes

def q(f):
 d={a:[]for a in f}
 for a,b in enumerate(f):d[b]+=[a]
 [print(p,*d.pop(p))for p in f if p in d]

repl.it

C # , 138 Bytes

using System.Linq;s=>Console.Write(string.Join("\n",s.Distinct().Select(c=>c+string.Join("",s.Select((d,i)=>d==c?i:-1).Where(i=>i>-1)))));

F # , 120 Bytes

let f s=s|>Seq.indexed|>Seq.groupBy(fun(a,b)->b)|>Seq.iter(fun(a,b)->
 printf"\n%c"a 
 Seq.iter(fun(c,_)->printf"%i"c)b)

Eine lesbarere Version:

let f s =
    s
    |> Seq.indexed
    |> Seq.groupBy (fun (idx, char) -> char)
    |> Seq.iter (fun (char, charIdxSeq) ->
         printf "\n%c" char 
         Seq.iter (fun (idx, _) -> printf "%i" idx) charIdxSeq)

Seq.indexed Erstellt eine neue Sequenz mit Tupeln, die aus dem ursprünglichen Element und dem auf 0 basierenden Index in der ursprünglichen Sequenz bestehen.

Der Rest ist ziemlich selbsterklärend, was für das Golfen nie gut ist!

R , 80 77 Bytes

function(s)for(i in (z=unique(s<-strsplit(s,'')[[1]])))cat(i,which(s==i),"
")

Probieren Sie es online!

eine anonyme Funktion; druckt das Ergebnis 1-indiziert mit einer nachfolgenden Newline.

J , 11 Bytes

~.,.":@I.@=

Probieren Sie es online!

Schale , 10 Bytes

§mȯ§:;ms¥u

Probieren Sie es online!

Hinweis: Husk (oder zumindest der Befehl ¥) ist neuer als diese Herausforderung.

Erläuterung

§mȯ§:;ms¥u  Implicit input, say S = "ababbc".
         u  Remove duplicates: "abc"
§m          Map over this string:
             Argument is a character, say 'b'.
        ¥    1-based indices in S: [2,4,5]
      ms     Convert each to string: ["2","4","5"]
     ;       Wrap argument in a string: "b"
  ȯ§:        Prepend to list of index strings: ["b","2","4","5"]
            Result is a list of lists of strings
             [["a","1","3"],["b","2","4","5"],["c","6"]]
            Implicitly print, separating strings by spaces and lists by newlines.