Hôm nay là ngày đăng ký thi AP tại trường của tôi, và trong khi tôi đang tỉ mỉ sủi bọt trong các trang và trang thông tin cần thiết, ý tưởng cho thử thách này đã đánh trúng tôi. Vì vậy, đưa ra một chuỗi các chữ cái và số, đưa ra biểu đồ bong bóng được điền đầy đủ.

Quy tắc:

• Đối với mỗi ký tự trong chuỗi đầu vào, thay thế ký tự đó trong cột tương ứng bằng một #hoặc @bất kỳ ký hiệu hợp lý nào khác (nếu ngôn ngữ của bạn có thể xử lý nó, ký tự Unicode 'full_block': trông thực sự tốt)
• Một khoảng trắng được biểu thị bằng một cột trống (xem ví dụ)
• Đầu vào hợp lệ sẽ là một chuỗi chỉ bao gồm các chữ cái viết hoa, chữ số và dấu cách.
• Đầu vào sẽ có độ dài tối thiểu là 1 và tối đa là 32 ký tự.
• Đầu ra phải được chữ hoa
• Nếu độ dài đầu vào nhỏ hơn độ dài tối đa 32, chương trình của bạn vẫn phải xuất các cột trống còn lại
• Chương trình của bạn không phải xử lý đầu vào chữ thường giống như khi chúng là chữ hoa, nhưng điểm thưởng nếu có thể.

Định dạng bảng:

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
JJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ
KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK
LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN
OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO
PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP
QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS
TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU
VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY
ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ
00000000000000000000000000000000
11111111111111111111111111111111
22222222222222222222222222222222
33333333333333333333333333333333
44444444444444444444444444444444
55555555555555555555555555555555
66666666666666666666666666666666
77777777777777777777777777777777
88888888888888888888888888888888
99999999999999999999999999999999

Ví dụ:

CODE GOLF ->

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
█CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
DD█DDDDDDDDDDDDDDDDDDDDDDDDDDDDD
EEE█EEEEEEEEEEEEEEEEEEEEEEEEEEEE
FFFFFFFF█FFFFFFFFFFFFFFFFFFFFFFF
GGGGG█GGGGGGGGGGGGGGGGGGGGGGGGGG
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
JJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ
KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK
LLLLLLL█LLLLLLLLLLLLLLLLLLLLLLLL
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN
O█OOOO█OOOOOOOOOOOOOOOOOOOOOOOOO
PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP
QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS
TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU
VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY
ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ
00000000000000000000000000000000
11111111111111111111111111111111
22222222222222222222222222222222
33333333333333333333333333333333
44444444444444444444444444444444
55555555555555555555555555555555
66666666666666666666666666666666
77777777777777777777777777777777
88888888888888888888888888888888
99999999999999999999999999999999


ABCDEFGHIJKLMNOPQRSTUVWXYZ012345 ->

@AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
B@BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
CC@CCCCCCCCCCCCCCCCCCCCCCCCCCCCC
DDD@DDDDDDDDDDDDDDDDDDDDDDDDDDDD
EEEE@EEEEEEEEEEEEEEEEEEEEEEEEEEE
FFFFF@FFFFFFFFFFFFFFFFFFFFFFFFFF
GGGGGG@GGGGGGGGGGGGGGGGGGGGGGGGG
HHHHHHH@HHHHHHHHHHHHHHHHHHHHHHHH
IIIIIIII@IIIIIIIIIIIIIIIIIIIIIII
JJJJJJJJJ@JJJJJJJJJJJJJJJJJJJJJJ
KKKKKKKKKK@KKKKKKKKKKKKKKKKKKKKK
LLLLLLLLLLL@LLLLLLLLLLLLLLLLLLLL
MMMMMMMMMMMM@MMMMMMMMMMMMMMMMMMM
NNNNNNNNNNNNN@NNNNNNNNNNNNNNNNNN
OOOOOOOOOOOOOO@OOOOOOOOOOOOOOOOO
PPPPPPPPPPPPPPP@PPPPPPPPPPPPPPPP
QQQQQQQQQQQQQQQQ@QQQQQQQQQQQQQQQ
RRRRRRRRRRRRRRRRR@RRRRRRRRRRRRRR
SSSSSSSSSSSSSSSSSS@SSSSSSSSSSSSS
TTTTTTTTTTTTTTTTTTT@TTTTTTTTTTTT
UUUUUUUUUUUUUUUUUUUU@UUUUUUUUUUU
VVVVVVVVVVVVVVVVVVVVV@VVVVVVVVVV
WWWWWWWWWWWWWWWWWWWWWW@WWWWWWWWW
XXXXXXXXXXXXXXXXXXXXXXX@XXXXXXXX
YYYYYYYYYYYYYYYYYYYYYYYY@YYYYYYY
ZZZZZZZZZZZZZZZZZZZZZZZZZ@ZZZZZZ
00000000000000000000000000@00000
111111111111111111111111111@1111
2222222222222222222222222222@222
33333333333333333333333333333@33
444444444444444444444444444444@4
5555555555555555555555555555555@
66666666666666666666666666666666
77777777777777777777777777777777
88888888888888888888888888888888
99999999999999999999999999999999

ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 ->^^^

