Phần đơn giản: Cho một chuỗi đầu vào chỉ chứa các ký tự ASCII có thể in (dấu cách - dấu ngã), đếm số lần xuất hiện của mỗi ký tự và trả về kết quả trên bất kỳ định dạng thuận tiện nào. Kết quả cho một chuỗi a%hda7aphải là một cái gì đó như : a:3, %:1, h:1, 7:1, d:1. Sắp xếp là không cần thiết, các dấu phân cách và định dạng là tùy chọn nhưng phải dễ hiểu số nào tương ứng với ký tự nào. Bạn sẽ không bao gồm các ký tự không có trong chuỗi đầu vào ( a:3, b:0, c:0, d:1, ...không ổn).

Thử thách thực sự:

Chuyển đổi mọi ký tự trong mã của bạn thành số nhị phân 8 bit (hoặc 16 bit nếu bạn đang sử dụng UTF-16 hoặc tương tự) và liệt kê mọi ký tự bắt đầu từ 0.

Đối với mỗi ký tự ( ilà liệt kê), i%7-bit ¹ phải là 1. Các bit được đánh số từ bên phải. Tất cả các bit khác có thể là bất cứ điều gì bạn muốn.

Hãy sử dụng mã sau đây làm ví dụ:

[f]-xif)#f

