Étant donné une chaîne, renvoyez une table dans laquelle la première colonne a les lettres uniques de la chaîne par ordre d'occurrence et les colonnes suivantes répertorient les indices de cette lettre dans la chaîne, en utilisant une indexation zéro ou une. L'espace horizontal n'a pas d'importance, tant que la colonne la plus à gauche est alignée verticalement. Les indices doivent être en ordre croissant de gauche à droite.

Exemples

En utilisant l'indexation de base zéro et étant donné "abracadabra", retournez

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

En utilisant l'indexation à base unique et en indiquant "3141592653589793238462643383279503", retournez:

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 octets

,⌸

Essayez-le en ligne!

( ⌸est de 3 octets)

Utilise l'indexation basée sur 1.

⌸est l'opérateur clé. Ici, il se comporte comme un opérateur monadique. Il applique la fonction ,, concatène l'argument de gauche avec l'argument de droite, à chaque élément unique dans son argument de droite et les indices de cet élément unique dans l'argument d'origine.

Haskell , 86 octets

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

Définit une fonction, fqui renvoie une chaîne contenant cette sortie.

Essayez-le en ligne!

Comment?

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 octets

group

Les bâtis sont fabuleux

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

Je joue généralement au golf en k , mais la version k à 2 octets ( =:) ne formate pas bien la sortie

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

Les résultats sont exactement les mêmes, mais la mise en forme est perdue. Pour formater et supprimer l'objet de retour, nous prenons en fait plus d'octets que la version q

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 octets

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]

essayez-le en ligne!

MATL , 11 octets

u"@0hG@=fVh

Les indices de sortie sont basés sur 1.

Essayez-le en ligne!

Pyth , 13 octets

jmj;+dxCdCMQ{

Essayez-le en ligne!

Gelée , 7 octets

Q;"ĠṢ$G

Essayez-le en ligne!

05AB1E , 14 octets

ÙvSyQƶ0Ky¸ìðý,

Essayez-le en ligne!

Explication

Ù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 octets

à l'aide d'une indexation à base unique

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

JavaScript (ES Draft), 77 octets

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

88 octets dans les anciens navigateurs:

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 octets

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

Essayez-le en ligne!

QBIC , 95 octets

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)=@

Explication

Cela copie des parties importantes de ma réponse à ce défi :

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$

Exemple d'exécution:

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

C (clang) , 176 octets

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("");}}

Bien sûr, c'est la réponse la plus longue ici ...

Essayez-le en ligne!

Python 3, 111 106 octets

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 octets

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 octets

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)

Une version plus lisible:

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 crée une nouvelle séquence contenant des tuples composés de l'élément d'origine et de son index basé sur 0 dans la séquence d'origine.

Le reste est assez explicite, ce qui n'est jamais une bonne chose pour le golf!

R , 80 77 octets

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

Essayez-le en ligne!

une fonction anonyme; imprime le résultat indexé 1 avec une nouvelle ligne de fin.

J , 11 octets

~.,.":@I.@=

Essayez-le en ligne!

Husk , 10 octets

§mȯ§:;ms¥u

Essayez-le en ligne!

Remarque: Husk (ou au moins la commande ¥) est plus récent que ce défi.

Explication

§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.