注意：这是由@Willbeing这个问题启发的，该任务的任务是计算一定长度的完美板的数量，但略有不同。

我们称其为满足以下条件的完美车牌：

• 它由字符组成，可以是大写字母（[A-Z]）或数字（[0-9]）
• 用1索引（即A=1,B=2,...,Z=26）将英文字母的字母位置相加得出整数n
• 获取每个数字块，将它们求和，然后将所有结果相乘得到相同的结果，n
• n是一个完美的正方形（例如：49 （7 ²），16 （4 ²））

一个近乎完美的车牌符合完美牌照的条件，除了ñ是不是一个完美的广场。

输入值

代表车牌文本的字符串，以任何标准格式输入，硬编码除外。

输出量

如果给定的字符串表示接近完美的车牌，则返回真实值（例如：True/ 1），否则返回虚假值（例如：False/ 0）。请注意，严禁使用任何标准形式的输出，但请注意，此漏洞是绝对禁止的。

例子

licence plate -> output


A1B2C3 -> 1

A + B + C = 1 + 2 + 3 = 6
1 * 2 * 3 = 6 
6 is not a perfect square, 6 = 6 => nearly perfect plate

01G61 -> 1

(0 + 1) * (6 + 1) = 7
G = 7
7 is not a perfect square, 7 = 7 => nearly perfect plate

11BB2 -> 0

(1 + 1) * 2 = 4
B + B = 2 + 2 = 4
4 = 4, but 4 is the square of 2 => perfect license plate (not what we want)

67FF1 -> 0

(6 + 7) * 1 = 13
F + F = 6 + 6 = 12
12 != 13 => not perfect at all!

计分

这是代码高尔夫球，因此最短答案以字节为单位！

果冻，29 28 30 字节

1字节修复错误发现通过ChristianSievers（不正确地处理只有零的子串）1字节固定为假阳性"0"，"00"...上述定影过程中发现（0是一个完美的正方形）。

i@€ØAS;Ʋ$
e€ØAœpV€€LÐfS€P;0⁼Ç

在线尝试！，或进行测试

怎么样？

i@€ØAS;Ʋ$ - Link 1: [letter-sum, letter-sum is perfect square?]: plate
i@€        - index of €ach char in plate [reversed @rguments] (1-based, 0 otherwise) in:
   ØA      -     uppercase alphabet
     S     - sum
         $ - last two links as a monad:
      ;    -     concatenate with:
       Ʋ  -         is square?

e€ØAœpV€€LÐfS€P;0⁼Ç - Main link: plate                        e.g. "11BB2"
    œp              - partition plate at truthy values of:
e€                  -     is in? for €ach char in plate:
  ØA                -         uppercase alphabet                   [['1','1'],[''],['2']]
      V€€           - evaluate for €ach for €ach                   [[1,1],[],[2]]
          Ðf        - filter keep:
         L          -     length                                   [[1,1],[2]]
            S€      - sum each                                     [2,2]
              P     - product                                      4
               ;0   - concatenate a zero                           [4,0]
                  Ç - last link (1) as a monad (taking plate)      [4,1]
                 ⁼  - equal? (non-vectorising)                     0

MATL，36 34 33 35字节

3Y432YXU"@V!Usvp]GlY2&msy=wtQ:qUm~v

在MATL Online上尝试

说明

        % Implicitly grab input as a string
3Y4     % Push the predefined literal '[A-Za-z]+' to the stack
32      % Push the literal 32 to the stack (ASCII for ' ')
YX      % Replace the matched regex with spaces (puts a space in place of all letters)
U       % Convert the string to a number. The spaces make it such that each group of
        % of consecutive digits is made into a number
"       % For each of these numbers
  @V!U  % Break it into digits
  s     % Sum the digits
  v     % Vertically concatenate the entire stack
  p     % Compute the product of this vector
]       % End of for loop
G       % Explicitly grab the input again
lY2     % Push the predefined literal 'ABCD....XYZ' to the stack
&m      % Check membership of each character in the input in this array and 
        % return an array that is 0 where it wasn't a letter and the index in 'ABC..XYZ'
        % when it was a letter
s       % Sum the resulting vector
y       % Duplicate the product of the sums of digits result
=       % Compare to the sum of letter indices result
w       % Flip the top two stack elements
Q       % Add one to this value (N)
t:      % Duplicate and compute the array [1...N]
q       % Subtract 1 from this array to yield [0...N-1]
U       % Square all elements to create all perfect squares between 1 and N^2
m~      % Check to ensure that N is not in the array of perfect squares
v       % Vertically concatenate the stack.
        % Implicitly display the truthy/falsey result

