挑战

编写一个非空程序/函数p，给定一个非空输入字符串s，该程序/函数输出的源代码中的每个字符第一次出现的位置。sp

例如，如果您的程序是

main() { cout << magic << cin }
^0   ^5   ^10  ^15  ^20  ^25

它收到一个输入abcd{，输出应该是

[1, x, 9, x, 7] (0-based)        [2, x, 10, x, 8] (1-based)

在此，x表示任何不是字符位置有效输出的输出（例如，负数，0如果您使用基于1的索引，则NaN，Inf字符串potato，大于程序长度的数字等）。

限制条件

不允许读取源代码（如适当的quine）。允许使用评论，但会计入您的分数。

输入和输出可以在一个合理的形式进行，但必须是明确的（唯一的额外分隔符，没有rand流，并声称，答案是在那里的地方），一致（例如，x从上面应该始终是相同的值）和人-可读性 ; 例如字符串或字符数组。您可以假设输入是可打印ASCII字符的字符串（或数组）；无需处理整个Unicode集。

自定义代码页或代码中不可打印的ASCII？

如果您的语言使用自定义代码页（Jelly，APL等），则必须将其考虑在内（因此，程序€æÆ必须[1, x, 2]为input输出€%æ）。仅使用非ASCII字符-1始终输出（因为输入仅是ASCII）不是有效的解决方案。您可以假定您的程序本机接受您的自定义代码页，即，如果您的程序具有将字符转换为A整数65（ASCII编码）的方法，则可以假定它现在将代码页中的第65个字符转换为65。

受到以下挑战的启发：位置意识

Python2，55字节

a=" )dfi(+m,nprut.';";print map(('a="'+a).find,input())

以包含代码中使用的所有字符的字符串开头，然后搜索索引

语言，56,623字节

以下是前256个字节的十六进制转储。其余字节可以任意选择。

0000000: 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f  ................
0000010: 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f  ................
0000020: 20 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f   !"#$%&'()*+,-./
0000030: 30 31 32 33 34 35 36 37 38 39 3a 3b 3c 3d 3e 3f  0123456789:;<=>?
0000040: 40 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f  @ABCDEFGHIJKLMNO
0000050: 50 51 52 53 54 55 56 57 58 59 5a 5b 5c 5d 5e 5f  PQRSTUVWXYZ[\]^_
0000060: 60 61 62 63 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f  `abcdefghijklmno
0000070: 70 71 72 73 74 75 76 77 78 79 7a 7b 7c 7d 7e 7f  pqrstuvwxyz{|}~.
0000080: 80 81 82 83 84 85 86 87 88 89 8a 8b 8c 8d 8e 8f  ................
0000090: 90 91 92 93 94 95 96 97 98 99 9a 9b 9c 9d 9e 9f  ................
00000a0: a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 aa ab ac ad ae af  ................
00000b0: b0 b1 b2 b3 b4 b5 b6 b7 b8 b9 ba bb bc bd be bf  ................
00000c0: c0 c1 c2 c3 c4 c5 c6 c7 c8 c9 ca cb cc cd ce cf  ................
00000d0: d0 d1 d2 d3 d4 d5 d6 d7 d8 d9 da db dc dd de df  ................
00000e0: e0 e1 e2 e3 e4 e5 e6 e7 e8 e9 ea eb ec ed ee ef  ................
00000f0: f0 f1 f2 f3 f4 f5 f6 f7 f8 f9 fa fb fc fd fe ff  ................

按照Brainfuck等人的惯例，输出以字节为单位。

这个怎么运作

具体来说，这是一个简单的cat程序,[.,]。

源代码按顺序包含所有256个字节的值，因此其中每个字节的索引都与其值匹配。

语言，1.22e7字节

包含12263215 NUL字节，（十六进制0x00）。

NUL为未出现在源代码中的每个字符输出一个。

原因是输入将永远不会包含NUL，因此我们总是输出输入中包含NUL字符的s 数量。

转换为以下Brainfuck程序

,[[-].,]

并细分...

,[[-].,]
,[    ,]    #Basic Input loop.
  [-]       #Zero out the cell.
     .      #Print it (A NUL).

这仅显示了Lenguage作为高尔夫语言的绝对力量。怕了

果冻，10 9字节

“ṾiЀƓv”v

在线尝试！

这个怎么运作

“ṾiЀƓv”v  Main link. No arguments.

“ṾiЀƓv”   Set the left argument and the return value to s := 'ṾiЀƓv'.
        v  Execute the string s as a monadic Jelly program with argument s.

 Ṿ         Uneval; yield a string representation of s, i.e., r := '“ṾiЀƓv”'.
     Ɠ     Read one line from STDIN and evaluate it like Python would.
  iЀ      Find the index of each character in the input in r.
      v    Eval the list of indices as a monadic Jelly program with argument s.
           Why?
             This is the shortest way to add the character 'v' to the string s,
             meaning that we can use r without having to append anything.
           What?
             The v atom vectorizes at depth 1 for its left argument, meaning that
             it acts on arrays of numbers and/or characters. When fed an array of
             integers, it first converts them to strings, then concatenates the
             strings and evaluates them as a Jelly program. For example, the array
             [1, 2, 3] gets cast to the string '123', then evaluates, yielding 123.
             Something slightly different happens if the array starts with a 0. For
             example, the array [0, 1, 2] gets cast to '012' just as before, but
             Jelly views '0' and '12' as two separate tokens; numeric literals
             cannot start with a 0. Since the Jelly program is monadic, the first
             token – '0' – sets the return value to 0. Since the second token –
             '12' – is also a niladic link, the previous return value is printed
             before changing the return value to 12. Then, the program finishes
             and the last return value is printed implicitly.

pbrain，402个 356 340 338 329字节

[(:<>)+,-.](>>>>>>)+([-]<<[->+>+<<]>>[-<<+>>]>>[-<+<+>>]<[->+<]<[-<->]<)+([-]+++++++[>+++++++++++++<-]>)+([-]+++++[>++++++++<-]>)+(-:<+++[->++++++<]>)+(-:++)+(-:++)+(----:+)+(-:++)+(-:+)+(-:+)+(-:+)+([-]++:++)+([>[->+>+<<]>>[-<<+>>]<:>>+:[[-]>+<]>-[<<<<[-.>]>>>>>>+>>>>>]<<[-]<<+<-]>>>)[-]>>>>>>>,[<<<<<<++<+++++++++++++:>>>>>>,]

Phew，@ KritixiLithos和我已经为此工作了4天。

0x00如果输入的char不在程序中，则打印，否则以16进制表示char（从1开始）的索引。在线尝试！

说明：

[(:<>)+,-.]
All chars listed here; like other submissions 
(>>>>>>)
@KritixiLithos added this part; I don't know what it does but saves the program
+([-]<<[->+>+<<]>>[-<<+>>]>>[-<+<+>>]<[->+<]<[-<->]<)
Comparison ;calculates z=x!=y and puts it in between x and y
Start; X _ _ _ Y
           ^
End;   X Z _ _ Y
         ^
+([-]+++++++[>+++++++++++++<-]>)
Function to add 91 to the tape
+([-]+++++[>++++++++<-]>)
Function to add 40 to the tape
+(-:<+++[->++++++<]>)
Function to add 58 to the tape
+(-:++)
Function to add 60 to the tape
+(-:++)
Function to add 62 to the tape
+(----:+)
Function to add 41 to the tape
+(-:++)
Function to add 43 to the tape
+(-:+)
Function to add 44 to the tape
+(-:+)
Function to add 45 to the tape
+(-:+)
Function to add 46 to the tape
+([-]++:++)
Function to add 93 to the tape
+([>[->+>+<<]>>[-<<+>>]<:>>+:[[-]>+<]>-[<‌​<<<[-.>]>>>>>>+>>>>>]<<[-]<<+<-]>>>)

最后一个功能是循环。它[(:<>)+,-.]按顺序循环遍历所选字符，并将输入内容与字符进行比较。现在，我将对此循环的工作方式进行更深入的说明。

12-n n+2 _ n+2: _ _ _ i _ _ _ _ _ _;  n=loop counter
                  ^                ;  i=input

堆栈在循环中看起来像这样。该循环将持续到12-nIS 0。然后我们有一个柜台n+2。该计数器也是每个所选字符的功能编号。因此，当时n=0，n+2将对应第一个字符，即[。>[->+>+<<]>>[-<<+>>]<:这样做，它将计数器转换为字符。

一旦指针位于插入标记的位置，我们将比较计数器变量产生的字符与输入，同时保留它们。

12-n n+2 _ n+2: Z _ _ i _ _ _ _ _ _;  n=loop counter
                ^                  ;  i=input

Z是0字符等于输入时的值，否则为其他非零整数。

现在，我们提出一个if语句来检查此相等性。

[[-]>+<]

如果Z非零，即字符和输入不相同，我们将增加下一个存储位置。

从这个if语句出来后，我们递减下一个存储位置。现在该存储位置包含!Z。最后使用它，如果与输入匹配，则输出字符的索引，然后强行退出循环。否则，我们继续循环，直到循环结束或找到匹配项为止。

[-]>>>>>>>
Clears first byte; goes to position to start program
,[<<<<<<++<+++++++++++++:>>>>>>,]
Loops inputs

CJam，14 12字节

{sq\f#p_~}_~

使用基于0的索引，-1用于未出现在源代码中的字符。

在线尝试！

Javascript，34个字节

f=a=>a.map(v=>('f='+f).indexOf(v))

它将输入作为字符串数组，x是-1（基于0的索引）。

C，153个 152 143字节

char s[99],p[]="odeflnrti%()*+-0;<={}\\";c;f(char*i){sprintf(s,"char s[99],p[]=\"%s",p);for(c=0;c<strlen(i);)printf("%d ",strchr(s,i[c++])-s);}

在线尝试！

Ruby 41 88 86 71 69 67 61 56字节

a='p$<.chrs{| #index};"';$<.chars{|c|p"a='#{a}".index c}

Thx Lynn杀死了6个字节

> <>（鱼）70字节

 #.0+4*a5;!?l|!?f4*b+l1--naolc3*1+0.01?!|~ed+0.0+2e-{:;!?+1:i-1:r}+2:"

大概是我做过的最长的<>> 1班轮。

它将在单独的行（索引为0）上打印每个字符的输出。

未找到的字符将始终打印代码的长度+ 1（如果在当前状态下认为还不错，我可以更改此长度），因此在这种情况下，71将始终是“未找到”字符。

有空的时候我会做一个解释。

一些测试用例；

## K = 1 \ n1 \ n71

＃“＃= 1 \ n69 \ n1

在线尝试

> <>语言

Perl 6的，50 52个字节

{(('R~.index$_) for}\\'R~'{((\'').index($_) for $_)}

翻译GB的Ruby解决方案和Rod的Python的解决方案。

输入一个字符列表并输出一个从零开始的索引列表（Nil对于不存在的字符）的lambda 。

编辑：修正了一个疏忽-需要添加2个字节:(

Clojure，43 56 48字节

编辑：该死的我忘了2！从43增加到56

编辑2：更新了此文本下方的示例代码，更新了不包括(def f ...）的字节数，仅更新了哈希图部分。

{\{ 0\\   1\  3\0   4\1 10\3 14\4 20\2 34 \} 43}

哈希图仅包含字符01234{\\}，并对其位置进行编码。如完整示例所示，可以在Clojure中使用哈希映射函数（f可以由哈希映射定义替换）：

; Keeping track of the zero-based index:
;      00000000001111111111222222222233333333334444444444
;      01234567890123456789012345678901234567890123456789
(def f {\{ 0\\   1\  3\0   4\1 10\3 14\4 20\2 34 \} 43})

(map f "0123456789{} \\abcdef") ; (4 10 34 14 20 nil nil nil nil nil 0 43 3 1 nil nil nil nil nil nil)
(apply str (keys f))            ; " 01234{\\}"

我想这很重要:)

JavaScript，39个字节

p=s=>[...s].map(c=>`p=${p}`.indexOf(c))

console.log( p('mapP') )

Pyth，11个字节

xL_+N"N+_Lx

该程序接受a的输入，"quoted string"字符串中的所有引号\均以前置符号转义，并输出零索引值的列表，其中带有-1for字符不在源中。

在线尝试！

这个怎么运作

xL_+N"N+_Lx    Program. Input: Q
xL_+N"N+_Lx"Q  Implicit quote closure and implicit input
     "N+_Lx"   Yield the string "N+_Lx"
   +N          Prepend a quote
  _            Reverse
 L          Q  Map over Q:
x               Yield the index of the character in the string
               Implicitly print

05AB1E，19个字节

"'ìsvDyk,"'"ìsvDyk,

在线尝试！

输出-1代替缺少的字符。

路易斯·门多（Luis Mendo）在高尔夫上发布了这条（略有修改）的礼物，这是一个伟大的礼物！，在该quine上加上“ s”和“ k”也将得到此答案。但是，我对这种琐碎的修改不屑一顾。Luis，如果您想重新发布此信息，可以给我发消息，我将其删除。如果要在查找问题之前先查看我的进度，请查看编辑内容。好吧……这一点很像他。

SmileBASIC，128 96 88 86字节

?R<3+CD,4LINPUT(S$)WHILE""<S$?INSTR("?R<3+CD,4LINPUT(S$)WHILE"+CHR$(34),SHIFT(S$))WEND

要意识到的重要一点是，这并不是真正的难题。您只需要源代码，直到最后一个唯一字符即可。

我将每个字符中的至少一个放在代码的开头：?R<3+CD,4LINPUT(S$)WHILE"因此我只需要存储程序的副本，直到第一个引号。

Python，90 88字节

a,b,d=" ()+.7:[]efilmnor","a,b,d=\"",lambda e:[[b.find(d),a.find(d)+7][d in a]for d in e]

测试用例：

print(d("a,b(]q"))
#[0, 1, 2, 8, 15, -1]

堆叠式（非竞争），36位元组

当我说这种语言仍在开发中时，我是说真的。显然，prompt用于消耗整个堆栈。这就是为什么我不能拥有美好的事物。在这里尝试！

[tostr ':!' + prompt CS index out]:!

这是标准的quine框架。基本上，:将函数复制到[...]堆栈上，然后使用来执行!。然后，内部[...]使用堆栈上的函数执行。它将其强制转换为字符串，追加:!（程序本身），然后使用进行字符串输入prompt。CS将其转换为字符串。字符串与常规字符串有点不同，因为它的操作符可以向量化。在这种情况下，index对输入进行矢量化处理，生成程序中输入字符串的每个索引，最后将其out放入。

对于input Hello, World!，这给出：

(-1 27 -1 -1 2 -1 6 -1 2 5 -1 26 9)

我尝试使用不带奎纳的方法（即，对出现在源代码中的字符串进行编码），但是Stacked中只有一种引号，即'，因此执行这种解决方案的时间会更长。

外壳，12个字节

m€`:'""m€`:'

在线尝试！

说明

该解释¨用于分隔字符串和'分隔字符：

m€`:'""m€`:'  -- implicit input, for example: ¨m"a1`¨
      "m€`:'  -- string literal: ¨m€`:'¨
  `:'"        -- append character '"': ¨m€`:'"¨
m             -- map function over each character (example with 'a'):
 €            -- | index of first occurrence (1-indexed): 0
              -- : [1,6,0,0,3]

Java 8，172 122字节

a->{/*.indexOf(c)+\" ;}orh:Systmup*/for(char c:a)System.out.print("a->{/*.indexOf(c)+\\\" ;}orh:Systmup".indexOf(c)+" ");}

0索引，并提供-1不属于源代码的字符。

说明：

在线尝试。

a->{                         // Method with character-array parameter and no return-type
  /*.indexOf(c)+\" ;}orh:Systmup*/
                             //  Comment containing the remaining characters of the code
  for(char c:a)              //  Loop over the input-array
    System.out.print(        //   Print:
      "a->{/*.indexOf(c)+\\\" ;}orh:Systmup"
                             //    String containing all the characters used in the code
      .indexOf(c)+" ");}     //    Print the index of the char, plus a space as delimiter

J，31 22字节

11|1+i.~&'11|1+i.~&'''

在线尝试！

1索引，0表示代码中不存在的字符。''代表单引号。找到字符串中的每个字符11|1+i.~&'，加1，取模11。

> <>，31个字节

'rd3*i:0(?;}{:}-&b0&?.75*l-nao]

在线尝试！

输出为1索引，32表示该字符不在代码中。

Perl 5的与-pl，43个字节

使用换行符分隔的输入，并打印-1出程序中未出现的字符。

$s=q{$_=index"\$s=q{$s};eval\$s",$_};eval$s

在线尝试！

Stax，19个字节

"'sym[]I+"'"s+ym[]I

运行并调试

输出从0开始的索引，每行一个字符。事实证明，这比修改"34bL"34bL我之前写的奎因短。