문제

두 단어가 주어지면 디지털 루트 전투 에서 우승자를 찾으십시오 .

이런 식으로 단어 의 디지털 루트 를 정의하십시오 .

1. 알파벳의 각 문자에는 숫자가 할당됩니다 : A = 1, B = 2, C = 3, ..., Z = 26
2. 각 글자의 값을 더하여 단어를 합산하십시오. 예를 들어 "CAT"을 사용하십시오. C + A + T = 3 + 1 + 20 = 24
3. 결과를 구성하는 모든 단일 숫자를 추가하십시오. 24 => 2 + 4 = 6
4. 한 자리에 도달 할 때까지 3 단계를 반복하십시오. 그 한 자리 숫자는 단어 의 디지털 뿌리 입니다.

규칙 :

1. 디지털 루트 가 다른 루트 보다 큰 경우 승자가 선언됩니다 .
2. 는 IF 디지털 루트 값이 동일, 단어와 다시 계산 모두에서 가장 높은 값 문자의 모든 인스턴스를 제거하여 단어를 단축.
3. 승자가 있거나 단어 중 하나에 하나의 문자 만 남아 있거나 문자가 남아 있지 않을 때까지 1 단계와 2 단계를 반복하십시오 .
4. 는 IF 디지털 루트 값이 단축 처리를 거쳐 동일, 긴 단어가 승자가된다.
5. 단어의 길이가 같고 단축 과정을 거친 후 승자가 없으면 승자가 선언되지 않습니다.

특별 규칙 :

1. 디지털 루트 자체를 계산할 때는 모듈러스를 사용할 수 없습니다. 다른 곳에서도 사용할 수 있습니다.
2. 단어는 문장 부호, 공백 등이 아닌 대문자로만 구성되어 있다고 가정합니다.

입력

stdin (쉼표로 구분)을 통해 단어를 가져옵니다. 메소드 매개 변수 또는 원하는대로. 솔루션이나 코드에서 단어를 구문 분석하거나 준비하는 방법을 분명히하십시오.

산출

이기는 단어를 표시하십시오. 당첨자가 없으면 "STALEMATE"를 표시하십시오.

예 :

입력 : CAN, BAT

CAN = 18 = 9
BAT = 23 = 5 

출력 : CAN

입력 : ZOO, NO

ZOO = 56 = 11 = 2
NO = 29 = 11 = 2

OO = 30 = 3
N = 14 = 5

출력 : NO

업데이트 : 쉼표로 구분 된 문자열로 단어와 함께 stdin을 사용하여 입력을 읽어야합니다.

업데이트 : 테스트 할 몇 가지 예가 추가되었습니다.

업데이트 : 넥타이의 경우 가장 높은 값의 문자 제거를 명확히했습니다. 단어 조건도 약간 변경됩니다. 단어가 한 글자 또는 0 자이면 짧아짐 프로세스가 중지됩니다

J, 100

