Lưu ý: Điều này được lấy cảm hứng từ câu hỏi này bởi @Willbeing , nơi nhiệm vụ là đếm số lượng tấm hoàn hảo có độ dài nhất định, nhưng nó hơi khác nhau.

Chúng tôi gọi một tấm giấy phép hoàn hảo mà tấm có văn bản thỏa mãn các điều kiện sau:

• Nó bao gồm các ký tự, có thể là chữ in hoa ( [A-Z]) hoặc chữ số ( [0-9])
• Tóm tắt vị trí của các chữ cái trong bảng chữ cái tiếng Anh, 1-index (tức là A=1,B=2,...,Z=26:) cho số nguyên n
• Lấy từng khối chữ số, tổng hợp chúng và sau đó nhân tất cả các kết quả cho cùng một kết quả, n
• n là một hình vuông hoàn hảo (ví dụ: 49 (7 ² ) , 16 (4 ² ) )

Một tấm giấy phép gần như hoàn hảo đáp ứng các điều kiện cho một biển số xe hoàn hảo, ngoại trừ việc n là không một hình vuông hoàn hảo.

Đầu vào

Một chuỗi đại diện cho văn bản của biển số xe, được lấy làm đầu vào dưới bất kỳ hình thức tiêu chuẩn nào, ngoại trừ mã hóa cứng.

Đầu ra

Nếu chuỗi đã cho đại diện cho một tấm giấy phép gần như hoàn hảo , hãy trả về một giá trị trung thực (ví dụ: True/ 1), nếu không thì trả về giá trị giả (ví dụ: False/ 0). Bất kỳ hình thức đầu ra tiêu chuẩn nào đều được chấp nhận trong khi lưu ý rằng sơ hở này đều bị nghiêm cấm.

Ví dụ

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!

Chấm điểm

Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte sẽ thắng!

Thạch , 29 28 30 byte

1 byte để sửa chữa một lỗi được phát hiện bởi ChristianSievers (sai đối phó với chuỗi con của chỉ số không) 1 byte để sửa chữa sai tích cực cho "0", "00", ... được tìm thấy trong sửa chữa trên (0 là một hình vuông hoàn hảo).

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

Hãy thử trực tuyến! hoặc chạy thử nghiệm

Làm sao?

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 byte

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

Dùng thử tại MATL Online

Giải trình

        % 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, 120 118 byte

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)

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

Giải thích mỗi ký tự là một số trong cơ sở-36 ( h). Chuyển đổi thành số thập phân và cộng vào tổng nếu h>9(có nghĩa là một chữ cái), nếu không thì thêm vào một biến được nhân lên để tạo thành sản phẩm đang chạy sau này.

Perl 5 , 80 byte

79 byte mã + -pcờ.

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

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

$.*=eval s/./+$&/gr for/\d+/g;nhân các tổng của các chữ số liên tiếp. (Tôi đang sử dụng $.vì giá trị ban đầu của nó là 1, có nghĩa là nó là phần tử trung tính cho phép nhân). Chính xác hơn, với mỗi khối chữ số ( for/\d+/g), s/./+$&/grđặt a +trước mỗi chữ số, sau đó chuỗi được evaltính và nhân với sản phẩm hiện tại.
Thứ hai, $t-=64-ord for/\pl/g;tổng trong $tmỗi chữ cái ( for/\pl/g). ( ordtrả lại mã ascii cho chữ cái và 64-..làm cho nó nằm trong khoảng từ 1 đến 26.
Cuối cùng, $.==$tkiểm tra xem cả hai giá trị có giống nhau không và ($.**.5|0)**2!=$.nó cũng không phải là một hình vuông hoàn hảo.

Python 2, 267 207 byte

^{Đã lưu 60 byte nhờ vào ovs}

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

Chức năng sử dụng: print(g('A1B2C3'))

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

Python 3 , 163 156 155 164 161 byte

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

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

• đã lưu 7 byte nhờ Jonathan và Shooqie
• đã lưu 1 byte: Cũng đã sửa lỗi dương tính giả. Cảm ơn Jonathan đã chỉ ra nó!
• đã thêm 11 byte: Chỉnh sửa trước đó là sai (phép nhân tổng số đang diễn ra trong một vòng lặp không mong muốn)

Võng mạc, 143 byte

Trả về 1 cho đúng, 0 cho sai

[1-9]
$ *
10 | 01
1
S_` (\ D)
Ôi
{`1 (? = 1 * \ n (1+))
$ 1
) 2 = `1 + \ n

[JS]
1 đô la +
[TZ]
2 đô la +
T'0L`ddd
1> `\ d + \ n?
$ *
^ ((? (1) ((? (2) \ 2 (11) | 111)) | 1)) * \ n

^ (1 *) \ n \ 1 $

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

Giải trình:

[1-9]
$ *
10 | 01
1

Đầu tiên, chúng tôi thay thế tất cả các chữ số khác không bằng biểu diễn đơn nhất của chúng. Chúng tôi xóa bất kỳ số 0 nào có chữ số liền kề để chúng không ảnh hưởng đến các hoạt động đơn nguyên của chúng tôi

S_` (\ D)

Tách chuỗi kết quả trên các chữ cái, cẩn thận để loại trừ các dòng trống (đây là vấn đề khi hai chữ cái liên tiếp AA).

Ôi
{`1 (? = 1 * \ n (1+))
$ 1
) 2 = `1 + \ n

Sắp xếp chuỗi theo từ vựng. Sau đó liên tục làm như sau:

1) Thay thế từng 1số bằng số 1s trên dòng sau (phép nhân này bắt chước)

2) Xóa dòng thứ hai của 1s

[JS]
1 đô la +
[TZ]
2 đô la +
T'0L`ddd

Thay thế chữ J-Svới 1J, 1Kvv và thay thế chữ T-Zvới 2T, 2Uvv Sau đó, thay thế từng nhóm A-I, J-Svà T-Zvới 1-9. Chúng ta sẽ để lại giá trị bằng số của mỗi chữ cái (ví dụ: 13for M).

1> `\ d + \ n?
$ *

Chuyển đổi mọi dòng nhưng dòng đầu tiên thành unary (dòng đầu tiên đã ở dạng unary). Nối các dòng này. Bây giờ chúng ta còn lại một chuỗi các hình thức <product of digits>\n<sum of letters>.

^ ((? (1) ((? (2) \ 2 (11) | 111)) | 1)) * \ n

Thay thế một số vuông bằng chuỗi trống. Điều này sử dụng phương pháp "cây khác biệt" .

^ (1 *) \ n \ 1 $

Quay trở lại 1nếu hai chuỗi ở hai bên của \ntrận đấu. Nếu không, trở lại 0.