नोट: यह @Willbeing के इस सवाल से प्रेरित है जहां कार्य एक निश्चित लंबाई की सही प्लेटों की संख्या की गणना करना था, लेकिन यह थोड़ा अलग है।

हम उस प्लेट को एक सही लाइसेंस प्लेट कहते हैं जिसका पाठ निम्नलिखित शर्तों को पूरा करता है:

इसमें वर्ण होते हैं, जो या तो अक्षर ( [A-Z]) या अंक ( [0-9]) हो सकते हैं
अंग्रेजी वर्णमाला में इसके अक्षरों की स्थिति को समेटते हुए, 1-अनुक्रमित (यानी A=1,B=2,...,Z=26:) एक पूर्णांक n देता है
अंकों के प्रत्येक भाग को प्राप्त करना, उन्हें समेटना और फिर सभी परिणामों को गुणा करना एक ही परिणाम देता है, एन
n एक पूर्ण वर्ग है (उदाहरण के लिए: 49 ( ) ^२ ) , 16 (४ ^२ ) )

एक लगभग पूर्ण लाइसेंस प्लेट , एक आदर्श लाइसेंस प्लेट के लिए शर्तों को पूरा करता सिवाय इसके कि 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!

स्कोरिंग

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम जवाब जीतता है!

— मिस्टर एक्सकोडर
स्रोत

लोकप्रियता-प्रतियोगिता

— मैथ्यू रो

मुझे लगता है कि यह कोड-गोल्फ के रूप में बेहतर होगा ।

— आउटगोल्फर

मुझे यकीन है कि मैं यह समझ सकता हूँ। हम केवल उत्पादन truthy अगर लाइसेंस प्लेट एकदम सही है और nहै नहीं एक पूर्ण वर्ग?

— गणित दीवाने

@ मैथजंकी हां। TL; DR: केवल अगर लाइसेंस लगभग सही है (देर से प्रतिक्रिया के लिए PS खेद)

— श्री Xcoder

1

इससे पहले कि कोई भी ऐसा करे s/licence/license/ig, यह ध्यान रखें कि "लाइसेंस" ब्रिटिश अंग्रेजी (साथ ही दुनिया के अन्य हिस्सों में अंग्रेजी) की सही वर्तनी है।

— मेगो

7

जेली , 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

— जोनाथन एलन
स्रोत

वाह, प्रतिभा जेली समाधान!

— श्री एक्सकोडर

किस बारे में 11AA0?

— क्रिश्चियन सेवर्स

@ChristianSievers, अच्छी पकड़। एक अन्य के साथ फिक्स्ड, संबंधित प्रकार, बग और टेस्ट सूट का विस्तार।

— जोनाथन एलन

7

MATL, 36 34 33 35 बाइट्स

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

इसे MATL ऑनलाइन पर आज़माएं

व्याख्या

        % 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

— Suever
स्रोत

केवल शून्य से बनी प्लेटों के लिए झूठी सकारात्मक पैदावार, उदाहरण के लिए '0'या '00'(एफडब्ल्यूआईडब्ल्यू मैंने अभी तय किया है कि मेरे कोड में भी)।

— जोनाथन एलन

1

@JonathanAllan अपडेट किया गया।

— स्वेअर

6

पायथन 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)

इसे ऑनलाइन आज़माएं!

बेस -36 ( h) में एक नंबर के रूप में प्रत्येक वर्ण की व्याख्या करता है । दशमलव में रूपांतरित करता है और योग में जोड़ता है h>9( यदि यह एक अक्षर है), अन्यथा एक चर में जोड़ता है जो बाद में चल रहे उत्पाद को बनाने के लिए गुणा हो जाता है।

— गणित के दीवाने
स्रोत

4

पर्ल 5 , 80 बाइट्स

कोड + -pध्वज के 79 बाइट्स ।

$.*=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पत्र के लिए एससीआई कोड लौटाएं, और 64-..यह 1 और 26 के बीच होना चाहिए।
अंत में, $.==$tजाँचता है कि दोनों मान समान हैं, और ($.**.5|0)**2!=$.यह एक पूर्ण वर्ग नहीं है।

— बापू
स्रोत

4

अजगर 2, 267 207 बाइट्स

^{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'))

इसे ऑनलाइन आज़माएं!

— मिस्टर एक्सकोडर
स्रोत

कुछ छोटे सुधार

— १s को अंडा

4

पायथन 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 बाइट्स को बचाया और शौकी की बदौलत बचाए
1 बाइट को बचाया: साथ ही गलत पॉजिटिव इश्यू को भी फिक्स्ड किया। धन्यवाद जोनाथन कोइसे इंगित !
जोड़ा गया 11 बाइट्स: पिछला संपादन गलत था (अंकों की राशि का गुणा अवांछित लूप में चल रहा था)

— officialaimm
स्रोत

1

from math import*छोटा है

— shooqie

1

आप की जरूरत नहीं है a, बस का उपयोग करें for x in input():। आपके पास शून्य (जैसे 11AA00) की एक स्ट्रिंग के साथ समाप्त होने वाली प्लेटों के लिए गलत सकारात्मक हो सकते हैं , क्योंकि अंतिम m*=tनिष्पादित नहीं किया गया है।

— जोनाथन एलन

1

जाहिरा तौर पर, मेरा कोड किसी भी स्ट्रिंग के लिए झूठे पॉजिटिव को दिखाता है जिसमें अलग-थलग शून्य है (3A0B को भी सच दिखाया गया है) ... जो @JonathanAllan को इंगित करने के लिए धन्यवाद। मैं इसे ठीक करने की कोशिश करूंगा।

— अधिकारिक

नए संस्करण की जाँच करें ... मैंने अंकों के योग को गुणा करने या न करने के लिए एक नया ध्वज चर 'p' जोड़ा है।

— आधिकारिक 14

3

रेटिना, 143 बाइट्स

सत्य के लिए १, झूठ के लिए ०

[1-9]
$ *
10 | 01
1
S_` (\ डी)
हे `
{ `1 (? = 1 * \ N (1 +))
$ 1
) 2 = `1 + \ N

[जे एस]
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_` (\ डी)

अक्षरों पर परिणामी स्ट्रिंग को विभाजित करें, खाली लाइनों को बाहर करने के लिए सावधान रहें (यह एक समस्या है जब दो अक्षर लगातार होते हैं AA)।

हे `
{ `1 (? = 1 * \ N (1 +))
$ 1
) 2 = `1 + \ N

स्ट्रिंग को क्रमबद्ध रूप से क्रमबद्ध करें। फिर बार-बार निम्न कार्य करें:

1) प्रत्येक को निम्नलिखित पंक्ति 1में 1s की संख्या से बदलें (यह नकल गुणन)

2) की दूसरी पंक्ति निकालें 1रों

[जे एस]
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।

— गणित के दीवाने
स्रोत

आदि के लिए झूठी सकारात्मकता 11AA0,0AA11

— जोनाथन एलन

@JonathanAllan धन्यवाद! यह मुझे ठीक करने के लिए 11 बाइट्स की लागत है

— गणित नशेड़ी

लगभग सही लाइसेंस प्लेट्स का पता लगाएं

इनपुट

उत्पादन

उदाहरण

स्कोरिंग

जेली , 29 28 30 बाइट्स

कैसे?

MATL, 36 34 33 35 बाइट्स

पायथन 2, 120 118 बाइट्स

पर्ल 5 , 80 बाइट्स

अजगर 2, 267 207 बाइट्स

पायथन 3 , 163 156 155 164 161 बाइट्स

रेटिना, 143 बाइट्स