Thử thách

Viết chương trình / hàm không trống p, được cung cấp một chuỗi đầu vào không trống s, xuất ra vị trí xuất hiện đầu tiên của mỗi ký tự strong mã nguồn của p.

Ví dụ: nếu chương trình của bạn là

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

và nó nhận được một đầu vào abcd{, đầu ra phải là

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

Tại đây, xđại diện cho bất kỳ đầu ra đó không phải là một kết quả hợp lệ cho một vị trí ký tự (ví dụ, một số âm, 0nếu bạn sử dụng 1 dựa trên lập chỉ mục, NaN, Inf, chuỗi potato, một lớn hơn số hơn chiều dài của chương trình của bạn, vv).

Những hạn chế

Đọc mã nguồn không được phép (như trong một quine thích hợp). Việc sử dụng các bình luận được cho phép, nhưng không được tính vào điểm số của bạn.

Đầu vào và đầu ra có thể được thực hiện ở định dạng hợp lý, nhưng phải rõ ràng (chỉ có các dấu phân cách bổ sung, không có randluồng và cho rằng câu trả lời nằm ở đâu đó trong đó), nhất quán (ví dụ: xtừ trên phải luôn có cùng giá trị) và con người- có thể đọc được ; ví dụ: một chuỗi hoặc một mảng ký tự. Bạn có thể giả sử rằng đầu vào là một chuỗi (hoặc mảng) các ký tự ASCII có thể in được; không cần phải xử lý toàn bộ bộ Unicode.

Trang mã tùy chỉnh hoặc ascii không in được trong mã của bạn?

Nếu ngôn ngữ của bạn sử dụng trang mã tùy chỉnh (Jelly, APL, v.v.), bạn phải tính đến điều đó (vì vậy một chương trình €æÆphải xuất ra [1, x, 2]cho đầu vào €%æ). Chỉ sử dụng các ký tự không phải ASCII để đầu ra -1luôn (vì đầu vào chỉ có ASCII) không phải là một giải pháp hợp lệ. Bạn có thể cho rằng chương trình của bạn thực sự chấp nhận codepage tùy chỉnh của bạn, nghĩa là, nếu chương trình của bạn có phương thức chuyển đổi một ký tự Athành một số nguyên 65(mã hóa ASCII), bạn có thể cho rằng giờ đây nó chuyển đổi ký tự thứ 65 trong codepage của bạn thành 65.

Lấy cảm hứng từ thử thách sau: Nhận thức vị trí

Python2, 55 byte

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

Bắt đầu với một chuỗi chứa tất cả các ký tự được sử dụng trong mã, sau đó tìm kiếm các chỉ mục

Chiều dài , 56.623 byte

Dưới đây là một hexdump của 256 byte đầu tiên. Các byte còn lại có thể được chọn tùy ý.

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

Đầu ra được tính bằng byte, theo thông lệ cho brainfuck et al.

Làm thế nào nó hoạt động

Đây là một chương trình mèo đơn giản, cụ thể ,[.,].

Mã nguồn chứa tất cả 256 giá trị byte theo thứ tự, do đó, mỗi chỉ mục của byte phù hợp với giá trị của nó.

Chiều dài , 1,22e7 byte

Bao gồm các 12263215 NULbyte, (Hex 0x00) .

NULXuất ra một ký tự cho mỗi ký tự không xuất hiện trong nguồn.

Lý do là đầu vào sẽ không bao giờ chứa a NUL, vì vậy chúng tôi luôn xuất lượng NULs có ký tự trong đầu vào.

Điều này dịch sang chương trình Brainfuck sau đây

,[[-].,]

Và với một sự cố ...

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

Điều này chỉ cho thấy sức mạnh tuyệt đối của Lenguage như một ngôn ngữ chơi gôn. Sợ nó

Thạch , 10 9 byte

“ṾiЀƓv”v

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

“Ṿ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 byte

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

Phew, @KritixiLithos và tôi đã làm việc này được 4 ngày rồi.

In 0x00nếu char đầu vào không có trong chương trình, chỉ mục của char (dựa trên 1) ở dạng hex. Hãy thử trực tuyến!

Giải trình:

[(:<>)+,-.]
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
+([>[->+>+<<]>>[-<<+>>]<:>>+:[[-]>+<]>-[<‌​<<<[-.>]>>>>>>+>>>>>]<<[-]<<+<-]>>>)

Hàm cuối cùng này là vòng lặp. Nó lặp qua các ký tự được chọn [(:<>)+,-.]theo thứ tự và so sánh đầu vào với ký tự. Bây giờ tôi sẽ đưa ra một lời giải thích sâu hơn về cách vòng lặp này hoạt động.

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

Các ngăn xếp trông như thế trong khi trong một vòng lặp. Các vòng lặp sẽ chạy cho đến khi 12-nlà 0. Sau đó, chúng tôi có các quầy đó là n+2. Bộ đếm này cũng là số lượng chức năng cho mỗi ký tự được chọn. Vì vậy, khi n=0, n+2sẽ tương ứng với ký tự đầu tiên, tức là [. >[->+>+<<]>>[-<<+>>]<:không chỉ thế, nó chuyển đổi bộ đếm thành nhân vật.

Khi con trỏ là vị trí của dấu mũ, chúng ta sẽ so sánh ký tự được tạo từ biến đếm với đầu vào trong khi bảo quản chúng.

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

Zlà 0khi ký tự bằng với đầu vào, hoặc một số nguyên khác không khác.

Bây giờ chúng tôi đưa ra một tuyên bố if để kiểm tra sự bằng nhau này.

[[-]>+<]

Nếu Zkhác không, tức là ký tự và đầu vào không giống nhau, chúng ta tăng vị trí bộ nhớ tiếp theo.

Sau khi chúng tôi ra khỏi câu lệnh if này, chúng tôi sẽ giảm vị trí bộ nhớ tiếp theo. Bây giờ nơi bộ nhớ này chứa !Z. Cuối cùng sử dụng cái này, chúng ta xuất chỉ mục của ký tự nếu nó khớp với đầu vào và sau đó thoát khỏi vòng lặp một cách cưỡng bức. Khác, chúng tôi tiếp tục với vòng lặp cho đến khi nó kết thúc hoặc một trận đấu được tìm thấy.

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

CJam , 14 12 byte

{sq\f#p_~}_~

Sử dụng lập chỉ mục dựa trên 0 và -1cho các ký tự không xuất hiện trong nguồn.

Hãy thử trực tuyến!

Javascript, 34 byte

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

Nó nhận đầu vào là mảng của chuỗi, xlà -1(lập chỉ mục dựa trên 0).

C, 153 152 143 byte

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

Hãy thử trực tuyến!

Ruby, 41 88 86 71 69 67 61 56 byte

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

Thx Lynn vì đã giết 6 byte

> <> (Cá) 70 byte

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

Có lẽ là lớp lót dài nhất> <> 1 tôi từng làm.

Nó sẽ in đầu ra cho mỗi ký tự được tìm thấy trên một dòng riêng biệt (0 được lập chỉ mục).

Một ký tự không tìm thấy sẽ luôn in độ dài của mã + 1 (Tôi có thể thay đổi điều này nếu thấy không ổn trong trạng thái hiện tại) vì vậy trong trường hợp này 71 sẽ luôn là ký tự "Không tìm thấy".

Tôi sẽ chạy lên một lời giải thích khi tôi có thời gian.

Một số trường hợp thử nghiệm;

## K = 1 \ n1 \ n71

# "# = 1 \ n69 \ n1

Dùng thử trực tuyến

> <> ngôn ngữ

Perl 6 , 50 52 byte

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

Dịch giải pháp Ruby của GB và giải pháp Python của Rod .

Một lambda nhập danh sách các ký tự và xuất ra một danh sách các chỉ mục dựa trên số không ( Nilđối với các ký tự không tồn tại).

EDIT: Đã sửa lỗi giám sát - yêu cầu thêm 2 byte :(

Clojure, 43 56 48 byte

Chỉnh sửa: Chết tiệt tôi quên mất 2! Tăng từ 43 lên 56.

Chỉnh sửa 2: Cập nhật mã mẫu bên dưới văn bản này, cập nhật số byte không bao gồm (def f ...) mà chỉ là phần băm bản đồ.

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

Bản đồ băm chỉ bao gồm các ký tự 01234{\\}và nó mã hóa vị trí của chúng. Trong Clojure hash-maps có thể được sử dụng các hàm, như trong ví dụ hoàn chỉnh này ( fcó thể được thay thế bằng định nghĩa hash-map):

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

Tôi đoán điều này tính :)

JavaScript, 39 byte

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

console.log( p('mapP') )

Bình thường, 11 byte

xL_+N"N+_Lx

Một chương trình lấy đầu vào của a "quoted string", với bất kỳ dấu ngoặc kép nào trong chuỗi thoát trước đó \và in danh sách các giá trị được lập chỉ mục bằng 0 với -1các ký tự không có trong nguồn.

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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 byte

"'ìsvDyk,"'"ìsvDyk,

Hãy thử trực tuyến!

Điều này xuất ra -1 thay cho ký tự bị thiếu.

Luis Mendo đã đăng bài này (sửa đổi một chút) trên Golf cho bạn một câu hỏi hay! , thêm "s" và "k" vào câu hỏi đó cũng dẫn đến câu trả lời này. Tuy nhiên, tôi không thể tin vào sự sửa đổi tầm thường đó ... Luis, bạn có thể nhắn tin cho tôi nếu bạn muốn đăng lại cái này và tôi sẽ xóa nó đi. Nếu bạn muốn xem tiến trình của tôi trước khi tìm câu hỏi đó, hãy xem các chỉnh sửa. Vâng ... Nó là đáng kể như mình tại một thời điểm.

SmileBASIC, 128 96 88 86 byte

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

Một điều quan trọng để nhận ra là đây không thực sự là một thách thức. Bạn chỉ cần mã nguồn cho đến ký tự duy nhất cuối cùng .

Tôi đặt ít nhất 1 của mỗi ký tự ở đầu mã: ?R<3+CD,4LINPUT(S$)WHILE"vì vậy tôi chỉ phải lưu một bản sao của chương trình cho đến dấu ngoặc kép đầu tiên.

Python, 90 88 byte

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

Trường hợp thử nghiệm:

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

Xếp chồng , không biên dịch, 36 byte

Khi tôi nói ngôn ngữ này vẫn đang được phát triển, tôi có ý đó. Rõ ràng, promptđược sử dụng để tiêu thụ toàn bộ ngăn xếp. Đây là lý do tại sao tôi không thể có những thứ tốt đẹp. Hãy thử nó ở đây!

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

Đây là khung quine tiêu chuẩn. Về cơ bản, :sao chép chức năng [...]trên ngăn xếp, sau đó được thực hiện với !. Sau đó, bên trong [...]thực thi với chức năng trên ngăn xếp. Nó ép nó thành một chuỗi, nối thêm :!(chính chương trình), sau đó lấy đầu vào chuỗi với prompt. CSchuyển đổi nó thành một chuỗi ký tự. Một chuỗi ký tự khác một chút so với một chuỗi thông thường ở chỗ nó có các toán tử véc tơ hóa trên nó. Trong trường hợp này, indexvector hóa trên đầu vào, thu được từng chỉ số của chuỗi đầu vào trong chương trình, cuối cùng được outđưa vào.

Đối với đầu vào Hello, World!, điều này mang lại:

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

Tôi đã thử sử dụng loại không có quine (nghĩa là mã hóa chuỗi ký tự xuất hiện trong nguồn của bạn), nhưng chỉ có một loại dấu ngoặc kép trong Stacked, cụ thể ', do đó, sẽ lâu hơn để thực hiện loại giải pháp đó.

Husk , 12 byte

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

Hãy thử trực tuyến!

Giải trình

Giải thích được sử dụng ¨để phân định các chuỗi và 'phân định các ký tự:

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 byte

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

Được lập chỉ mục 0 và cung cấp -1cho các ký tự không phải là một phần của mã nguồn.

Giải trình:

Hãy thử trực tuyến.

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 byte

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

Hãy thử trực tuyến!

1 chỉ mục, 0 cho các ký tự không có trong mã. ''là viết tắt của một trích dẫn Tìm từng ký tự trong chuỗi 11|1+i.~&', thêm 1, modulo 11.

> <> , 31 byte

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

Hãy thử trực tuyến!

Đầu ra là 1 chỉ mục, có 32nghĩa là ký tự không có trong mã.

Perl 5 với -pl, 43 byte

Sử dụng đầu vào và bản in tách dòng mới -1cho các ký tự không xuất hiện trong chương trình.

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

Hãy thử trực tuyến!

Stax , 19 byte

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

Chạy và gỡ lỗi nó

Xuất ra chỉ số dựa trên 0, một ký tự trên mỗi dòng. Hóa ra nó ngắn hơn so với sửa đổi "34bL"34bLquine tôi đã viết trước đó.