न्यूमेरोलॉजी कैलकुलेटर

19

इस चुनौती का लक्ष्य वर्णों और संख्याओं के तार से एक प्रकार के अंक विज्ञान की गणना करना है ।

  • इनपुट किसी भी सुविधाजनक विधि (मानक इनपुट, तर्क, पृथक फ़ाइल) के माध्यम से हो सकता है।
  • इनपुट किसी भी प्रिंट योग्य ASCII वर्ण हो सकती है, लेकिन सिर्फ़ शब्द व संख्या ( A-Z, a-z, और 0-9) पर विचार करना होगा।
  • उत्पादन अंक के बीच होना चाहिए 1और 9या एक स्टार *अगर कोई पत्र और कोई अंकों ... जहां पाया (या यहां तक कि 0इनपुट के किसी भी संख्या को नियंत्रित करता है, तो 0 और कुछ नहीं है, लेकिन यह बात नहीं करता है)।

  • पत्र मानों को इस तरह से मैप किया जाता है:

    1  2  3  4  5  6  7  8  9
a  b  c  d  e  f  g  h  i
j  k  l  m  n  o  p  q  r
s  t  u  v  w  x  y  z

  • अंकज्योतिष अंकों स्ट्रिंग में से प्रत्येक के मूल्य जोड़कर गणना की जाती है, तो दोहराते रहें जब तक वहाँ केवल एक ही अंकों है। के लिए नमूना 13579, Hello, world!, 00 0 00, !@#$%^&*();, और 3.141592:

    13579 => 1 + 3 + 5 + 7 + 9 = 25 => 2 + 5 = 7
Hello, world! => 8 + 5 + 3 + 3 + 6 + 5 + 6 + 9 + 3 + 4 = 52 => 5 + 2 = 7
00 0 00 => 0 + 0 + 0 + 0 + 0 = 0
!@#$%^&*(); => *
  => *
3.141592 => 3 + 1 + 4 + 1 + 5 + 9 + 2 = 25 => 2 + 5 = 7
3.1415926535897932384 => 
 3 + 1 + 4 + 1 + 5 + 9 + 2 + 6 + 5 + 3 + 5 + 8 + 9 + 7 + 9 + 3 + 2 + 3 + 8 + 4
 = 97 => 9 + 7 = 16 => 1 + 6 = 7

    (यह बहुत अच्छा है, इस नमूने के अधिकांश दे 7! लेकिन यह सिर्फ नमूना है;)

    कुछ और परीक्षण:

    Bob  => 2 + 6 + 2 = 10 => 1 + 0 = 1
Charlie => 3 + 8 + 1 + 9 + 3 + 9 + 5 = 38 => 3 + 8 = 11 => 1 + 1 = 2
Anna => 1 + 5 + 5 + 1 = 12 => 1 + 2 = 3
Fana => 6 + 1 + 5 + 1 = 13 => 1 + 3 = 4
Gregory => 7 + 9 + 5 + 7 + 6 + 9 + 7 = 50 => 5 + 0 = 5
Denis => 4 + 5 + 5 + 9 + 1 = 24 => 2 + 4 = 6
Erik => 5 + 9 + 9 + 2 = 25 => 2 + 5 = 7
Helen => 8 + 5 + 3 + 5 + 5 = 26 => 2 + 6 = 8
Izis => 9 + 8 + 9 + 1 = 27 => 2 + 7 = 9

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

भाषा द्वारा सबसे कम

कोड स्निपेट दिखाएं

code-golf 
— एफ। होरी
स्रोत
0 किसी और चीज़ में जोड़े जाने पर गायब हो जाएगा
— F. Hauri
0 प्रासंगिक नहीं है! प्रासंगिक उत्पादन 1और के बीच है 9!
— एफ। होरी
क्या आप बिना अल्फ़ान्यूमेरिक वर्णों के कुछ उदाहरण जोड़ सकते हैं?
— ETHproductions
1
मेरा मतलब कुछ ऐसा है !@#$%^&*(); कुछ जो लौटना चाहिए *।
— ETHproductions
मनी क्षेत्र पर कुछ तकनीकी-विश्लेषण चर्चाओं में इस का हवाला देते हुए इसका विरोध करना बहुत कठिन रहा है ...
— पीपी

