Erstellen Sie einen Nachschlageindex

12

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
code-golf  string  classification 
— Adam
quelle
Kann ich führende Leerzeichen in der Ausgabe haben?
— Erik der Outgolfer
Muss das Ausgabeformat streng sein?
— Undichte Nonne
@EriktheOutgolfer Ja. Hinzugefügt.
— Adám
@LeakyNun Nr. Hinzugefügt.
— Adám
2
Muss dies für Zeichen funktionieren, die nicht druckbar sind? Gibt es Zeichen, von denen wir annehmen können, dass sie nicht in der Zeichenfolge enthalten sind (insbesondere Leerzeichen)?
— FryAmTheEggman

Antworten:

6

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.

— Kritixi Lithos
quelle
Hm, das braucht eine Erklärung :-)
— Adám
4
@ Adám Ich vermute, diese Herausforderung wurde speziell für APL zugeschnitten
— Uriel
@Uriel Umgekehrt. Ich habe mir angesehen, was APL gut kann, und dachte, dass dies eine gute Herausforderung wäre.
— Adám
Ich sehe dort 4 Bytes.
— Adám
2

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
— Loovjo
quelle
2
Ich glaube nicht, dass ich jemals das für Haskell verwendete Kommentarformat gesehen habe.
— Adám
Ihr inneres Listenverständnis kann auf verkürzt werden [' ':show i|(i,c)<-zip[0..]s,c==x].
— Laikoni
2

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:{1@.Q.s x;} //11 bytes!
k)f"abracadabra"
a| 0 3 5 7 10
b| 1 8
r| 2 9
c| ,4
d| ,6
— Simon Major
quelle
Hm, es gibt ein Wörterbuch zurück. Interessant.
— Adám
0

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
— Emigna
quelle
0

Mathematica, 85 Bytes

Verwenden einer einseitigen Indizierung 

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

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>
Erweitern Sie das Snippet

— Neil
quelle
0

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
— steenbergh
quelle
0

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

— Wunderkricket
quelle
0

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)))));
0

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!

0

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.

— Giuseppe
quelle
0

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.
— Zgarb
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.