Và tất nhiên, đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất sẽ thắng

Husk , 23 byte

mż§?'#|=⁰mR32¤+…"AZ""09

Hãy thử trực tuyến hoặc thử với ký tự fancy ưa thích (nhưng một phụ bản không hợp lệ)!

Thật không may, tôi không thể hợp nhất hai maps thành một (trừ khi sử dụng dấu ngoặc đơn, tốn 24 byte) ..

Giải trình

mż§?'#|=⁰mR32¤+…"AZ""09"  -- expects string as argument, eg. "FOO"
             ¤            -- with the two strings "AZ" "09" ..
               …          -- | fill ranges: "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                          -- |              "0123456789"
              +           -- .. and concatenate: "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
          m               -- map the following (eg. with 'X')
                          -- | replicate 32 times: "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
                          -- : ["A…A","B…B",…,"Z…Z","0…0",…"9…9"]
m                         -- map the following (eg. with "F…")
 ż      ⁰                 -- | zipWith (keeping elements of longer list) argument ("FOO")
  §?   =                  -- | | if elements are equal
    '#                    -- | | | then use '#'
      |                   -- | | | else use the first character
                          -- | : ["#FF…F"]
                          -- : ["A…A",…,"#FF…F",…,"O##O…O",…,"9…9"]

Ruby , 62 byte

->s{[*?A..?Z,*?0..?9].map{|c|(0..31).map{|i|c==s[i]??@:c}*''}}

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

Trả về mảng của chuỗi. Có thể được đánh gôn hơn nữa bằng cách loại bỏ các chuỗi tham gia và trả về một mảng các ký tự 2D như thường lệ, nhưng tôi không chắc liệu nó có được phép ở đây không.

C (gcc) , 132 126 byte

char*s="ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",*_,*a;f(char*x){for(_=s;*_;++_,puts(""))for(a=s;*a;)putchar(x[a++-s]-*_?*_:64);}

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

Cảm ơn Jonathan Frech đã lưu 6 byte.

Màu đỏ , 177 byte