जवाबों:

6

मतलाब, 121 बाइट्स

s=[input('','s'),'*'];while nnz(s)>1;s=num2str(sum(mod([s(48<s&s<58)-4,s(96<s&s<123)+2,s(64<s&s<91)-2],9)+1));end;disp(s)

मतलब सिर्फ तार के लिए नहीं बना है = ((

— flawr
स्रोत
3
अरे, कम से कम यह
— माँ के
मेरे +1, मैं बेहतर नहीं कर सका। btw, क्या dispबयान देना आवश्यक है ?
— brainkz
@ बीब्रींक शायद, लेकिन मैं आमतौर पर इसे सुरक्षित पक्ष पर होने के लिए
— उकसाता हूं
3

गणितज्ञ, 174 168 163 बाइट्स

Catch[#-9Floor[Max[#-1,1]/9]&@If[(a=Tr[Characters@#/.{(b=a_String)?DigitQ:>FromDigits@a,b?LetterQ:>LetterNumber@a~Mod~9,b->0}])<1&&#~StringFreeQ~"0",Throw@"*",a]]&

पहला कदम रखता है, फिर डिजिटल रूट की गणना करता है।

— LegionMammal978
स्रोत
3

रूबी, 97 74 वर्ण

n=->s{(t=eval s.tr('a-z9A-Z','1-9'*6).scan(/\d/)*?+)&&t>9?n[t.to_s]:t||?*}

नमूना रन:

2.1.5 :001 > n=->s{(t=eval s.tr('a-z9A-Z','1-9'*6).scan(/\d/)*?+)&&t>9?n[t.to_s]:t||?*}
 => #<Proc:0x00000001b4b3f0@(irb):4 (lambda)> 

2.1.5 :002 > puts ['13579', 'Hello, world!', '00 0 00', '!@#$%^&*();', ' ', '3.141592', '3.1415926535897932384', 'Bob', 'Charlie', 'Anna', 'Izis'].map{|s|'%s : %s'%[n[s],s]}
7 : 13579
7 : Hello, world!
0 : 00 0 00
* : !@#$%^&*();
* :  
7 : 3.141592
7 : 3.1415926535897932384
1 : Bob
2 : Charlie
3 : Anna
9 : Izis
— आदमी काम पर है
स्रोत
3

पर्ल, 91 89 76 74 बाइट्स

73 + 1 -pस्विच के लिए

s/[a-z]/(ord($&)%32-1)%9+1/eig;$t="*",s/\d/$t+=$&/eg,$_=$t until/^[*\d]$/

टेस्ट

for test in '13579' 'Hello, world!' '00 0 00' '!@#$%^&*();' ' ' \
    '3.141592' '3.1415926535897932384' \
    Bob Charlie Anna Fana Gregory Denis Erik Helen Izis ;do  
    perl -pe '
      s/[a-z]/(ord($&)%32-1)%9+1/eig;$t="*",s/\d/$t+=$&/eg,$_=$t until/^[*\d]$/
      ' < <(echo -n "$test")
    echo "  $test"
done
7  13579
7  Hello, world!
0  00 0 00
*  !@#$%^&*();
*   
7  3.141592
7  3.1415926535897932384
1  Bob
2  Charlie
3  Anna
4  Fana
5  Gregory
6  Denis
7  Erik
8  Helen
9  Izis

2 14 16 15 17 वर्णों को बचाने में मेरी मदद करने के लिए धन्यवाद @manatwork !!

... मैंने सोचा है: N % 32 + Yबदल सकते हैं( N & 31 ) + Y !

— एफ। होरी
स्रोत
1
यदि आप पूरे मिलान किए गए विकल्प को पकड़ते हैं, $1तो बराबर है $&। इसलिए बेहतर कैप्चरिंग हटाएं और परिवर्तनशील नाम बदलें।
— मैनेटवर्क
1
whileका ब्लॉक हो सकता है $t="*";s/\d/$t+=$&/eg;$_=$t।
— मैनटवर्क
1
क्षमा करें, लेकिन इसका वास्तव में 1 वर्ण लंबा है, क्योंकि आपको -pगिनती में स्विच शामिल करना चाहिए ।
— मैनटवर्क
1
फिर से क्षमा करें (इस बार बड़ा खेद है), लेकिन यह एकल गैर-शब्द वर्ण इनपुट पर विफल रहता है, उदाहरण के लिए "!" परिणाम समान है! "। ( काम करने के लिए लगता है क्योंकि यहाँ-स्ट्रिंग के साथ इनपुट हमेशा एक अनुगामी न्यूलाइन के साथ पास किया जाता है, इसलिए आपके परीक्षण मामलों में कभी भी एकल वर्ण इनपुट नहीं है। echo -n "$test" | perl -pe '…'यह देखने के लिए उपयोग करें कि मेरा क्या मतलब है।) आप इसे whileस्थिति को बदलकर हल कर सकते हैं !/^[\d*]$/। वहाँ, स्कोर नुकसान को कम करने के दौरान, आप पूरे जगह ले सकती whileइस के साथ: $t="*",s/\d/$t+=$&/eg,$_=$t until/^[\d*]$/।
— मैनटवर्क
1
एक और सुधार है जो आप कर सकते हैं। के रूप &में कम पूर्वता है +, जबकि %उच्चतर है, परिवर्तन &31→ %32और आप उस उपपरिवर्तन के आसपास कोष्ठक हटा सकते हैं।
— मैनटवर्क
3

ईएस 6, 98 बाइट्स

s=>(m=s.match(/[1-9a-z]/gi))?(t=8,m.map(c=>t+=c>'@'?c.charCodeAt()&31:+c),t%9+1):/0/.test(s)?0:'*'

Ungolfed:

function(s) {
    var m = s.match(/[1-9a-z]/gi);
    if (m) {
        var t = 0;
        for (var i = 0; i < m.length; i++) {
            if (m[i] > '@')
                t += m[i].charCodeAt(0) & 31;
            else
                t += parseInt(m[i]);
        }
        return t % 9 || 9;
    }
    return /0/.test(s) ? 0 : "*";
}

94-बाइट संस्करण जो केवल छोटे तारों पर काम करता है:

s=>(m=s.match(/[1-9a-z]/gi))?m.map(c=>c>'@'?c.charCodeAt()&31:c).join``%9||9:/0/.test(s)?0:'*'

उपयोग करना match, mapऔर दो बार joinउपयोग करने से छोटा हो replaceगया:

s=>(m=s.replace(/[^1-9a-z]/gi,''))?m.replace(/[a-z]/gi,c=>c.charCodeAt()&31)%9||9:/0/.test(s)?0:'*'

इसे यहाँ टेस्ट करें: https://jsbin.com/zizosayisi/edit?js,console

— नील
स्रोत
यह इनपुट के लिए काम नहीं करता है00 0 00
— rink.attenders.6
@ rink.attendant.6 आह, आरईपीएल मैं सिर्फ प्रिंट उपयोग कर रहा था ["0"]के रूप में 0तो मैं अंतर नहीं बता सकते हैं।
— नील
बहुत, @ rink.attenders.6 संस्करण से बहुत बेहतर! चतुर गोल्फ हैक का इस्तेमाल किया। क्या आप समझा सकते हैं > '@', & 31और || 9?
— पावलो
1
@Pavlo > '@'सिर्फ अक्षरों और संख्याओं के बीच अंतर करता है। & 31ऊपरी और निचले मामले के चरित्र कोड के बीच अंतर को अनदेखा करने का एक उपयोगी तरीका है, क्योंकि यह आसानी से 1..26 मूल्यों में चरित्र कोड को सीधे मैप करता है। || 9का उपयोग किया जाता है क्योंकि % 99 के गुणकों के लिए 0 लौटाता है लेकिन बार-बार अंकों को जोड़ने पर 9 के गैर-शून्य गुणकों के लिए 9 (t + 8) % 9 + 1आता है। गोल्फ कोड में मैं इसके बजाय का उपयोग करता हूं जो एक ही चीज के लिए आता है।
— नील
भाषा को आमतौर पर "जावास्क्रिप्ट (
— ईएस 6
2

161 वर्ण

*=@n{*}
n:\A=@set{t;};<L1>=@set{t;@add{$t;@add{@mod{@sub{@mod{@char-int{$0};32};1};9};1}}};<D1>=@set{t;@add{$t;$0}};?=;\Z=@cmps{$t;;;\*;@cmpn{$t;9;$t;$t;@n{$t}}}

(केवल पुनरावर्ती डोमेन कॉल काम करने की कोशिश करने के लिए लिखा गया है।)

नमूना रन:

bash-4.3$ for input in '13579' 'Hello, world!' '00 0 00' '!@#$%^&*();' ' ' '3.141592' '3.1415926535897932384'; do
>     echo -n "'$input' : "
>     gema '*=@n{*};n:\A=@set{t;};<L1>=@set{t;@add{$t;@add{@mod{@sub{@mod{@char-int{$0};32};1};9};1}}};<D1>=@set{t;@add{$t;$0}};?=;\Z=@cmps{$t;;;\*;@cmpn{$t;9;$t;$t;@n{$t}}}' <<< "$input"
>     echo
> done
'13579' : 7
'Hello, world!' : 7
'00 0 00' : 0
'!@#$%^&*();' : *
' ' : *
'3.141592' : 7
'3.1415926535897932384' : 7
— आदमी काम पर है
स्रोत
1

जावास्क्रिप्ट (ईएस 6), 162 159 157 बाइट्स

f=_=>{for(_=_.replace(/\W+/g,''),g=$=>''+[...$.toUpperCase()].reduce((p,a)=>isNaN(a)?p+(a.charCodeAt()-64)%9:+a+p,0);1<(l=_.length);_=g(_));return!l?'*':g(_)}

फिर भी बाहरी फ़ंक्शन में निहित वापसी का उपयोग करने का एक तरीका खोजने की कोशिश कर रहा है।

अघोषित + अयोग्य

f = str => {
  str = str.replace(/\W+/g, '');
  recursiveFunc = $ => String([...$.toUpperCase()].reduce(
    (prev, val) => isNaN(val) ? prev + (val.charCodeAt() - 64) % 9 : Number(val) + prev,
    0
  ));
  while (1 < (len = str.length)) {
    str = recursiveFunc(str);
  }
  return len === 0 ? '*' : recursiveFunc(str)
}
  1. सभी गैर-अल्फ़ान्यूमेरिक वर्णों की स्ट्रिप्स
  2. किसी फ़ंक्शन को पुनरावर्ती रूप से उनके संबंधित मानों को कम करने के लिए कॉल करता है जबकि स्ट्रिंग 1 वर्ण से अधिक लंबी होती है।
    1. ASCII कोड के साथ आसानी से काम करने के लिए स्ट्रिंग को अपरकेस में परिवर्तित करता है
    2. प्रसार ऑपरेटर का उपयोग करके सरणी में कनवर्ट करें और एक संचायक चलाएं
    3. isNaNयदि यह संख्या नहीं है, तो जांच करने के लिए वैश्विक फ़ंक्शन (जो इसके इनपुट को काटता है) का उपयोग करें
      • यदि यह नहीं है, तो संबंधित मान प्राप्त करने के लिए ASCII कोड और मॉड 9 में कनवर्ट करें
      • यदि यह एक संख्या है, तो इसे कास्ट करें
  3. यदि लंबाई 0 है, तो कोई अल्फ़ान्यूमेरिक वर्ण मौजूद नहीं थे (तारांकन वापसी), अन्यथा पुनरावर्ती फ़ंक्शन का आउटपुट लौटाएं।
— rink.attendant.6
स्रोत
यह ब्रेक नियम 00 0 00, आउटपुट के *बजाय 0!
— एफ। होरी डेसी
@ एफ.हौरी फिक्स्ड।
— rink.attenders.6 11
आप कॉमन ऑपरेटर का उपयोग करके स्पष्ट वापसी से बच सकते हैं: _=>{expr;return expr}=>_=>(expr,expr)
— Pavlo
@Pavlo मैं अपने मामले में कैसे आवेदन करूं?
— rink.attenders.6
मेरे लिए काम नहीं करता है, SyntaxError
— Pavlo
1

हास्केल, 126 बाइट्स

l x=[n|(c,n)<-zip(['0'..'9']++['a'..'z']++'\0':['A'..'Z'])$0:cycle[1..9],c==x]
g[]="*"
g[x]=show x
g x=f$show$sum x
f=g.(l=<<)

उपयोग: f "Hello, world!"-> "7"।

lवर्णों की सूची के लिए पूर्णांक तालिका (सिंगलटन सूची, यदि वर्ण पाया जाता है, तो रिक्त सूची अन्यथा) है। fयह तर्क के प्रत्येक चार्ट को देखता है और सूचियों की लौटी हुई सूची को पूर्णांकों की एक सरल सूची में समतल करता है और gअंतिम स्थिति (खाली सूची (-> *) या एकल पूर्णांक) की जांच करने के लिए कॉल करता है या fदूसरे दौर के लिए सूची के योग के साथ कॉल करता है।

— nimi
स्रोत
1

MATL , 64 बाइट्स

jk42ht`YUt'[a-z]'XXY}3+w'[1-9]'XXY}6+h,9X\st9>]w2Y24Y2h!=~?x'*']

यह भाषा के वर्तमान संस्करण (4.0.0) का उपयोग करता है ।

मुझे लग रहा है कि इसे छोटा किया जा सकता है ...

परीक्षण के मामलों

>> matl
 > jk42ht`YUt'[a-z]'XXY}3+w'[1-9]'XXY}6+h,9X\st9>]w2Y24Y2h!=~?x'*']
 > 