Chuyển đổi này thành nhị phân, chúng tôi nhận được các mảng dưới đây. Số thứ nhất (đại diện [có số 1ở vị trí số 0, do đó số thứ tự ổn. Số thứ hai (số đại diện fcó 1vị trí số 1, do đó số này cũng ổn. Tiếp tục như vậy và bạn sẽ thấy mã ở trên là hợp lệ.

C 76543210 Số bit
- -------- ----------
[0101101 1   0 - OK
f 011001 1 0 1 - OK
] 01011 1 01 2 - OK
- 0010 1 101 3 - OK
x 011 1 1000 4 - OK
tôi 01 1 01001 5 - OK
f 0 1 100110 6 - OK
) 0010100 1   0 - OK
# 001000 1 1 1 - OK
f 01100 1 10 2 - OK

Nếu chúng tôi thay đổi mã thành: ]f[-xif)#fchúng tôi sẽ bắt đầu chuỗi sau:

C  76543210  Bit number
-  --------  ----------
]  01011101  0   <- OK
f  01100110  1   <- OK
[  01011011  2   <- Not OK
-  00101101  3   <- OK

Như chúng ta thấy, ký tự thứ ba [không có 1vị trí thứ 2 (không có chỉ mục) và do đó mã này không hợp lệ.

Các trường hợp thử nghiệm:

Input:
This is a string containing some symbols: ".#!".#&/#

Output:
   !  "  #  &  /  :  T  a  b  c  e  g  h  i  l  m  n  o  r  s  t  y  .
7  1  2  3  1  1  1  1  2  1  1  1  2  1  5  1  2  4  3  1  6  2  1  2

Bất kỳ định dạng đầu ra hợp lý là OK (bất cứ điều gì thuận tiện nhất cho bạn). Ví dụ, bạn có thể có: :7, !:1, ":2, #:3, &:1, /:1, T:1, a:2 ...hoặc [ ,7][!,1][",2][#,3][&,1].... Đầu ra là trên bất kỳ cách tiêu chuẩn nào (trở về từ chức năng, được in thành STDOUT, v.v.)

¹i mô đun 7.

Đây là mã golf , vì vậy mã ngắn nhất tính bằng byte sẽ giành được ^ref .

Pyke, 1 6 byte

1cn;1c

Hãy thử nó ở đây!

1c     - chunk(size=1, input)
  n;1  - noop. 
     c - count(^)

Một nửa mã này chỉ là không có ...

00110001 - 1
01100011 - c
01101110 - n
00111011 - ;
00110001 - 1
01100011 - c

Bình thường, 12 8 7 byte

^{-1 byte nhờ @Loovjo}

m+d/Qd{
      { # remove all duplicated elements from the (implicit) input
m       # map each element (d) of the parameter (the set from previous operation)
   /Qd  # count the occurrences of d in Q
 +d     # concatenate with d

đại diện nhị phân

0110110 1 m
001010 1 1 +
01100 1 00 ngày
0010 1 111 /
010 1 0001 Q
01 1 00100 d
0 1 111011 {

Thử ở đây

Befunge-93, 150 byte

={<{p+}3/}*77\%*7{7:\+{}{1g}+3/*77\%*7{7:}=:_{}{}={}{}{v#{}{}`x1:~
}-}=*}{2*}97}:<$}={$_v#}!:-*84g+3/*77\%*7{7:}=:}:}+}1{}<_{@#
}{}{}={}{}{}={^.},\={<

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

Tôi bắt đầu bằng cách viết nó như một chương trình Befunge thông thường, mà tôi đã chơi golf nhiều nhất có thể. Sau đó tôi đã thêm phần đệm để đảm bảo các ký tự khác nhau trong chương trình chỉ xuất hiện ở các vị trí được phép. Phần đệm này dựa trên thực tế là các lệnh không được hỗ trợ bị bỏ qua trong Befunge-93, vì vậy tôi chỉ cần một chuỗi các ký tự không được sử dụng có các bit được căn chỉnh theo các vị trí cần thiết (chuỗi tôi đã sử dụng ={}{}{}).

Một chút phức tạp là các nhánh khác nhau giữa các dòng cần xếp hàng chính xác (ví dụ: vmũi tên trong một dòng, sẽ cần xếp hàng với <mũi tên bên dưới nó). Điều này còn phức tạp hơn bởi thực tế là lệnh cầu (# ) không thể tách rời khỏi mũi tên phân nhánh liền kề của nó. Ban đầu tôi đã thử tạo phần đệm theo chương trình, nhưng cuối cùng, nó chủ yếu là một quy trình thủ công.

Do quy mô của chương trình, tôi sẽ không liệt kê phân tích nhân vật đầy đủ, nhưng đây là một mẫu từ đầu đến cuối:

= 00111101 0
{ 01111011 1
< 00111100 2
{ 01111011 3
p 01110000 4
+ 00101011 5
} 01111101 6
3 00110011 0
/ 00101111 1
...
{ 01111011 1
^ 01011110 2
. 00101110 3
} 01111101 4
, 00101100 5
\ 01011100 6
= 00111101 0
{ 01111011 1
< 00111100 2

Các ngắt dòng được coi là một ký tự dòng mới, do đó sẽ ở vị trí 1 hoặc 3.

MATL , 17 byte

u"G91x@=zD91x@uRD

Hiển thị số đếm, sau đó ký tự tương ứng, tất cả các dòng mới được phân tách. Khó khăn lớn nhất là cái @đó là 0b01000000; Tôi hy vọng tôi có thể tìm ra cách để làm mà không cần nó.

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

Giải trình:

u"  % Implicit input. Take (u)nique characters and loop (") over them.
G   % Take the input a(G)ain
91x % Filler: push 91, delete immediately.
@   % Push current character of loop
=   % Check for equality with earlier G
z   % Count number of equal characters
D   % Display
91x % More filler!
@   % Get loop character again
uR  % Filler: two NOPs for the single-character @
D   % Display. Implicitly end loop.

MATL, 15 byte (đầu ra nghi vấn)

Nếu chỉ để hai vectơ hàng trên ngăn xếp được phép (hành vi giống như chức năng theo bài Meta này ), chúng ta có thể truy cập vào

u"G91x@=zv]v!Gu

Nhưng ở đây, đầu ra không được sắp xếp gọn gàng.

CJam, 14 byte

q__|_ @sfe=]zp

Hãy thử nó ở đây.

Không gian trước @và ssau nó là các ký tự phụ được chèn để làm cho mã ASCII phù hợp với mẫu được yêu cầu: không gian không có gì vàs chỉ chuyển đổi một chuỗi thành một chuỗi. Ngoài ra, đây là một cách thực hiện nhiệm vụ thử thách khá đơn giản và dễ hiểu:

q_ "đọc đầu vào và tạo một bản sao của nó";
  _ | "thu gọn các ký tự lặp đi lặp lại trong bản sao";
    _ "lưu một bản sao của chuỗi bị sập";
      @ "kéo chuỗi đầu vào ban đầu lên đầu ngăn xếp";
       s "(không làm gì ở đây)";
        fe = "cho mỗi ký tự trong chuỗi bị sập, hãy đếm ...";
                 "... số lần xảy ra trong chuỗi gốc";
           ] z "ghép các số đếm với bản sao đã lưu của chuỗi bị sập";
             p "in đại diện chuỗi kết quả";

Đối với đầu vào foobar123, mã này đầu ra [['f 1] ['o 2] ['b 1] ['a 1] ['r 1] ['1 2] ['2 2] ['3 1]]. Nếu chỉ đơn giản là in số đếm trên một dòng và các ký tự tương ứng trên dòng khác, như trong:

[1 2 1 1 1 2 2 1]
fobar123

được coi là một định dạng đầu ra có thể chấp nhận, sau đó ]zcó thể được bỏ qua để lưu hai byte, với tổng số 12 byte . Có, mã rút ngắn vẫn sẽ vượt qua yêu cầu mẫu bit.

Thi thiên Tôi cũng đã viết một trình kiểm tra mã nguồn đơn giản cho thử thách này. Đưa ra một dòng mã làm đầu vào, đầu tiên nó sẽ lặp lại dòng đó và sau đó in cùng một dòng với mỗi ký tự được thay thế bằng bit ASCII ( n % 7) của nó. Nếu dòng thứ hai là tất cả, đầu vào là hợp lệ.

Jelly , 6 byte trong bảng mã của Jelly

ṢZṢṀŒr

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

Đây là một hàm trả về một danh sách các cặp (ký tự, số đếm). (Jelly đại diện cho các danh sách như văn bản, ví dụ: nếu chúng được gửi đến đầu ra tiêu chuẩn, bằng cách nối các phần tử, đó là lý do tại sao bạn phải coi đây là một chức năng chứ không phải là một chương trình hoàn chỉnh. ( Đây là cùng một chương trình với một số mã được thêm vào gọi hàm và sau đó in cấu trúc bên trong thành đầu ra tiêu chuẩn, chứng minh rằng đầu ra ở định dạng rõ ràng.)

Đại diện và giải thích nhị phân:

  76543210 

1011011 1    Sắp xếp các ký tự của đầu vào
Z 010110 1 0 Chuyển đổi danh sách (đó là 1D, do đó, điều này thực sự bao bọc nó trong danh sách)
10110 1 11 Sắp xếp danh sách (không có op, vì nó chỉ có một yếu tố)
Ṁ 1100 1 000 Lấy phần tử lớn nhất (chỉ có nghĩa là)
Œ 000 1 0011 byte đầu tiên của lệnh hai byte
r 01 1 10010 Mã hóa chiều dài chạy

Có thể thấy rằng các ký tự thứ hai, thứ ba và thứ tư triệt tiêu lẫn nhau và chỉ ở đó để duy trì mẫu bit mà chúng ta cần. Œrtuy nhiên, quá tiện lợi và việc đệm chương trình để chúng ta có thể sử dụng nó có thể mang lại cho chúng ta một chương trình ngắn hơn là cố gắng giải quyết vấn đề mà không cần dựng sẵn.