输出程序中每个输入字符的第一个位置


43

挑战

编写一个非空程序/函数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的索引,则NaNInf字符串potato,大于程序长度的数字等)。

限制条件

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

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


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

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


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


大写重要吗?
Kritixi Lithos

@KritixiLithos 默认是,是
马丁·恩德

@KritixiLithos确实如此。
桑契斯

如果我的程序仅使用索引09,是否需要分隔符或可以输出,例如01030708070
丹尼斯

@丹尼斯不,你不知道。它是明确,一致且易于阅读的。要求使用分隔符不会给挑战增加任何有趣的东西,因此绝对会滥用低字节数。;)
Sanchises

Answers:


24

Python2,55字节

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

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


5
我看不出这是无聊的答案。我认为使用标准奎因比这有趣得多。:)
Martin Ender

由于这是Python 2,这不会在大多数输入上中断吗?如果确实损坏,则必须使用raw_input
TidB

@TidB嗯,我想不是吗?您有什么想法?
Rod

@Rod Nevermind,我只是有点笨。输入可迭代项时,它将始终有效。傻我
TidB '16

12

语言,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个字节的值,因此其中每个字节的索引都与其值匹配。


4
嗯,我认为Lenguage是唯一使人们超出三个数量级的语言...
Sanchises

2
语言语言也是唯一不断发现作弊方式的语言,这种语言甚至在其他语言中也没有竞争优势。:P
丹尼斯

不会+[,.]取得更好的成绩吗?
桑契斯

@Sanchises这样可以节省大约12,000个字节,但是最后还会打印一个额外的空字节。
丹尼斯

2
好吧,我想空字节在输入(即使它的功能是终止字符串),并会在你的程序中的第0位...;)
Sanchises

10

语言,1.22e7字节

包含12263215 NUL字节,(十六进制0x00)

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

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

转换为以下Brainfuck程序

,[[-].,]

并细分...

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

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


2
如此巧妙的诡计,您几乎赢了……您是否也尝试过反向操作,即0x00字节和1索引?
桑契斯

我本来会喜欢的,但是Brainfuck / Lenguage(或者至少是我正在使用的解释器)无法区分EOF和0x00,所以我将无法真正应对挑战。
ATaco

Brainfuck等。通常允许将整数打印为字节,即,您将SOH打印为1,NUL为0。–
Dennis

@Sanchises您能否确定是这种情况?
丹尼斯

1
不会,[>.,]更短吗?
Jo King

8

果冻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.

8

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=0n+2将对应第一个字符,即[>[->+>+<<]>>[-<<+>>]<:这样做,它将计数器转换为字符。

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

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

Z0字符等于输入时的值,否则为其他非零整数。

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

[[-]>+<]

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

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

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


6

Javascript,34个字节

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

它将输入作为字符串数组,x-1(基于0的索引)。


允许,因为该方法也适用于奎因。它不会打开其源文件并读取它,也不会使用初始化为源的变量。
mbomb007 '16

1
@ mbomb007我不能说所有的JavaScript引擎,但是在Firefox中,Function.toString通过阅读源代码起作用。某一时刻,如果尝试读取源时不再存在该源,则它将在调试版本中崩溃。(我最近没有尝试过,因为调试版本总体上是如此崩溃。)
Neil

我认为这s='s=%s;print s%%s';print s%s与Python 没什么不同。它不包含f=,所以没关系
mbomb007 '16

1
您不能真正做到这一点,因为输入a应该是字符串。map字符串没有功能。
manonthemat

@manonthemat“您可以假定输入是字符串(或数组)”
LarsW 2016年

5

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

在线尝试!


5

Ruby 41 88 86 71 69 67 61 56字节

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

Thx Lynn杀死了6个字节


1
a='p$<.chrsm{| #index};"';p$<.chars.map{|c|"a='#{a}".index c}从STDIN输入信息,它也应该工作。
林恩

4

> <>(鱼)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

在线尝试

> <>语言


我认为71可以很好地作为未找到的输出。它是一致的,明确的且易于阅读的,我认为比“ ...任何非正整数的输出”更重要。我扩展了规则以反映此决定。
桑契斯


3

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{\\}"

我想这很重要:)



2

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

2

05AB1E,19个字节

"'ìsvDyk,"'"ìsvDyk,

在线尝试!

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


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


@Sanchises为我工作!
魔术章鱼缸

酷酷酷!
桑契斯

@MagicOctopusUrn干得好!
路易斯·门多

2

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"因此我只需要存储程序的副本,直到第一个引号。


1

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]

1

堆叠式(非竞争),36位元组

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

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

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

对于input Hello, World!,这给出:

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

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


1

外壳,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]

1

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

1

J31 22字节

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

在线尝试!

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




1

Stax,19个字节

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

运行并调试

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

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.