Python 2 2，120 118字节

s=t=p=0;r=1
for n in input():
 h=int(n,36)
 if h>9:s+=h-9;r*=t**p
 p=h<10;t=(t+h)*p
print(s==r*t**p)&(int(s**.5)**2<s)

在线尝试！

在base-36（h）中将每个字符解释为数字。转换为小数并在h>9（如果是字母）时加到总和，否则加到一个变量，该变量在以后乘以形成正在运行的乘积。

Perl 5，80个字节

79个字节的代码+ -p标志。

$.*=eval s/./+$&/gr for/\d+/g;$t-=64-ord for/\pl/g;$_=$.==$t&&($.**.5|0)**2!=$.

在线尝试！

$.*=eval s/./+$&/gr for/\d+/g;乘以连续数字的总和。（我使用$.它是因为它的初始值为1，这意味着它是乘法的中性元素）。更准确地说，对于每个数字位（for/\d+/g），在每个数字前s/./+$&/gr放置一个+，然后对字符串进行eval求和，然后乘以当前乘积。
其次，$t-=64-ord for/\pl/g;在资金$t每个字母（for/\pl/g）。（ord返回字母的ascii码，并64-..使其介于1到26之间。
最后，$.==$t检查两个值是否相同，并且($.**.5|0)**2!=$.它也不是一个完美的平方。

Python 2中，267个 207字节

^{多亏了ovs，节省了60个字节}

import re
def g(l):a=reduce(lambda a,b:a*b,[sum(map(int,list(i)))for i in re.sub(r'\D',' ',l).split()],1);return a==sum(sum(k)for k in[[ord(i)-64for i in x]for x in re.sub(r'\d',' ',l).split()])and a**.5%1>0

功能用法： print(g('A1B2C3'))

在线尝试！

Python 3中，163个156 155 164 161字节

from math import*
m=1;s=t=p=0
for x in input():
 try:t+=int(x);p=1
 except:m*=[1,t][p];p=t=0;s+=ord(x.upper())-64
if p:m*=t
print(m==s and sqrt(m)!=int(sqrt(m)))

在线尝试！

• 节省了7个字节，这要归功于Jonathan和Shooqie
• 已保存1个字节：还修复了误报问题。感谢乔纳森指出！
• 增加了11个字节：上次编辑是错误的（数字总和的乘法正在不必要的循环中进行）

视网膜，143字节

返回1表示true，0表示false

[1-9]
$ *
10 | 01
1个
S_`（\ D）
O`
{`1（？= 1 * \ n（1+））
$ 1
）2 =`1 + \ n

[JS]
1 $ +
[TZ]
2 $ +
T`0L`ddd
1>`\ d + \ n？
$ *
^（（？（1）（（？（2）\ 2（11）| 111））| 1））* \ n

^（1 *）\ n \ 1 $

在线尝试！

说明：

[1-9]
$ *
10 | 01
1个

首先，我们将所有非零数字替换为其一进制表示形式。我们删除任何带有相邻数字的零，以便它们不会影响我们的一元运算

S_`（\ D）

将结果字符串拆分为字母，请小心以排除空行（这是两个字母连续时的问题AA）。

O`
{`1（？= 1 * \ n（1+））
$ 1
）2 =`1 + \ n

按字典顺序对字符串进行排序。然后重复执行以下操作：

1）用下一行1的1s 数替换每个（模拟乘法）

2）删除1s 的第二行

[JS]
1 $ +
[TZ]
2 $ +
T`0L`ddd

替换字母J-S用1J，1K等，代替字母T-Z用2T，2U等等。然后，代替每个组A-I，J-S以及T-Z用1-9。我们将留下每一个字母（例如的数值13为M）。

1>`\ d + \ n？
$ *

将除第一行以外的每一行都转换为一元（第一行已经在一元中）。连接这些行。现在剩下的是形式为的字符串<product of digits>\n<sum of letters>。

^（（？（1）（（？（2）\ 2（11）| 111））| 1））* \ n

用空字符串替换一个平方数。这使用“差异树”方法。

^（1 *）\ n \ 1 $

1如果\n匹配双方的两个字符串都返回。否则，返回0。