填写我的气泡表

18

今天是我学校的AP考试注册日，当我一丝不苟地浏览所需的信息页面时，这一挑战的念头打动了我。因此，给定一串字母和数字，输出适当填充的气泡图。

规则：

  • 对于输入字符串中的每个字符，用#或@或任何其他合理的符号替换相应列中的该字符（如果您的语言可以处理，则Unicode字符'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  ascii-art 
— X1M4L
source
7
通常不鼓励输入验证，因此您可以使输入匹配，[A-Z0-9]{1,32}并允许不匹配输入的任何行为。
— 朱塞佩
1
ASCII代码中'0'出现在'A'之前的事实真是可笑，（> lol
— NL628
“有效输入将是由气泡表上出现的字符以及空格组成的字符串”，但您还应声明“除大写字母，空格和数字以外的任何字符，或超过32个字符的限制应该被忽略”，那是哪一个呢？
— Kritixi Lithos '18
1
但是根据第一个陈述，您说那$将不会出现在输入中
— Kritixi Lithos 18-4-20
1
现在，您已从规格中删除了数字和innalid字符，您可能还希望从示例中删除它们。
— 泰特斯

Answers:

4

外壳，23个字节

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

在线试用或尝试用花哨█字符（但无效BYTECOUNT）！

不幸的是，我无法将两个maps 合并为一个（除非使用括号，否则花费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"]
— ბიმო
source
4

红宝石，62字节

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

在线尝试！

返回字符串数组。通常可以通过丢弃字符串连接并返回二维字符数组来进一步解决问题，但是我不确定此处是否允许使用。

— 基里尔
source
3

C（GCC） ，132个 126字节

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

在线尝试！

感谢Jonathan Frech节省了6个字节。

— LambdaBeta
source
puts("")等同于putchar(10)。
— 乔纳森·弗雷希
++a)putchar((x[a-s]-*_)?*_:64);-> )putchar(x[a++-s]-*_?*_:64);。
— 乔纳森·弗雷奇
如果你愿意通融一下，你也可以打高尔夫球64来1。
— 乔纳森·弗雷希
如果您这样做，putchar可以将电话打到putchar(*_*(*_!=a[x-s]));。
— 乔纳森·弗雷希
通常情况下，我可以通过弯曲规则来解决问题……但是1是与填充矩形或@符号完全不同的野兽。其他更改虽然很有用-将更新。
— LambdaBeta
3

红色，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
]
— 加伦·伊万诺夫（Galen Ivanov）
source
3

木炭，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个字节。

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

在线尝试！链接是详细版本的代码。

— 尼尔
source
：/您似乎在结尾处缺少封闭的括号
— ASCII码
这看起来像它的工作原理。（Wolfram StringReplace）在旁注中，一个内置的replace确实非常方便
— 纯ASCII，
没关系，我不知道自己在做什么。27个字节 -您不需要Cast
— 的纯ASCII码
同样，重新：您之前问过的带有任意字符的键盘：您认为添加为内置键盘是否足够有用？还是内置两个字符？
— ASCII中仅ASCII
23
— 分，仅使用ASCII
3

果冻， 18  17字节

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

使用空格字符。要使用#替代⁶用”#了一个字节的成本。

在线尝试！

怎么样？

Ø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
— 乔纳森·艾伦
source
我可以保存一个字节。
— Erik the Outgolfer
亲爱的，我也³Ḣ,⁶yØA;ØD¤µ32СZY18岁了，我觉得这也是可以改善的！虽然走出去……
— 乔纳森·艾伦
因此，显然，这不是我要指的字节。:)更加努力...
— 暴民埃里克（Erik the Outgolfer）'18年
令人惊讶的是，我设法通过移动17字节
— 乔纳森·艾伦
我的实际上是这个，但恭喜！
— 暴民埃里克（Erik the Outgolfer）'18年
2

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

在线尝试！

— NL628
source
问题：是否需要包含标题？
— NL628
如果需要运行代码，则必须在您的答案中。也就是说，您可以删除几乎所有的空白，并使此答案仍然有效。
我可以将其重写为带有参数的函数，而不是main（）吗？
— NL628
@ NL628是的，您可以。有关更多帮助，请参见C ++打高尔夫球的技巧。编辑：切换到C ++的链接
— 朱塞佩
1
有人吗？我从未在其中编写任何代码，但是使用COBOL进行代码高尔夫可能是一个有趣的挑战。
— 汉斯·马丁·莫斯纳
2

Node.js，85个字节

@DanielIndie建议的端口到Node.js

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

在线尝试！

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

在线尝试！

— Arnauld
source
90字节呢？
— DanielIndie
@DanielIndie谢谢！添加。（我们真的不需要这个+""，对吗？）
— Arnauld
我从不知道我们是否需要转换，所以我不考虑它：P但是的，您实际上不需要它:)
— DanielIndie
@DanielIndie啊，现在我们可以再使用x/322个字节，因为Buffer它强制转换为整数。
— Arnauld
f=(s,x=561,c=Buffer([48+x/33%43]))=>x<1749?(s[x++%33]==c?'@':x%33?c:`\n`)+f(s,x):''
— l4m2
2

Haskell，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

使用该帮助程序，我们只需要生成字符串"A..Z0..9"，将每个元素复制32次，然后将每个字符串的输入压缩，就可以了：

f x = map ((x#) . replicate 32) (['A'..'Z'] ++ ['0'..'9'])
— ბიმო
source
1
85个字节：在线尝试！
— Laikoni '18
@Laikoni：遗憾的是，它只少了1个字节，这是一个非常聪明的用法max。我认为您应该将其发布为您自己的解决方案，因为它与我的解决方案非常不同。
— ბიმო
我发布了一个74字节的版本。
— Laikoni '18
2

Haskell，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'。因为这会产生单例字符串而不是char，所以使用do-notation将单例字符串连接为一个字符串。

基于BMO的Haskell解决方案。

— 莱科尼
source
2

Python 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))
— 桑拉德10
source
2

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

运行这个

— 递归的
source
1

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

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
— 格雷厄姆
source
1

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！）此外，我确保使用以下命令将输出精确地保持为32个字符sprintf()：如果这不是任务的要求，则函数将为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));}

在线尝试！

— 埃里克
source
— ceilingcat
1

CJam，31个字节

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

在线尝试！使用空格作为“洞”字符。

如果允许尾随空格，那么它适用于29个字节：

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

在线尝试！

这是一个34字节的变体，它改用Unicode完整块（█）：

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.
— 硕果累累
source
1

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
— 艾米尼亚
source
a[b]不能像您想要的那样工作，：P吗？
— 魔术章鱼缸
@MagicOctopusUrn：不幸的是没有。那也是我的第一个想法，但是在这种情况下模块化索引不是我们的朋友：P
— Emigna'April
1

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
— 路易斯·门多
source
1

普通Lisp，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")
— 仅ASCII
source
1

爪哇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
— 凯文·克鲁伊森
source
1

视网膜，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个字符

— 黄昏
source
1

Tcl，153145字节

感谢@sergiol -8个字节

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}}
        ]
        ""
    ]
}
— 仅ASCII
source
152
— sergiol
@sergiol：| 是的。146？
— 仅使用ASCII
1
145
— 的纯ASCII码
1

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
— 朱塞佩
source
1

Prolog（SWI），235 229 228 222 214 198 173 167 165字节

-6字节由于@Cows嘎嘎，-6字节由于@ 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`.

在线尝试！

说明

% 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`.
— 仅ASCII
source
0

八度，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
— 汤姆·卡彭特
source
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.