참고 : 이것은 @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!

채점

이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다!

젤리 , 29 28 30 바이트

버그를 해결하기 위해 1 바이트에 대한 잘못된 반응을 해결하기 위해 1 바이트 (잘못 만 제로의 문자열 처리) ChristianSievers에 의해 발견 "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

파이썬 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) 에서 각 문자를 숫자로 해석합니다 . 10 진수로 변환하고 합계 h>9(문자 인 경우)에 합산하고, 그렇지 않으면 나중에 곱을 곱하는 변수에 곱하여 나중에 실행중인 제품을 형성합니다.

펄 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/./+$&/gra +를 배치 한 다음 문자열을 eval사용하여 현재 제품과 곱합니다.
둘째, 각 문자의 $t-=64-ord for/\pl/g;합계 $t( for/\pl/g). ( ord문자의 ASCII 코드를 반환하고 64-..1에서 26 사이로 만듭니다.
마지막으로 $.==$t두 값이 모두 같은지, ($.**.5|0)**2!=$.완벽한 제곱이 아닌지 확인합니다.

파이썬 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'))

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

파이썬 3 , 163156155164161 바이트

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

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

• Jonathan 과 Shooqie 덕분에 7 바이트 절약
• 1 바이트 저장 : 또한 오 탐지 문제를 해결했습니다. 지적 해 주신 Jonathan 에게 감사합니다 !
• 11 바이트 추가 : 이전 편집이 잘못되었습니다 (자리 수의 곱셈이 원하지 않는 루프에서 진행 중임)

레티 나, 143 바이트

true는 1, false는 0

[1-9]
$ *
10 | 01
1
S_` (\ D)
오
{`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

먼저, 우리는 0이 아닌 모든 숫자를 단항 표현으로 대체합니다. 우리는 단항 연산에 영향을 미치지 않도록 인접한 숫자로 0을 제거합니다.

S_` (\ D)

빈 줄을 제외하도록주의하면서 결과 문자열을 문자로 분할합니다 (두 문자가 연속적 일 때 문제가 됨 AA).

오
{`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. 각 문자의 숫자 값이 남습니다 (예 : 13for M).

1>`\ d + \ n?
$ *

첫 번째 행을 제외한 모든 행을 단항으로 변환하십시오 (첫 번째 행은 이미 단항입니다). 이 줄들을 연결하십시오. 우리는 이제 형식의 문자열을 남겼습니다 <product of digits>\n<sum of letters>.

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

정사각형 번호를 빈 문자열로 바꿉니다. "차이 트리"방법을 사용합니다 .

^ (1 *) \ n \ 1 $

1양쪽의 두 문자열이 \n일치 하면 반환 합니다 . 그렇지 않으면를 반환하십시오 0.