오늘은 학교에서 AP 시험을 치르는 날이었으며, 필요한 정보 페이지와 페이지에서 꼼꼼하게 버블 링을하는 동안이 과제에 대한 아이디어가 떠 올랐습니다. 따라서 문자와 숫자로 구성된 문자열이 적절하게 채워진 거품 형 차트를 출력합니다.

규칙 :

• 입력 문자열의 각 문자에 대해 해당 열의 해당 문자를 하나 #이상의 @적절한 기호로 바꿉니다 (언어에서 처리 할 수있는 경우 유니 코드 문자 'full_block': █가 정말 좋습니다)
• 공백은 빈 열로 표시됩니다 (예 참조).
• 유효한 입력은 대문자, 숫자 및 공백으로 구성된 문자열입니다.
• 입력 길이는 최소 1 자, 최대 32 자입니다.
• 출력은 대문자 여야합니다
• 입력 길이가 최대 길이 인 32보다 작 으면 프로그램은 여전히 ​​나머지 빈 열을 출력해야합니다
• 프로그램은 대문자 인 것처럼 소문자 입력을 처리 할 필요가 없지만 가능하면 보너스 포인트를 처리 할 필요가 없습니다.

보드 형식 :

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

예 :

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

물론 이것은 code-golf 이므로 가장 짧은 답변이 승리합니다.

껍질 , 23 바이트

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

온라인으로 시도 하거나 멋진 █ 문자 (그러나 잘못된 바이트 수) 로 시도하십시오 !

불행히도 나는 두 map바이트를 하나로 병합 할 수 없었습니다 (24 바이트의 괄호 사용 제외).

설명

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"]

루비 , 62 바이트

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

온라인으로 사용해보십시오!

문자열 배열을 반환합니다. 문자열 조인을 버리고 일반적으로 일반적인 2D 문자 배열을 반환하여 더 골프를 칠 수는 있지만 여기에서 허용되는지 확실하지 않습니다.

C (GCC) , 132 (126) 바이트

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

온라인으로 사용해보십시오!

6 바이트를 절약 한 Jonathan Frech에게 감사합니다.

빨강 , 177 바이트

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]

온라인으로 사용해보십시오!

더 읽기 쉬운 :

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
]

숯 , 21 바이트

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명:

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

입력 유효성 검사가있는 이전 버전, 34 32 바이트 편집 : @ASCII 전용 덕분에 2 바이트가 절약되었습니다.

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다.

R , 104 바이트

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

온라인으로 사용해보십시오!

젤리 ,  18  17 바이트

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

공백 문자를 사용합니다. A가 사용하는 #대신 ⁶에 ”#한 바이트의 비용.

온라인으로 사용해보십시오!

어떻게?

Ø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 바이트 237

최악의 CodeGolf 언어로이 작업을 수행 한 것은 이번이 처음입니다 : 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';}}

온라인으로 사용해보십시오!

Node.js, 85 바이트

@DanielIndie가 제안한 Port to Node.js

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

온라인으로 사용해보십시오!

자바 스크립트 (ES6), 103 98 바이트

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):''

온라인으로 사용해보십시오!

펄 5 -F , 47 바이트

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

온라인으로 사용해보십시오!

하스켈 , 86 바이트

훨씬 더 좋은 접근 방식과 적은 바이트 수는 Laikoni의 솔루션을 참조하십시오 !

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

온라인으로 사용해보십시오!

또는 동일한 바이트 수에 대해 다음을 사용할 수 있습니다.

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

온라인으로 사용해보십시오!

설명 / 언 골프