> 13579
7

>> matl
 > jk42ht`YUt'[a-z]'XXY}3+w'[1-9]'XXY}6+h,9X\st9>]w2Y24Y2h!=~?x'*']
 > 
> Hello, world!
7

>> matl
 > jk42ht`YUt'[a-z]'XXY}3+w'[1-9]'XXY}6+h,9X\st9>]w2Y24Y2h!=~?x'*']
 > 
> 00 0 00
0

>> matl 
 > jk42ht`YUt'[a-z]'XXY}3+w'[1-9]'XXY}6+h,9X\st9>]w2Y24Y2h!=~?x'*']
 > 
> !@#$%^&*();
*

>> matl
 > jk42ht`YUt'[a-z]'XXY}3+w'[1-9]'XXY}6+h,9X\st9>]w2Y24Y2h!=~?x'*']
 > 
> 3.141592
7

>> matl
 > jk42ht`YUt'[a-z]'XXY}3+w'[1-9]'XXY}6+h,9X\st9>]w2Y24Y2h!=~?x'*']
 > 
> 3.1415926535897932384
7

>> matl
 > jk42ht`YUt'[a-z]'XXY}3+w'[1-9]'XXY}6+h,9X\st9>]w2Y24Y2h!=~?x'*']
 > 
> Bob
1

