หมายเหตุ:นี่เป็นแรงบันดาลใจจากคำถามนี้โดย@Willbeingโดยที่หน้าที่คือการนับจำนวนแผ่นที่สมบูรณ์แบบที่มีความยาวที่แน่นอน แต่มันแตกต่างกันเล็กน้อย

เราเรียกแผ่นป้ายทะเบียนที่สมบูรณ์ซึ่งมีข้อความตรงตามเงื่อนไขต่อไปนี้:

• ประกอบด้วยอักขระซึ่งอาจเป็นตัวอักษรตัวพิมพ์ใหญ่ ( [A-Z]) หรือตัวเลข ( [0-9])
• การรวมตำแหน่งของตัวอักษรในตัวอักษรภาษาอังกฤษ1 ดัชนี (เช่น:) A=1,B=2,...,Z=26จะให้จำนวนเต็มn
• ได้รับตัวเลขแต่ละอันรวมกันแล้วคูณผลลัพธ์ทั้งหมดให้ผลลัพธ์เดียวกันn
• nเป็นสี่เหลี่ยมจัตุรัสที่สมบูรณ์แบบ (เช่น: 49 (7 ² ) , 16 (4 ² ) )

แผ่นป้ายทะเบียนเกือบสมบูรณ์แบบตรงตามเงื่อนไขสำหรับแผ่นป้ายทะเบียนที่สมบูรณ์แบบยกเว้นว่าnคือไม่ได้ตารางที่สมบูรณ์แบบ

อินพุต

สตริงที่แสดงถึงข้อความของแผ่นป้ายทะเบียนซึ่งถูกใช้เป็นอินพุตในรูปแบบมาตรฐานใด ๆ ยกเว้นการเข้ารหัส

เอาท์พุต

หากสตริงที่กำหนดแสดงถึงป้ายทะเบียนที่เกือบสมบูรณ์แบบให้ส่งคืนค่าความจริง (เช่น: 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, 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วางที่+หน้าตัวเลขแต่ละตัวจากนั้นสตริงจะถูกevaluated และคูณด้วยผลิตภัณฑ์ปัจจุบัน
ประการที่สอง$t-=64-ord for/\pl/g;จำนวนเงินใน$tจดหมายแต่ละฉบับ ( for/\pl/g) ( ordส่งคืนรหัส ascii สำหรับจดหมายและ64-..ทำให้อยู่ระหว่าง 1 ถึง 26
ในที่สุด$.==$tตรวจสอบว่าค่าทั้งสองเหมือนกันและ($.**.5|0)**2!=$.ไม่เป็นสี่เหลี่ยมจัตุรัสที่สมบูรณ์แบบ

Python 2, 267 207 bytes

^{บันทึกแล้ว 60 ไบต์ด้วย 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

ฟังก์ชั่นที่มีการใช้งาน: 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 ไบต์: การแก้ไขก่อนหน้านี้ผิด (การคูณของผลรวมของตัวเลขเกิดขึ้นในลูปที่ไม่ต้องการ)

Retina, 143 ไบต์

ส่งคืน 1 สำหรับจริง, 0 สำหรับเท็จ

[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?
$ *

แปลงทุกบรรทัด แต่บรรทัดแรกเป็น unary (บรรทัดแรกมีอยู่แล้วพร้อมกัน) ต่อสายเหล่านี้เข้าด้วยกัน <product of digits>\n<sum of letters>เราจะเหลือในขณะนี้กับสตริงของรูปแบบ

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

แทนที่หมายเลขจตุรัสด้วยสตริงว่าง นี้จะใช้ความแตกต่าง "ต้นไม้" วิธีการ

^ (1 *) \ n \ $ 1

ส่งคืน1ถ้าทั้งสองสายที่ด้านใดด้านหนึ่งของการ\nแข่งขัน 0มิฉะนั้นกลับ