命理计算器

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 
— 豪里
source
当添加到别的0将diseapear
— F. Hauri
0不相关！相关输出在1和之间9。
— F. Hauri
您能否添加一些不包含字母数字字符的示例？
— ETHproductions 2015年
1
我的意思是!@#$%^&*(); 应该返回的东西*。
— ETHproductions 2015年
很难在金钱领域的一些技术分析讨论中引用这一点……
— ；-p

Answers:

6

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

Matlab不适用于字符串=（

— 瑕疵
source
3
嘿，至少它不像Mma那样冗长：P
— LegionMammal978
我的+1，我做得更好。顺便说一句，是否有必要disp发表声明？
— brainkz 2015年
@brainkz也许可以，但是我通常会说它是安全的
— 虚伪的2015年
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]]&

进行第一步，然后计算数字根。

— 军团哺乳动物978
source
3

Ruby，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
— 工作的人
source
3

Perl，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

感谢@manatwork帮助我节省了2 14 16 15 17个字符！！

...我已经考虑过：N % 32 + Y可以取代( N & 31 ) + Y！

— 豪里
source
1
如果捕获整个匹配的子字符串，$1则等于$&。因此最好删除捕获并更改变量名称。
— manatwork，2013年
1
while的障碍可能是$t="*";s/\d/$t+=$&/eg;$_=$t。
— manatwork 2015年
1
抱歉，它实际上要长1个字符，因为您应该-p在计数中包括该开关。
— manatwork 2015年
1
再次抱歉（这次比较抱歉），但是在单个非单词字符输入上失败，例如“！”的结果与“！”相同。（似乎有效，因为使用here-string时，输入始终以尾随换行符传递，因此在您的测试用例中，永远不会传递单个字符输入。echo -n "$test" | perl -pe '…'请看我的意思。）您可以通过将while条件更改为来解决此问题!/^[\d*]$/。在此处，为减少分数损失，您可以使用来代替整个while：$t="*",s/\d/$t+=$&/eg,$_=$t until/^[\d*]$/。
— manatwork 2015年
1
您还可以进行另一项改进。由于&优先级低于+，而优先级%较高，请更改&31→，%32然后可以删除该子表达式周围的括号。
— manatwork 2015年
3

ES6，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:'*'

取消高尔夫：

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

— 尼尔
source
这不适用于输入00 0 00
— rink.attendant.15年6
@ rink.attendant.6啊，我使用的REPL只是印刷品["0"]，0所以我无法分辨出区别。
— 尼尔
比@ rink.attendant.6版本好得多！使用了聪明的高尔夫技巧。你能解释一下> '@'，& 31和|| 9？
— 帕夫洛2015年
1
@Pavlo > '@'只是区分字母和数字。& 31这是一种忽略大小写字符代码之间差异的有用方法，因为它还可以方便地直接将字符代码映射为1..26值。|| 9之所以使用，是因为% 9返回0表示9的倍数，但重复添加数字将返回9表示9的非零倍数(t + 8) % 9 + 1。
— 尼尔，2015年
该语言通常被称为“ JavaScript（ES6）”
— edc65
2

Gema，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
— 工作的人
source
1

的JavaScript（ES6），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代码和mod 9以获取其各自的值
      • 如果是数字，则将其强制转换
  3. 如果长度为0，则不存在字母数字字符（返回星号），否则返回递归函数的输出。
— 溜冰场助理6
source
此中断规则00 0 00，输出*代替 0！
— F. Hauri 2015年
@ F.Hauri固定。
— rink.attendant.15年6
您可以使用comman运算符来避免显式返回：_=>{expr;return expr}=>_=>(expr,expr)
— Pavlo 2015年
@Pavlo在我的情况下该如何应用？
— rink.attendant.15年6
对我不起作用，引发SyntaxError：jsbin.com/havotusoqa/1/edit?js,console
— Pavlo
1

Haskell，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是用于查找整数列表中的字符的查找表（单列表，如果找到了char，否则为空列表）。f查找其参数的每个字符，并将返回的列表列表展平为简单的整数列表，然后调用g以检查结束条件（空列表（-> *或单个整数）或f使用列表的总和进行下一轮调用。

— 妮米
source
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
— 路易斯·门多
source
不幸的是，我无法测试您的样品。请发布整个测试用例，包括最近添加的测试（对不起）。
— F. Hauri 2015年
@ F.Hauri是的，您需要Matlab对其进行测试。抱歉，还没有在线编译器。我添加了测试用例
— Luis Mendo 2015年
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
— 昆托
source
@ F.Hauri单击“在线尝试”。在输入框中输入测试用例。
— quintopia，2015年
1

Pyth，39个字节

IK@J+jkUTGrz0WtK=K`smh%xtJd9-K\0)K).?\*

在线试用

我这样做是因为我无法入睡。也许我明天再解释...

— 昆托
source
1

纯bash中，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
— 豪里
source
1

JavaScript（ES6），78 83

递归解决方案。作为尾递归，变量t和r不必是局部的。

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
source
0

Mathematica，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有点不同。我的函数将所有内容转换为字符代码，然后过滤掉非字母数字的内容（用空字符串替换它们）。如果没有字母数字，则返回*，否则以数字根。如果我不必处理全零字符串的情况，这可能会短很多（〜15B）。这就是生活。

Mathematica魔术，对于初学者：foo//.a_:>Tr@IntegerDigits@a是重复的替换：它将afoo中的任何数字替换为它们的数字之和，然后再次替换直到达到固定点，即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}
— 超级用户
source
不幸的是，我无法测试您的样品。请发布测试用例
— F. Hauri
我在途中。在进行测试组合时，我还发现了一些拼写错误需要解决。谢谢;）
— hYPotenuser
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.