>> matl
 > jk42ht`YUt'[a-z]'XXY}3+w'[1-9]'XXY}6+h,9X\st9>]w2Y24Y2h!=~?x'*']
 > 
> Charlie
2

>> matl
 > jk42ht`YUt'[a-z]'XXY}3+w'[1-9]'XXY}6+h,9X\st9>]w2Y24Y2h!=~?x'*']
 > 
> Anna
3

>> matl
 > jk42ht`YUt'[a-z]'XXY}3+w'[1-9]'XXY}6+h,9X\st9>]w2Y24Y2h!=~?x'*']
 > 
> Izis
9
— लुइस मेंडो
स्रोत
दुर्भाग्य से, मैं अपने नमूने का परीक्षण नहीं कर सका। कृपया हाल ही में जोड़े गए परीक्षणों (क्षमा करें) सहित पूरे परीक्षण मामलों को पोस्ट करें।
— एफ। हरूई
@ F.Hauri हां, आपको इनका परीक्षण करने के लिए मतलाब की आवश्यकता होगी। इसके बारे में क्षमा करें, अभी तक कोई ऑनलाइन संकलक नहीं है। मैंने परीक्षण मामलों को जोड़ा है
— लुइस मेंडू
1

गंभीरता से, 50 बाइट्स

,$ù;ú1╤▀+;#pX╗@-@-;Y`'*.`╬X1WX`╜í;s9*@%u`MΣ$;lDWX