연산자 (#)는 매우 비슷 zipWith하지만 함수는 하드 코딩되어 있습니다. 그것은 사용하는 #두 문자가 동일하고, 그렇지 않으면 ungolfed 두번째는, 유지하는 경우 :

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

첫 번째 목록이 소진되면 두 번째 목록의 나머지 요소 만 추가됩니다.

_ # w = w

이 도우미를 사용하면 string 만 생성하고 "A..Z0..9"각 요소를 32 번 복제하고 각 문자열로 입력을 압축하지 않고 골퍼해야합니다.

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

하스켈 , 74 바이트

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

온라인으로 사용해보십시오! 입력 문자열 x은 공백으로 32 자 길이로 채워집니다 take 32$x++cycle" ". 각 문자 c의 A에 Z와 0에 9, 우리는 문자를 보면 a패딩 입력 문자열에서에 의해 교체 ~할 때 a와 c동일 의해있다 c그렇지 않으면. 이것은 max[c]['~'|a==c]예를 들어 max "A" "~" = "~"언제 a = c = 'A', max "A" "" = "A"언제 c = 'A'그리고 언제에 의해 달성된다 a = 'B'. 이것은 문자 대신 단일 문자열을 생성하기 때문에 do단일 문자열을 하나의 문자열로 연결하는 -notation이 사용됩니다.

BMO의 Haskell 솔루션을 기반으로 합니다 .

파이썬 2, 138 바이트

대문자와 소문자를 모두 지원하며 공백을 위해 채워지지 않은 열을 남겨 둡니다.

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

보너스가 가치가 없다면 125 바이트를 사용하고 대문자 입력 만 지원합니다.

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 바이트

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

실행 및 디버깅

사용합니다 '#'채워진 거품을 나타내는 됩니다.

포장을 풀고 포장을 풀고 주석을 달았습니다.

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

이것을 실행

Pyth, 23 20 바이트

j.Tm:s+r1GUTdN.[Qd32

여기 사용해보십시오

설명

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 + WIN, 56 바이트

입력 문자열을 프롬프트하고 # 문자를 식별자로 사용합니다.

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

설명:

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 바이트

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

온라인으로 사용해보십시오!

하드 코딩 된 배열 대신 검색 기능으로 대체했습니다. 다행히도 ASCII 문자 세트에는 연속적인 알파벳 및 숫자 범위가 있습니다 (EBCDIC를보고 있습니다!). 또한 sprintf()다음을 사용하여 출력을 정확하게 32 자로 유지해야합니다 . 함수는 97 바이트입니다.

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

온라인으로 사용해보십시오!

CJam , 31 바이트

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

온라인으로 사용해보십시오! 공백을 "구멍"문자로 사용합니다.

후행 공백이 허용되면 29 바이트 동안 작동 합니다 .

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

온라인으로 사용해보십시오!

█대신 유니 코드 전체 블록 ( ) 을 사용하는 34 바이트 변형이 있습니다 .

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

온라인으로 사용해보십시오!

설명

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.

파이썬 2 , 103 96 94 바이트

-7 덕분에 바이트 니모닉
-2 덕분 바이트 Jonathan Frech

용도 '기호로

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

온라인으로 사용해보십시오!

05AB1E , 19 바이트

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

온라인으로 사용해보십시오!

설명

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 바이트

1Y24Y2vjO33(32:)y=~*c

공백을 마커 문자로 사용합니다.

온라인으로 사용해보십시오!

설명

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

공통 리스프 , 150 바이트

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

온라인으로 사용해보십시오!

설명

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

자바 10 120 118 117 바이트

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

온라인으로 사용해보십시오 (TIO의 경우 '█'를 사용했습니다 ( 9608대신35 경우 더 나은 가시성을 위해 ).

설명:

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

레티 나 , 64 바이트

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

온라인으로 사용해보십시오!

$
36* 
L`.{36}

오른쪽의 입력 문자열을 36 자로 공백으로 채 웁니다.

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

그런 다음 각 문자를 한 줄에 넣고 ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789앞에 추가 하십시오.

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

동일한 행에서 동일한 문자 쌍을 찾습니다. 해당 행의 문자가 중 하나와 일치하는 경우에만 ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789있습니다. 첫 번째를 교체하고 두 번째를 @제거하십시오.

N$`\S
$.%`

일치하지 않는 유일한 행은 공백이있는 행이므로 공백이 아닌 문자는 36 × 36 정사각형 블록입니다. 전치하십시오.

L`.{32}

각 줄에서 처음 32 자만 유지

TCL , 153 바이트

-8 바이트에 대한 @sergiol 감사 합니다.

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

온라인으로 사용해보십시오!

설명

# 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) 바이트

	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

온라인으로 사용해보십시오!

설명:

	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

프롤로그 (SWI) , 235 (229) 228 222 214 198 173 167 165 바이트

@Cows quack 덕분에 -6 바이트, @ 0 ' 덕분에 -6 바이트

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

온라인으로 사용해보십시오!

설명

% 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 바이트

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

여기 사용해보십시오!

옥타브 , 61 바이트

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

온라인으로 사용해보십시오!

이 기능은 다음과 같이 작동합니다.

@(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  

펄 6 , 57 바이트

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

온라인으로 사용해보십시오!