조회 색인 만들기


12

문자열이 주어지면 첫 번째 열에 고유 한 문자열 문자가 나타나는 순서대로 표를 반환하고 후속 열에는 0 또는 1 기반 색인을 사용하여 문자열에서 해당 문자의 인덱스를 나열합니다. 가장 왼쪽 열이 세로로 정렬되어 있으면 가로 공백은 중요하지 않습니다. 인덱스는 왼쪽에서 오른쪽으로 오름차순이어야합니다.

0부터 시작하는 색인화 및 "abracadabra"를 사용하여 반환

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

1부터 시작하여 "3141592653589793238462643383279503"을 지정하면 다음을 반환합니다.

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                     

출력에 선행 공백을 사용할 수 있습니까?
아웃 골퍼 에릭

출력 형식이 엄격해야합니까?
Leaky Nun

@EriktheOutgolfer 예. 추가되었습니다.
Adám

@LeakyNun 번호가 추가되었습니다.
Adám

2
ASCII로 인쇄 할 수없는 문자에 대해이 작업이 필요합니까? 문자열에 포함되지 않을 것으로 예상되는 문자가 있습니까 (특히 공백)?
FryAmTheEggman 2016 년

답변:


6

APL (Dyalog) , 4 바이트

,⌸

온라인으로 사용해보십시오!

( 3 바이트입니다)

1 기반 인덱싱을 사용합니다.

핵심 연산자입니다. 여기서는 모나드 연산자로 작동합니다. ,왼쪽 인수와 오른쪽 인수를 연결 하는 함수를 오른쪽 인수의 각 고유 요소와 원래 인수의 고유 요소 색인에 적용합니다.


흠, 이것은 설명이 필요합니다 :-)
Adám

4
@ Adám 나는이 도전이 APL을 위해 특별히 맞춰 졌다고 생각합니다.
Uriel

@Uriel 다른 방법. 나는 APL이 깔끔하게 할 수있는 것을보고 있었고, 이것이 좋은 도전이 될 것이라고 생각했다.
Adám

거기에 4 바이트가 있습니다.
Adám

2

하스켈 , 86 바이트

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

f이 출력을 포함하는 문자열을 반환 하는 함수를 정의합니다 .

온라인으로 사용해보십시오!

어떻게?

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

2
필자는 Haskell에 사용되는 주석 형식을 본 적이 없다고 생각합니다.
Adám

귀하의 내부 목록 이해가로 단축 될 수 있습니다 [' ':show i|(i,c)<-zip[0..]s,c==x].
Laikoni 2016 년

2

kdb + / q , 5 바이트

group

내장은 팹

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

나는 보통 k로 골프를 =:치지 만 2 바이트 k 버전 ( )은 출력을 멋지게 형식화하지 않습니다.

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

결과는 정확히 동일하지만 서식이 손실됩니다. 반환 객체를 포맷하고 제거하기 위해 실제로 q 버전보다 많은 바이트를 선택합니다.

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

흠, 그것은 사전을 반환합니다. 흥미 롭군
Adám





0

05AB1E , 14 바이트

ÙvSyQƶ0Ky¸ìðý,

온라인으로 사용해보십시오!

설명

Ù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

0

Mathematica, 85 바이트

1 기반 색인 사용

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

0

자바 스크립트 (ES 초안), 77 바이트

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

구형 브라우저에서 88 바이트 :

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>



0

QBIC , 95 바이트

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

설명

이것은 이 도전에 대한 내 대답 의 상당 부분을 복사합니다 .

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$

샘플 실행 :

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


0

파이썬 3, 111106 바이트

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]

반복


0

C # , 138 바이트

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 바이트

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)

더 읽기 쉬운 버전 :

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 원래 요소로 구성된 튜플을 포함하는 새 시퀀스를 만들고 원래 시퀀스의 0 기반 인덱스입니다.

나머지는 골프에 대해 결코 좋은 일이 아닙니다.




0

껍질 , 10 바이트

§mȯ§:;ms¥u

온라인으로 사용해보십시오!

참고 : Husk (또는 최소한 command ¥)는이 문제보다 최신입니다.

설명

§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.
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.