हेक्स डंप:

2c24973ba331d1df2b3b237058bb402d402d3b5960272a2e7f
60ce5831575860bda13b73392a402575604de4243b6c445758

यह ऑनलाइन की कोशिश करो

व्याख्या की:

,$ù                                               Read input, make it a string, lowercase
    ú                                             Push lowercase alphabet
     1╤▀+                                         Prepend base 10 digits.
         ;#pX╗                                    Remove "0" from a copy and stash in reg0
   ;          @-                                  Remove alphanumerics from input copy
                @-                                Remove nonalphanumerics from input
                  ;Y                              Push 1 if string is empty, else 0
                    `'*.`╬                        If top is truthy, output * and halt
                          X                       Discard boolean
                           1                      Push 1 to enter loop
                            WX                 WX Loop while top of stack is truthy
                              `         `M        Map this function over the string
                               ╜                  Push alphanumeric string from reg0
                                í                 Push index of this char in it
                                 ;s9*             Push 9 if found, else -9
                                     @%u          Take index mod previous: this yields the
                                                  correct conversion from the numerology
                                          Σ       Sum the resulting digits.
                                           $      Convert the sum to a string.
                                            ;lD   push 1 less than its length
— quintopia
स्रोत
@ F.Hauri "ऑनलाइन प्रयास करें" पर क्लिक करें। अपने परीक्षण मामलों को इनपुट बॉक्स में दर्ज करें।
— क्विंटोपिया
1