z=:"."0@":@(+/)^:9@(64-~a.i.])@(#~' '&i.)"1
f=:*@-/"2@(z@((]#~]i.~{.@\:~)"1^:([:=/z))){'STALEMATE'&,

다음과 같이 실행됩니다.

f 'NO',:'ZOO'
NO       
f 'CAN',:'BAT'
CAN      
f 'FAT',:'BANANA'
FAT      
f 'ONE',:'ONE'
STALEMATE

그것은하지 않습니다 아직 물었다대로 정확하게 입력을 받아들입니다.

APL (Dyalog) ( 91 86)

⎕ML←3⋄{Z≡∪Z←{2>⍴⍕⍵:⍵⋄∇+/⍎¨⍕⍵}¨+/¨⎕A∘⍳¨⍵:G[↑⍒Z]⋄1∊↑¨⍴¨⍵:'STALEMATE'⋄∇1∘↓¨⍵}G←Z⊂⍨','≠Z←⍞

설명 (실행 순서) :

• ⎕ML←3: ML을 3으로 설정하십시오 (이것은 ⊂무엇보다도 파티션 을 의미합니다).
• G←Z⊂⍨','≠Z←⍞: 쉼표로 구분하여 입력을 읽고 G에 저장하고 함수에 전달합니다.
• +/¨⎕A∘⍳¨⍵: 각 단어의 점수를 계산합니다. ( ⎕A알파벳이 포함 된 목록입니다.)
• Z←{2>⍴⍕⍵:⍵⋄∇+/⍎¨⍕⍵}¨: 각 점수에 대한 디지털 근을 계산하고 (아직 두 자리 이상인 한 모든 자리를 합산하여) Z에 저장합니다.
• Z≡∪Z: 모든 점수가 고유 한 경우 ...
• :G[↑⍒Z]: ... 그러면 원래 목록에서 가장 높은 점수를 가진 단어를 출력합니다.
• ⋄1∊↑¨⍴¨⍵:'STALEMATE': 그렇지 않으면 (동점이있는 경우) 단어 중 하나의 길이가 1이면 STALEMATE를 출력합니다.
• ⋄∇1∘↓¨⍵: 그렇지 않으면 각 단어에서 첫 글자를 빼고 기능을 다시 실행하십시오.

루비-210

d,e=(a,b=$<.read.chop.split(/,/)).map{|w|w.bytes.sort}
r=->w,o=65{n=0;w.map{|c|n+=c-o};n>9?r[n.to_s.bytes,48]:n}
d.pop&e.pop while r[d]==r[e]&&d[1]&&e[1]
$><<[[:STALEMATE,a,b][a.size<=>b.size],a,b][r[d]<=>r[e]]

테스트 :

$ ruby1.9 1128.rb <<< CAN,BAT
CAN

$ ruby1.9 1128.rb <<< ZOO,NO
NO

$ ruby1.9 1128.rb <<< ZOO,ZOO
STALEMATE

하스켈, 205 자

import List
s b=d.sum.map((-b+).fromEnum)
d q|q<10=q|1<3=s 48$show q
f=map(s 64.concat).tails.group.reverse.sort
w(a,_:b)=f a#f b where x#y|x<y=b|x>y=a|1<3="STALEMATE"
main=getLine>>=putStrLn.w.span(/=',')

샘플 실행 :

> ghc --make WordVsWord.hs 
[1 of 1] Compiling Main             ( WordVsWord.hs, WordVsWord.o )
Linking WordVsWord ...

> ./WordVsWord <<< CAN,BAT
CAN

> ./WordVsWord <<< ZOO,NO
NO

> ./WordVsWord <<< FAT,BANANA
FAT

> ./WordVsWord <<< ONE,ONE
STALEMATE

• 편집 : (227-> 219) 우승자의 더 나은 선택, 단축 된 패턴 일치 w, 이전, 짧은 모듈 가져 오기
• 편집 : (219-> 208) JB의 제안을 통합하십시오
• 편집 : (208-> 205) 하스켈에서 하이픈에 대한 홀수 규칙을 활용하여 음수를 처리하십시오.

펄 224 225 229

기본 골프 (아직 똑똑하지 않음) :

split",",<>;$_=[sort map-64+ord,/./g]for@a=@_;{for(@b=@a
){while($#$_){$s=0;$s+=$_ for@$_;$_=[$s=~/./g]}}($a,$b)=
map$$_[0],@b;if($a==$b){pop@$_ for@a;@{$a[1]}*@{$a[0]}&&
redo}}say+("STALEMATE",@_)[$a<=>$b||@{$a[0]}<=>@{$a[1]}]

Perl 5.10 이상, perl -M5.010 <file>또는perl -E '<code here>'

$ perl -M5.010 word.pl <<<CAN,BAT
CAN
$ perl -M5.010 word.pl <<<ZOO,NO
NO

$ perl -M5.010 word.pl <<<NO,ON
STALEMATE

K, 106

{a::x;@[{$[(>). m:{+/"I"$'$+/@[;x].Q.A!1+!26}'x;a 0;(<). m;a 1;.z.s 1_'x@'>:'x]};x;"STALEMATE"]}[","\:0:0]

예외 처리를 사용하여 스택 오류를 포착하여 교착 상태가 발생합니다.

VBA ( 242 462)

Function s(q,Optional l=0)
s=-1:t=Split(q,","):r=t:m=t
For j=0 To 1
m(j)=0:w=t(j)
While Len(w)>1 Or Not IsNumeric(w)
b=0
For i=1 To Len(w)
a=Mid(w,i,1):a=IIf(IsNumeric(a),a,Asc(a)-64):b=b+a
If m(j)+0<a+0 Then m(j)=a
Next
w=b
Wend
r(j)=b
Next
s=IIf(r(0)>r(1),0,IIf(r(0)<r(1),1,s))
For j=0 To 1
r(j)=Replace(t(j),Chr(m(j)+64),"",,1)
Next
If s<0 And Len(t(0))+Len(t(1))>2 Then s=s(r(0) & "," & r(1),1)
If l=0 Then If s>=0 Then s=t(s) Else s="STALEMATE"
End Function

아래 코드가 사양과 일치하지 않는 것으로 나타 났으므로 길이를 많이 추가하여 다시 작업해야했습니다 (위 참조). :-/ 이것은 더 골프를 치는 것이 가능할 수 있지만, 이미 꽤 작고 경쟁 점수로 되돌릴 수 있을지 의심됩니다.

원래 (아래)는 동점이있을 때 단어에서 가장 가치가 높은 문자를 제거하지 않았습니다.

Sub s(q)
t=Split(q,",")
r=t
For j=0 To 1
w=t(j):b=0
For i=1 To Len(w)
b=b+Asc(Mid(w,i,1))-64
Next
While Len(b)>1
d=0
For i=1 To Len(b)
d=d+Mid(b,i,1)
Next
b=d
Wend
r(j)=b
Next
MsgBox IIf(r(0)>r(1),t(0),IIf(r(0)<r(1),t(1),"STALEMATE"))
End Sub

이것은 정말로 나의 공상을 취했고 나의 첫번째 포스트이다. 그것은 오래되었지만 아무도 PHP 버전을 수행하지 않았으므로 여기에 내 것이 있습니다.

<?php $f='CAN,CBN';$w=explode(',',$f);$a=$ao=$w[0];$b=$bo=$w[1];$c='';
function splice($a,$t){$s=$h=0;$y=array();$x=str_split($a);
foreach($x as $k=>$v){$s=$s+ord($v)-64;if($v>$h){$h=$k;}}
$y[0]=$s;if($t==1){unset($x[$h1]);$y[1]=$x;}return $y;}
while($c==''){$y1=splice($a,0);$y2=splice($b,0);$y3=splice($y1[0],1);
$y4=splice($y2[0],1);if($y3[0]>$y4[0]){$c=$ao;}else if($y3[0]<$y4[0]){$c=$bo;
}else if((strlen($a)<1)OR(strlen($b)<1)){if(strlen($a)<strlen($b)){$c=$ao;}
else if(strlen($b)<strlen($a)){$c=$bo;}else{$c='STALEMATE';}}}
echo $c;
?>

534 자

이제 시작 규칙에 대해 확신이 없으므로 $ f = 'CAN, CBN'을 입력으로 시작했습니다. 나는 그것이 옳았기를 바랍니다. 나는 모든 테스트를 실행했으며 특히 우아하지는 않지만 모든 테스트를 통과합니다. 나는 지금 정말로 잠을 자야한다. 그러나 나는 이것을 해결하는 것은 매우 재미 있었다 – 큰 퍼즐에 감사드립니다.

http://codepad.org/ZSDuCdin에 코딩

D : 326 자

import std.algorithm,std.array,std.conv,std.stdio;void main(string[]a){alias reduce r;auto b=array(splitter(a[1],","));auto s=map!((a){int n=r!"a+b"(map!"cast(int)(a-'A')+1"(a));while(n>9)n=r!"a+b"(map!"cast(int)(a-'0')"(to!string(n)));return n;})(b);int v=r!"a>b?a:b"(s);writeln(count(s,v)>1?"STALEMATE":b[countUntil(s,v)]);}

더보기 :

import std.algorithm, std.array, std.conv, std.stdio;

void main(string[] a)
{
    alias reduce r;

    auto b = array(splitter(a[1], ","));
    auto s = map!((a){int n = r!"a + b"(map!"cast(int)(a - 'A') + 1"(a));

                      while(n > 9)
                          n = r!"a+b"(map!"cast(int)(a - '0')"(to!string(n)));

                      return n;
                     })(b);
    int v = r!"a > b ? a : b"(s);

    writeln(count(s, v) > 1 ? "STALEMATE" : b[countUntil(s, v)]);
}

매스 매 티카

일부 세부 사항이 여전히 누락되었습니다

a = {"ZOO"}; b = {"NO"}
f = FixedPoint[IntegerDigits@Total@# &, #] &

If[(s = f /@ 
        NestWhile[(# /. Max@# -> 0 &) /@ # &, (ToCharacterCode @@ # - 64) & /@ #, 
        f[#[[1]]] == f[#[[2]]] &, 1, 5] &@{a, b})[[1, 1]] > s[[2, 1]], 
   a, b, "STALMATE"]  

{"NO"}

매쓰 220 207

이 글을 쓰고 난 후에 이것은 이것이 Belisarius가 사용한 것과 같은 추론을 따른다는 것을 알았습니다.

h@u_ := ToCharacterCode@u - 64;
m@w_ := FromCharacterCode[Most@Sort@h@w + 64];
f@v_ := FixedPoint[Tr@IntegerDigits@# &, Tr@h@v];
x_~g~y_ := If[f@x == f@y, g[m@x, m@y], If[f@x > f@y, 1, 2]];
x_~z~x_ := "STALEMATE";
x_~z~y_ := {x, y}[[x~g~y]] 

용법

z["ZOO", "NO"]
z["CAN", "BAT"]
z["FAT", "BANANA"]
z["ONE", "ONE"]

응답이 경쟁적이지 않기 때문에 (매우 길다) Mathematica에 더 일반적인 입력 형식을 사용하기로 결정했습니다.

CoffeeScript-335

z=(a,b,g=a,h=b)->c=y a;d=y b;e=a.length;f=b.length;return g if(c>d);return h if(d>c);return g if(e<2&&f>1);return h if(f<2&&e>1);return "STALEMATE" if(f==e&&f<2);z(x(a),x(b),a,b)
y=(a)->t=0;t+=c.charCodeAt(0)-1 for c in a;t-=9 while 9<t;t
x=(a)->for i in[90..65]
 b=new RegExp(String.fromCharCode(i));return a.replace b, "" if b.test a

내가 생각했던 것만 큼 행복하지는 않지만 어쨌든 올려 놓겠다. 실제 점수는 매우 간결 y하지만 ( 기능) if결과를 비교 하는 s z는 꽤 길어집니다.

그것을 사용하려면 z두 단어로 전화 하십시오 (예 :) z 'FOO','BAR'. 두 단어를 모두 득점하고 더 높은 점수를주는 단어를 반환합니다. 동점 인 경우 x함수 에서 가져 오는 수정 된 단어 (원본이 최종적으로 반환되도록하여 두 개의 추가 매개 변수를 유지함)로 반복됩니다 .

관심있는 사람들을위한 동등한 (확장 된) 자바 스크립트 :

var x, y, z;

z = function(a, b, g, h) {
  var c, d, e, f;
  if (g == null) {
    g = a;
  }
  if (h == null) {
    h = b;
  }
  c = y(a);
  d = y(b);
  e = a.length;
  f = b.length;
  if (c > d) {
    return g;
  }
  if (d > c) {
    return h;
  }
  if (e < 2 && f > 1) {
    return g;
  }
  if (f < 2 && e > 1) {
    return h;
  }
  if (f === e && f < 2) {
    return "STALEMATE";
  }
  return z(x(a), x(b), a, b);
};

y = function(a) {
  var c, t, _i, _len;
  t = 0;
  for (_i = 0, _len = a.length; _i < _len; _i++) {
    c = a[_i];
    t += c.charCodeAt(0) - 1;
  }
  while (9 < t) {
    t -= 9;
  }
  return t;
};

x = function(a) {
  var b, i, _i;
  for (i = _i = 90; _i >= 65; i = --_i) {
    b = new RegExp(String.fromCharCode(i));
    if (b.test(a)) {
      return a.replace(b, "");
    }
  }
};

라켓 479 바이트

(define(dl n)(let p((ol '())(n n))(let-values(((q r)(quotient/remainder n 10)))(if(= q 0)(cons r ol)(p(cons r ol)q)))))
(define(dr N)(let p2((n N))(define s(apply +(dl n)))(if(< s 10)s(p2 s))))
(let p3((l(for/list((i(string->list s)))(-(char->integer i)64)))(k(for/list((i(string->list t)))(-(char->integer i)64))))
(let((a(dr(apply + l)))(b(dr(apply + k))))(cond[(> a b)s][(< a b)t][(equal? l k)"STALEMATE"][else(p3(remove*(list(apply max l))l)(remove*(list(apply max k))k))])))

언 골프 드 :

(define (f s t)

  (define (getDigitList n)                     ; sub-fn  to get digit list
    (let loop ((ol '())
               (n n))
      (let-values (((q r) (quotient/remainder n 10)))
        (if (= q 0) (cons r ol)
            (loop (cons r ol) q)))))

  (define (digit_root N)                       ; sub-fn to get digital root of a number
    (let loop2 ((n N))                        
      (define s (apply + (getDigitList n)))    
      (if (< s 10)
          s
          (loop2 s))))

  (let loop3 ((l (for/list ((i (string->list s)))  ; actual fn to compare 2 strings
                   (- (char->integer i) 64)))
              (k (for/list ((i (string->list t)))
                   (- (char->integer i) 64))))
    (let ((a (digit_root (apply + l)))
          (b (digit_root (apply + k))))
      (cond
        [(> a b) s]
        [(< a b) t]
        [(equal? l k) "STALEMATE"]
        [else (loop3 (remove* (list (apply max l)) l)
                     (remove* (list (apply max k)) k)
                     )]
        ))))

테스트 :

(f "CAN" "BAT")
(f "ZOO" "NO")

산출:

"CAN"
"NO"

PHP, 339 (SPEC에 생략) 410 382 359 339 337 바이트

$b=$w=fgetcsv(STDIN);function a($c){for(;a&$g=$c[$p++];)$f+=ord($g)-64;$f=trim($f);for(;$f[1]&a;$f=$h)for($h=0;a&$r=$f[$q++];$h=bcadd($h,$r));return$f;}function d($f){return strtr($f,[max(str_split($f))=>'']);}for(;$c==$d;$b=[$e,$f]){$x=$z++?d:trim;$e=$x($b[0]);$f=$x($b[1]);$c=a($e);$d=a($f);$e||die(STALEMATE);$c!=$d&&die($w[$c<=$d]);}

편집 1 : +71 바이트 짧은 태그 STDIN대신 fopen('php://stdin','r');및 짧은 태그를 사용 합니다. 또한 사양을 완벽하게 준수합니다.

편집 2 : -28 바이트. 사용 fgetcsv(STDIN)대신에 explode(',',trim(fgets(STDIN))), 그리고 사용하는 for대신 루프 while루프를.

편집 3 : -23 바이트. 병합 된 함수 a및 b, for 루프를 병합했습니다.

편집 4 : -20 바이트. c재귀에서 루프로 바뀌 었습니다 . 그런 다음 함수를 제거 c하고 코드를 전역 네임 스페이스에 넣습니다.

편집 5 : -2 바이트. -r깃발 에 @Titus에게 감사드립니다 .

자바

    public static void main(String args[]) throws Exception{
        String input=(new BufferedReader(new InputStreamReader(System.in)).readLine());
        StringTokenizer st = new StringTokenizer(input, ",");
        String w1 = st.nextToken();String w2 = st.nextToken();int s1=0;int s2=0;
        String flag="";
        do{ Integer sum1=0;Integer sum2=0;
        for (int i=0;i<w1.length();i++)
            sum1+=((int)w1.charAt(i) - 64);
        for (int i=0;i<w2.length();i++)
            sum2+=((int)w2.charAt(i) - 64);
        while (sum1.toString().length()>1){
            s1=0;
            for (int i=0;i<sum1.toString().length();i++)
                s1+=((int)sum1.toString().charAt(i)-48);
            sum1=s1;
        }
        while (sum2.toString().length()>1){
            s2=0;
            for (int i=0;i<sum2.toString().length();i++)
                s2+=((int)sum2.toString().charAt(i)-48);
            sum2 =s2;
        }
        flag=(s1>s2)?w1:(s1!=s2)?w2:"";
        if (flag!="")
            {st = new StringTokenizer(input,",");
                if (s1>s2)
                    System.out.println(st.nextToken());  
                else{
                    st.nextToken();
                    System.out.println(st.nextToken());
                }
            }
        int max=0;
        for (int i=0;i<w1.length();i++){
            max=((int)w1.charAt(i)>max)?(int)w1.charAt(i):max;
        }
        w1 = w1.replace((char)max, (char)64);
        max=0;
        for (int i=0;i<w2.length();i++){
            max=((int)w2.charAt(i)>max)?(int)w2.charAt(i):max;
        }
        w2 = w2.replace((char)max, (char)64);
            }while(flag=="" && !w1.equals(w2)); 
    if (flag.length()<1)
        System.out.println("STALEMATE");
        }

C ++, 473 (코스 아이언을 빌리고 있습니다)

#include<iostream>
#define $ string
#define _ return
using namespace std;$ S($&s){int i=-1,m=i,x=0;while(++i<s.length())if(s[i]-'@'>x)m=i,x=s[i];s.erase(m,1);_ s;}int M($ w){int i,v=0;for(i=0;i<w.length();++i)v+=w[i]-'@';while(v>9){i=0;while(v)i+=v-v/10*10,v/=10;v=i;}_ v;}$ B($ x, $ y){while(!(M(x)-M(y)))S(x),S(y);if(M(x)>M(y))_ x;if(M(x)<M(y))_ y;_"STALEMATE";}int main(int c,char**v){$ s;cin>>s;$ x=s.substr(0,s.find(',')),y=s.substr(s.find(',')+1);cout<<B(x,y)<<endl;_ 0;}

어떻게 든 단축 할 수 있다고 확신하지만 피곤합니다.

편집 : 원래 명령 줄 인수를 사용하여 cin을 사용하도록 수정했습니다. 아마도 지금은 몇 자 더 길었을 것입니다.

파이썬 : 383 자

기능을 실행하십시오 c('CAN','BAT').

def k(j):
 l=list(j);l.remove(max(j));return''.join(l)
def f(x):
 x=str(x)
 if len(x)==1 and x.isdigit():return int(x)
 return f(sum('ABCDEFGHIJKLMNOPQRSTUVWXYZ'.index(y)+1 for y in x)) if x.isalpha() else f(sum(map(int,x)))
def c(a,b):
 v=f(a);u=f(b);
 if v>u:return a
 if v<u:return b
 return'STALEMATE' if v==u and (len(a)==1 or len(b)==1)else c(k(a),k(b))

F 번호, 559 533 530 바이트

아직 경쟁력이 없습니다. 나는 마지막 몇 줄뿐만 아니라 c 를 더 짧게 만들 수 있다고 확신 합니다. 커맨드 라인 인수에 쉽게 액세스 할 수 없다는 것도 여기에서 아프다.

open System
let m=Seq.map
let a s=s="";s.ToUpper()|>m(fun c->int c-64)
let rec c i=if i>9 then string i|>m(int>>(-))|>m(fun x->x 48)|>Seq.sum|>c else i
let b i=Seq.fold(fun(r,a)j->(Seq.sum i-a)::r,a+j)([],0)(Seq.sortBy(~-)i)|>fst|>m c
[<EntryPoint>]
let x z=
 let y=z.[0].Split(',')
 let u,v=y.[0].Length,y.[1].Length
 printf"%s"(Seq.fold2(fun s l r->if l=r then 3::s else if l>r then 0::s else 1::s)[](b<|a y.[0])(b<|a y.[1])|>Seq.tryFind((>)3)|>function|None when u>v->y.[0]|None when u<v->y.[1]|Some x->y.[x]|_->"STALEMATE")
 0

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

• 문자열과 비교하여 s를 문자열로 제한하여 3 바이트를 절약했습니다.

언 골프 버전

open System
let m=Seq.map // this is just to save some characters and I'll use Seq.map for this version

let toIntList s =
    s = "" // constrain s to type string
    s.ToUpper()
    |>Seq.map (fun c -> int c - 64) // converts char value to int and offsets it so that A=1

let rec digitSumUntilSingle i =
    if i > 9 then
        string i                // convert number to string
        |>Seq.map ( int>>(-) )  // convert individual char to int and partially apply substraction
                                // this returns a function
        |>Seq.map (fun x -> x 48) // provide last parameter for substraction, this is equivalent to
                                  // charValue - 48
        |>Seq.sum                 // sum over all digits
        |>digitSumUntilSingle     // recursively call this function again in case we are >9
    else
        i

let calculateDigitalRoot input =
    Seq.fold(fun (result, acc) current ->       // calculate digital root for all possible iterations
                (Seq.sum input - acc)::result,  // basically, this calculates Rule 3 until the end for a given word
                acc + current
            ) ([], 0) (Seq.sortBy (~-) input) // sort input by value descending
    |>fst   // only interested in the lits, not the final accumulator
    |>Seq.map digitSumUntilSingle

[<EntryPoint>]
let main (args) =
    let y = args.[0].Split(',')
    let leftLength = y.[0].Length
    let rightLength = y.[1].Length

    Seq.fold2 (fun state left right ->
                if left = right then
                    3::state
                else if left > right then
                    0::state                // 0 is chosen because this represents y[0] index
                else
                    1::state
               ) [] (calculateDigitalRoot (toIntList y.[0])) (calculateDigitalRoot (toIntList y.[1]))
    |> Seq.tryFind ((>) 3)                  // try to find first variation where left and right digital root isn't equal
    |> function
        | None when leftLength > rightLength -> y.[0]
        | None when leftLength < rightLength -> y.[1]
        | Some x -> y.[x]
        | _ ->"STALEMATE"
    |>printf "%s" 
    0

PHP, 296 281 267 바이트

function f(&$s){for(;$c=$s[$i++];$m>$c||$m=$c)$p+=ord($c)&31;for($s=str_replace($m,'',$s);9<$p=array_sum(str_split($p)););return$p;}for(list($a,$b)=$x=fgetcsv(STDIN);$s==$t&&$a&$b;$t=f($b))$s=f($a);echo($s-=$t)||($s=strlen($x[0])-strlen($x[1]))?$x[+($s<0)]:STALEMATE;

온라인으로 실행 -n하거나 온라인으로 사용해보십시오 (TiO에 고장 포함).

2011 년 2 월 현재 PHP 버전은 5.3.5입니다. 그래서 나는 할 수 없었다

• 사용 속기 목록 할당 ( [$a,$b]=fgetcsv(...)등)
• 별칭 count_chars인라인
• 인덱스 함수 결과를 직접
• 대신 음수 문자열 인덱스를 사용하십시오. substr

그러나 어느 쪽도 많이 구하지 않았을 것입니다. 중요하지 않습니다.

가장 비용이 많이 드는 것은 루프 (물론)와 규칙 # 4 ( 40 36 바이트)였습니다.