func[s][m: copy[]foreach c a:"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"[insert/dup r: copy"^/"c 32 append m r]j: 0
foreach c s[j: j + 1 if c <>#" "[m/(index? find a c)/(j): #"@"]]m]

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

Dễ đọc hơn:

f: func[s][
    m: copy[]
    a:"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
    foreach c a[
        insert/dup r: copy "^/" c 32
        append m r
    ]
    j: 0
    foreach c s[
        j: j + 1
        if c <>#" "[m/(index? find a c)/(j): #"@"]
    ]
    m
]

Than , 21 byte

Ｅ⁺α⭆…αχκ⭆…◨θφ³²⎇⁼ιλ#ι

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

  α  α                  Uppercase alphabet predefined variable
      χ                 Predefined variable 10
    …                   Chop to length
   ⭆                    Map over characters and join
       κ                Current index
 ⁺                      Concatenate
Ｅ                       Map over characters into array
           θ            Input string
            φ           Predefined variable 1000
          ◨             Right pad to length
             ³²         Literal 32
         …              Chop to length
        ⭆               Map over characters and join
                 ι  ι   Current outer character
                  λ     Current inner character
                ⁼       Equals
                   #    Literal `#`
               ⎇        Ternary
                        Implicitly print each result on its own line

Phiên bản trước với xác nhận đầu vào, 34 32 byte. Chỉnh sửa: đã lưu 2 byte chỉ nhờ @ ASCII.

≔⁺α⭆…αχκαＥα⭆…◨Φθ∨⁼ι №αιφ³²⎇⁼ιλ#ι

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã.

R , 104 byte

function(S,o=""){for(i in 1:32)o=paste0(o,`[<-`(x<-c(LETTERS,1:9),x==substr(S,i,i),"@"))
cat(o,sep="
")}

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

Thạch ,  18  17 byte

ØA;ØDWẋ32ɓ,€⁶y"ZY

Sử dụng một nhân vật không gian. Để sử dụng #thay thế ⁶với ”#chi phí một byte.

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

Làm sao?

ØA;ØDWẋ32ɓ,€⁶y"ZY - Main Link: list of characters, S   e.g.  ['S','P','A','M']
ØA                - upper-case alphabet characters           ['A','B',...,'Z']
   ØD             - digit characters                         ['0','1',...,'9']
  ;               - concatenate                              ['A','B',...,'Z','0','1',...,'9']
     W            - wrap in a list                           [['A','B',...,'Z','0','1',...,'9']]
      ẋ32         - repeat 32 times                          [['A','B',...,'Z','0','1',...,'9'],...,['A','B',...,'Z','0','1',...,'9']]
         ɓ        - start a new dyadic chain with that on the right
            ⁶     - space character                          ' '
          ,€      - pair €ach of S with a space              [['S',' '],['P',' '],['A',' '],['M',' ']]
              "   - zip with:
             y    -   translate (replace 'S' with ' ' in 1st, 'P' with ' ' in 2nd, ...) -- Note: zip is a zip-longest, so trailing lists remain
                Z  - transpose
                 Y - join with line-feeds
                   - implicit print

C ++ 14, 319 byte 237

Đây là lần đầu tiên tôi làm điều này, bằng ngôn ngữ CodeGolf tồi tệ nhất có thể: P

char c;string k="ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",s;int main(){map<char,vc>g;g[' ']=vc(32,' ');for(char c:k)g[c]=vc(32,c);getline(cin,s);for(int i=0;i<s.length();i++)g[s[i]][i]='@';for(char d:k){for(char x:g[d])cout<<x;cout<<'\n';}}

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

Node.js, 85 byte

Cổng tới Node.js được đề xuất bởi @DanielIndie

f=(s,x=544,c=Buffer([48+x/32%43]))=>x<1696?(s[x&31]==c?'@':c)+[`
`[++x&31]]+f(s,x):''

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

JavaScript (ES6), 103 98 byte

f=(s,x=544,n=x>>5,c=String.fromCharCode(48+n%43))=>n<53?(s[x&31]==c?'@':c)+[`
`[++x&31]]+f(s,x):''

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

Perl 5 -F , 47 byte

//,say map{$F[$_]eq$'?'*':$'}0..31for A..Z,0..9

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

Haskell , 86 byte

Để biết cách tiếp cận đẹp hơn (và ít byte hơn), hãy xem giải pháp của Laikoni !

f x=(x#).(<$[1..32])<$>['A'..'Z']++['0'..'9']
(a:b)#(u:v)=last(u:['#'|a==u]):b#v
_#w=w

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

Ngoài ra, với cùng số byte chúng ta có thể sử dụng:

(a:b)#(u:v)|a==u='#':b#v|0<3=u:b#v

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

Giải thích / Ungolfed

Toán tử (#)rất giống với zipWithtuy nhiên chức năng được mã hóa cứng, st. nó sử dụng #nếu hai ký tự bằng nhau và nếu không thì nó giữ nguyên ký tự thứ hai, không có dấu vết:

(a:b) # (u:v)
   | a == u    = '#' : b # v
   | otherwise =  u  : b # v

Nếu danh sách đầu tiên đã hết, nó chỉ nối thêm các phần tử còn lại của danh sách thứ hai:

_ # w = w

Với trình trợ giúp đó, chúng ta chỉ cần tạo chuỗi "A..Z0..9", sao chép mỗi phần tử 32 lần và nén đầu vào với mỗi chuỗi, không được mã hóa:

f x = map ((x#) . replicate 32) (['A'..'Z'] ++ ['0'..'9'])

Haskell , 74 byte

f x=[do a<-take 32$x++cycle" ";max[c]['~'|a==c]|c<-['A'..'Z']++['0'..'9']]

Hãy thử trực tuyến! Một chuỗi đầu vào xđược đệm với khoảng trắng đến 32 với take 32$x++cycle" ". Đối với mỗi ký tự ctừ Ađến Zvà 0đến 9, chúng tôi xem xét các ký tự atừ chuỗi đầu vào được đệm và thay thế chúng bằng ~khi avà cbằng nhau và bằng cách ckhác. Điều này đạt được bởi max[c]['~'|a==c], ví dụ như max "A" "~" = "~"khi nào a = c = 'A', và max "A" "" = "A"khi nào c = 'A'và a = 'B'. Bởi vì điều này mang lại một chuỗi singleton thay vì char, chú dothích được sử dụng để nối các chuỗi singleton thành một chuỗi.

Dựa trên giải pháp Haskell của BMO .

Python 2, 138 byte

Hỗ trợ cả ký tự chữ hoa và chữ thường và để lại một cột không lấp đầy cho khoảng trắng.

def f(s):
 s=s.upper()
 for j in"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789":print"".join(j if(len(s)<=i)or(s[i]!=j)else'@'for i in range(32))

Nếu phần thưởng không xứng đáng, thì tôi sẽ sử dụng 125 byte và chỉ hỗ trợ đầu vào chữ hoa:

def f(s):
 for j in"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789":print"".join(j if(len(s)<=i)or(s[i]!=j)else'@'for i in range(32))

Stax , 15 byte

╛dδÑ-═E↑\≈Fà±AG

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

Nó sử dụng '#'để chỉ ra một bong bóng đầy.

Giải nén, không được chỉnh sửa và nhận xét, nó trông như thế này.

32(     right-pad or truncate to 32
{       begin block for mapping
  VAVd+ "A..Z0..9"
  s'#+  move input character to top of stack and append "#". e.g. "C#"
  |t    translate; replace the first character with the second in string
m       perform map using block
Mm      transpose array of arrays and output each line

Chạy cái này

Bình thường, 23 20 byte

j.Tm:s+r1GUTdN.[Qd32

Hãy thử nó ở đây

Giải trình

j.Tm:s+r1GUTdN.[Qd32
              .[Qd32      Pad the input to 32 characters.
   m                      For each character...
     s+r1GUT              ... get the string "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"...
    :       dN            ... with the character replaced by a '"'.
j.T                       Transpose the lines and print them all.

APL + THẮNG, 56 byte

Lời nhắc cho chuỗi đầu vào và sử dụng # ký tự làm định danh:

m←⍉32 36⍴⎕av[(65+⍳26),48+⍳10]⋄((,m[;1]∘.=32↑⎕)/,m)←'#'⋄m

Giải trình:

m←⍉32 36⍴⎕av[(65+⍳26),48+⍳10] create the table

32↑⎕ pad the input string to 32 characters with spaces

(,m[;1]∘.=32↑⎕) use outer product with = to identify characters in table

((,m[;1]∘.=32↑⎕)/,m)←'#' replace characters with #

m display table

⋄ statement separator

C (gcc) , 124 byte

f(s,b,x,y)char*s,b[33];{sprintf(b,"%-32.32s",s);for(x=0;++x<36;puts(""))for(y=x+21+43*(x<27),s=b;*s;putchar(*s++==y?35:y));}

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

Thay vì một mảng mã hóa cứng, tôi đã thay thế nó bằng một chức năng tra cứu thay thế. May mắn thay, bộ ký tự ASCII có các chữ số và chữ số liền kề nhau (Tôi đang nhìn bạn, EBCDIC!) Đồng thời, tôi đảm bảo giữ đầu ra cho chính xác 32 ký tự bằng cách sử dụng sprintf(): nếu đây không phải là yêu cầu của nhiệm vụ, thì Hàm sẽ là 97 byte:

f(s,i,x,y)char*s,*i;{for(x=0;++x<36;puts(""))for(y=x+21+43*(x<27),i=s;*i;putchar(*i++==y?35:y));}

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

CJam , 31 byte

q32Se]{'[,65>A,s+S+_@#St);}%zN*

Hãy thử trực tuyến! Sử dụng khoảng trắng làm ký tự "lỗ".

Nếu khoảng trắng theo dõi được cho phép, thì điều này hoạt động với 29 byte :

q32Se]{'[,65>A,s+S+_@#St}%zN*

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

Đây là một biến thể 34 byte sử dụng toàn bộ khối Unicode ( █):

q32Se]{'[,65>A,s+S+_@#'█t);}%zN*

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

Giải trình

q                                Input.
    e]                           Pad to a length of
 32                                32
                                 with
   S                               spaces.
      {                   }%     For each character:
                                   Get the uppercase alphabet by
            >                        dropping the first
          65                           65
                                     elements of
         ,                             the range of characters below
       '[                                '['.
                +                  Append
               s                     the string version
              ,                        of the range of numbers below
             A                           10.
                  +                Append
                 S                   a space.
                     #             Find the index of
                    @                the character.
                       t           Set this index to
                      S              a space
                   _               in the original array.
                        );         Drop the space at the end.
                                   Yield this modified array.
                                 End for. The result is an array of arrays of characters.
                            z    Transpose this array, turning rows into columns.
                             N*  Join the result on newlines.

Con trăn 2 , 103 96 94 byte

-7 byte nhờ Mnemonic
-2 byte nhờ Jonathan Frech

Sử dụng 'như là biểu tượng

i,l=input(),17;exec"k=chr(l%43+48);print''.join(`k`[i[x:][:1]!=k]for x in range(32));l+=1;"*36

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

05AB1E , 19 byte

RтúR32£vžKuÙyð:})ø»

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

Giải trình

R                     # reverse
 тú                   # prepend 100 zeroes
   R                  # reverse
    32£        }      # take the first 32 characters
       v              # for each character
        žK            # push a string of [a-zA-Z0-9]
          uÙ          # upper case and remove duplicates
            yð:       # replace current character with space
                )ø    # transpose
                  »   # join by newline

MATL , 21 byte

1Y24Y2vjO33(32:)y=~*c

Sử dụng một không gian làm ký tự đánh dấu.

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

Giải trình

1Y2     % Push 'AB...YZ'
4Y2     % Push '01...89'
v       % Concatenate into a 36×1 column vector of chars
j       % Push unevaluated input: string of length n, or equivalently 1×n
        % row vector of chars
O33(    % Write 0 at position 33. This automatically writes a 0 at postions
        % n+1, n+2, ..., 32 too
32:)    % Keep only the first 32 entries: gives a 1×32 row vector
y       % Duplicate from below: pushes a copy of the 36 ×1 column vector
=~      % Test for non-equal entries, with broadcast. Gives a 33×32 matrix
        % containing 0 for matching entries, and 1 otherwise
*       % Multiply this matrix by the 1×32 row vector, with broadcast. This
        % changes each 1 into the corresponding character in the input
c       % Convert to char. Implicitly display. Char 0 is displayed as space

Lisp thông thường , 150 byte

(setq s(format nil"~32a"(read-line)))(map nil(lambda(i)(map nil(lambda(j)(princ(if(eq i j)#\# i)))s)(princ"
"))"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")

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

Giải trình

;; pad input to 32 spaces on the right
(setq s(format nil"~32a"(read-line)))
;; for each character in bubble sheet, for each character in input:
;; if characters are equal print "#"
;; else print bubble sheet character
(map nil(lambda(i)(map nil(lambda(j)(princ(if(eq i j)#\# i)))s)(princ"
"))"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")

Java 10, 120 118 117 byte

s->{var r="";for(char c=65,i;c<91&c!=58;r+="\n",c+=c<90?1:-42)for(i=0;i<32;i++)r+=i<s.length&&s[i]==c?35:c;return r;}

Dùng thử trực tuyến (đối với TIO tôi đã sử dụng '' ( 9608thay vì 35) để nhìn rõ hơn).

Giải trình:

s->{                   // Method with character-array parameter and String return-type
  var r="";            //  Result-String, starting empty
  for(char c=65,i;     //  Start character `c` at 'A'
      c<91&c!=58       //  Loop as long as `c` is 'Z' or smaller, and is not '9'
      ;                //    After every iteration:
       r+="\n",        //     Append a new-line to the result-String
       c+=c<90?        //     If `c` is not 'Z' yet
           1           //      Go to the next character ASCII-value-wise
          :            //     Else:
           -42)        //      Change the 'Z' to '0'
    for(i=0;i<32;i++)  //    Inner loop `i` in the range [0,32)
      r+=i<s.length    //     If we're not at the end of the input array yet,
         &&s[i]==c?    //     and the characters in the column and array are the same
          35           //      Append the filler-character '#'
         :             //     Else:
          c;           //      Append the current character instead
  return r;}           //  Return the result-String

Võng mạc , 64 byte

$
36* 
L`.{36}
.
36*@$&¶
Y`@`Ld
(.)(.*)\1
@$2
N$`\S
$.%`
L`.{32}

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

$
36* 
L`.{36}

Đệm chuỗi đầu vào bên phải với khoảng trắng đến 36 ký tự

.
36*@$&¶
Y`@`Ld

Sau đó, đặt từng ký tự trên dòng riêng và thêm vào ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789trước nó.

(.)(.*)\1
@$2

Ghép một cặp của cùng một nhân vật trên cùng một dòng, có một khi và chỉ khi nhân vật cho dòng đó khớp với một ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789. Thay cái thứ nhất bằng @và loại bỏ cái thứ hai.

N$`\S
$.%`

Các dòng duy nhất chưa từng có là các dòng có khoảng trắng, vì vậy các ký tự không phải là khoảng trắng là một khối vuông 36 × 36. Chuyển nó

L`.{32}

Chỉ giữ 32 ký tự đầu tiên trong mỗi dòng

Tcl , 153 145 byte

Cảm ơn @sergiol cho -8 byte

lmap i [split ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 ""] {puts [join [lmap j [split [format %-32s [join $argv ""]] ""] {expr {$i==$j?"#":$i}}] ""]}

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

Giải trình

# for i in list of choices
lmap i [split ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 ""] {
    # print string of
    puts [join
        # list of
        [lmap j
             # for each character in first argument padded to 32 characters
             [split [format %-32s [join $argv ""]] ""]
             # return "#" if current choice and current character are equal, else current choice
             {expr {$i==$j?"#":$i}}
        ]
        ""
    ]
}

SNOBOL4 (CSNOBOL4) , 155 150 byte

	I =INPUT
	U =&UCASE '0123456789'
N	U LEN(1) . K REM . U	:F(END)
	O =DUPL(K,32)
	X =
S	I LEN(X) @X K	:F(O)
	O POS(X) K =' '	:S(S)
O	OUTPUT =O	:(N)
END

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

Giải trình:

	I =INPUT			;* read input
	U =&UCASE '0123456789'		;* U = uppercase concat digits
N	U LEN(1) . K REM . U	:F(END)	;* while U not empty, pop first letter as K
	O =DUPL(K,32)			;* dup K 32 times
	X =				;* set position to 0
S	I LEN(X) @X K	:F(O)		;* find the next occurrence of K and save (index - 1) as X
	O POS(X) K =' '	:S(S)		;* replace the X'th occurrence of K with space. If that's before character 32, goto S, else proceed to next line
O	OUTPUT =O	:(N)		;* output the string and goto N
END

Prolog (SWI) , 235 229 228 222 214 198 173 167 165 byte

-6 byte nhờ vào quẻ @Cows , -6 byte nhờ @ 0 '

X*[H|T]:-(H=X->write(#);writef("%n",[X])),X*T;nl.
_+[].
X+[H|T]:-H*X,X+T.
?-read(X),swritef(Y,"%32l",[X]),string_codes(Y,Z),Z+`ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789`.

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

Giải trình

% if head = bubble char, write "#", else write bubble char, then while tail is non-empty, recurse.
% if tail is empty then print newline
X*[H|T]:-(H=X->write(#);writef("%n",[X])),X*T;nl.
% if list is empty, then do nothing. this prevents t from being called with invalid X
_+[].
% call t, then recurse for each char in list
X+[H|T]:-H*X,X+T.
% read, pad input to 32 chars, and convert input to list
?-read(X),swritef(Y,"%32l",[X]),string_codes(Y,Z),Z+`ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789`.

SOGL V0.12 , 19 byte

,M↕+'»m{Z²²+;╗ŗ}⁰№I

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

Octave , 61 byte

@(s)[((a=[30:55 13:22]'*~~(o=1:32)).*(a+35~=[s o](o)))+35 '']

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

Hàm này hoạt động như sau:

@(s)[                                                     ''] %Anonymous function, taking string, outputting character array   
         [30:55 13:22]'                                       %Creates the board alphabet ('A':'Z' '0':'9']) but minus 35 (value of '#')
                       *~~(o=1:32)                            %Matrix multiplication by an array of 32 1's to form the 2D board. Saves 1:32 for later.
      (a=                         )                           %Saves the board mimus 32 to a for use later.
                                            [s o](o)          %Ensures the input is 32 characters long. Missing chars replaced by 1:32 (not in board)
                                     (a+35~=        )         %Compares against board (a+35 as a=board-35). Makes 2D array where matches = 0, others = 1. 
     (                             .*                )+35     %Element=wise multiplication, forcing matches to 0. Then add 35 resulting in board with #'s  

Perl 6 , 57 byte

{map {<<$^c█>>[.comb[^32]Xeq$c].join},|('A'..'Z'),|^10}

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