शुद्ध बैश, 199 194 बाइट्स

eval a+={a..z};r="$1";while [ "${r:1}" ];do o=;for ((i=0;i<${#r};i++));do
l=${r:i:1};case $l in [a-zA-Z])d=${a%${l,}*};((o+=$((${#d}%9+1))));;[0-9])
((o+=l));;esac;done;r="$o";done;echo "${o:-*}"

(दूसरी लाइन ब्रेक केवल स्क्रॉलबार से बचने के लिए है)

टेस्ट नियम:

numerology() {
    eval a+={a..z};
    r="$1";
    while [ "${r:1}" ]; do
        o=;
        for ((i=0; i<${#r}; i++))
        do
            l=${r:i:1};
            case $l in 
                [a-zA-Z])
                    d=${a%${l,}*};
                    ((o+=$((${#d}%9+1))))
                ;;
                [0-9])
                    ((o+=l))
                ;;
            esac;
        done;
        r="$o";
    done;
    echo "${o:-*}"
}

for test in '13579' 'Hello, world!' '00 0 00' '!@#$%^&*();' ' ' \
            '3.141592' '3.1415926535897932384'\
            Bob Charlie Anna Fana Gregory Denis Erik Helen Izis ;do
    echo "$(numerology "$test")" $test
done

7 13579
7 Hello, world!
0 00 0 00
* !@#$%^&*();
*
7 3.141592
7 3.1415926535897932384
1 Bob
2 Charlie
3 Anna
4 Fana
5 Gregory
6 Denis
7 Erik
8 Helen
9 Izis
— एफ। होरी
स्रोत
1

जावास्क्रिप्ट (ईएस 6), 78 83

पुनरावर्ती समाधान। पूंछ पुनरावृत्ति होने के कारण, चर टी और आर को स्थानीय नहीं होना चाहिए।

f=x=>(t=r=0,x.replace(/\w/g,d=>t+=1+~-parseInt(d,r=36)%9),t>9?f(''+t):r?t:'*')

व्याख्या की

f=x=>(
  t = 0, // set initial value of counter to 0 
  r = 0, // flag to verify that we found at last one alphanumeric chars
  x.replace(/\w/g, d => ( // execute the following for each alphanumeric character
    // t += 1 + ~-parseInt(d,r=36) % 9 explained below
    r = 36, // set flag, could be any nonzero value
    d = parseInt(d,36), // convert to numeric. a..z -> 10..25, case insensitive.
    d = 1 + (d-1) % 9, // this is the arithmetic conversion required (
                       // works also with 0 because the strange implementation of % in javascript for negative numbers
    t = t + d // add to global counter
  ) ), 
  t > 9 // if t > 9 then we found some alphanumeric char, but we must repeat the loop on t
    ? f(''+t) // recursive call, t is numeric and must become a string
    : r // check flag r 
      ? t // if alphanumeric found, return t 
      : '*' // else return '*'
)

टेस्ट स्निपेट

f=x=>(t=r=0,x.replace(/\w/g,d=>t+=1+~-parseInt(d,r=36)%9),t>9?f(''+t):r?t:'*')

console.log=x=>O.textContent+=x+'\n';

;[['13579',7],['Hello, world!',7],['00 0 00',0],['!@#$%^&*();','*'],
['3.141592',7],['3.1415926535897932384',7],
['Bob', 1],['Charlie', 2],['Anna', 3],['Fana', 4],['Gregory', 5],
['Denis', 6],['Erik', 7],['Helen', 8],['Izis', 9]]
.forEach(t=>{
  i=t[0]+''
  k=t[1]
  r=f(i)
  console.log(i+' -> ' + r + (k==r? ' OK':' Fail - expected '+k))
  })
<pre id=O></pre>
स्निपेट का विस्तार करें

— edc65
स्रोत
0

गणितज्ञ, 133 बाइट्स

f[s_]:= ToCharacterCode@ToUpperCase@s-64/.{a_/;17>-a>6:>a+16,b_/;b<1||b>26:>""}//If[Or@@NumberQ/@#,Tr@#/.""->0//.a_:>Tr@IntegerDigits@a,"*"]&

LegionMammal978 के ऊपर से थोड़ा अलग। मेरा कार्य सब कुछ एक चरित्र कोड में बदल देता है, फिर गैर-अल्फ़ान्यूमेरिक चीजों (उन्हें खाली तारों के साथ प्रतिस्थापित करना) को फ़िल्टर करता है। यदि अल्फ़ान्यूमेरिक्स नहीं हैं, तो यह * लौटता है, अन्यथा यह डिजिटल रूट लेता है। अगर मैं ऑल-जीरो-स्ट्रिंग मामले से निपटना नहीं चाहता तो यह काफी (~ 15 बी) छोटा हो सकता है। C'est la vie।

गणितज्ञ जादू, बिना किसी के लिए: foo//.a_:>Tr@IntegerDigits@aएक दोहराया प्रतिस्थापन है: यह aफू में किसी भी संख्या को उनके अंकों के योग के साथ बदल देता है, फिर इसे फिर से बदल देता है जब तक कि यह एक निश्चित बिंदु को हिट नहीं करता, अर्थात aप्रतिस्थापन के तहत बदलना बंद कर देता है।

टेस्ट:

f /@ {"13579", "Hello,world!", "00 0 00", "!@#$%^&*()", "3.141592","3.1415926535897932384"}
     => {7, 7, 0, "*", 7, 7}
f /@ {"Bob", "Charlie", "Anna", "Fana", "Gregory", "Denis", "Erik",  "Helen", "Izis"}
     => {1, 2, 3, 4, 5, 6, 7, 8, 9}
— hYPotenuser
स्रोत
दुर्भाग्य से, मैं अपने नमूने का परीक्षण नहीं कर सका। कृपया परीक्षण के मामले दर्ज करें
— F. Hauri
रास्ते में हूं। परीक्षणों को एक साथ रखते हुए, मैंने कुछ टाइपो को ठीक करने के लिए भी पाया है। धन्यवाद;)
— hYPotenuser
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.