Mein Wort kann dein Wort verprügeln

26

PROBLEM

Finde mit zwei Worten den Gewinner in einem digitalen Wurzelkampf .

Definieren Sie die digitale Wurzel eines Wortes folgendermaßen:

  1. Jedem Buchstaben des Alphabets ist eine Zahl zugeordnet: A = 1, B = 2, C = 3, ..., Z = 26
  2. Addieren Sie die Werte für jeden Buchstaben, um das Wort zu addieren. Nehmen wir zum Beispiel "CAT". C + A + T = 3 + 1 + 20 = 24
  3. Addieren Sie alle einzelnen Ziffern, aus denen das Ergebnis besteht: 24 => 2 + 4 = 6
  4. Wiederholen Sie Schritt 3, bis Sie eine einzelne Ziffer erreicht haben. Diese einzelne Ziffer ist die digitale Wurzel des Wortes.

Regeln:

  1. Ein Gewinner wird erklärt, wenn seine digitale Wurzel größer als die andere ist.
  2. Wenn die digitalen Stammwerte gleich sind, kürzen Sie die Wörter, indem Sie jede Instanz des Buchstabens mit dem höchsten Wert aus beiden Wörtern entfernen und neu berechnen.
  3. Wiederholen Sie die Schritte 1 und 2, bis ein Gewinner gefunden wurde oder eines der Wörter nur noch einen Buchstaben (oder keine Buchstaben) enthält.
  4. Wenn die digitalen Wurzelwerte nach Durchlaufen des Verkürzungsprozesses gleich sind, wird das längere Wort zum Gewinner erklärt.
  5. Wenn die Wörter gleich lang sind und nach der Verkürzung kein Gewinner gefunden wird, wird kein Gewinner ermittelt.

Besondere Regeln:

  1. Bei der Berechnung der digitalen Wurzel selbst ist die Verwendung des Moduls nicht zulässig . Es kann überall verwendet werden.
  2. Angenommen, Wörter bestehen nur aus Großbuchstaben - keine Interpunktion, keine Leerzeichen usw.

EINGANG

Ziehen Sie die Wörter durch stdin (durch Kommas getrennt). Methodenparameter, oder wie Sie wollen. Stellen Sie in Ihrer Lösung oder im Code klar, wie die Wörter analysiert oder vorbereitet werden.

AUSGABE

Zeigen Sie das gewinnende Wort an. Wenn es keinen Gewinner gibt, zeige "STALEMATE" an.

Beispiele:

Eingabe: CAN, BAT

CAN = 18 = 9
BAT = 23 = 5 

Ausgang: CAN

Eingabe: ZOO, NO

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

OO = 30 = 3
N = 14 = 5

Ausgang: NEIN

UPDATE : Die Eingabe muss mit stdin mit den Wörtern als durch Kommas getrennte Zeichenfolge gelesen werden.

UPDATE : Einige Beispiele zum Testen hinzugefügt.

UPDATE : Das Entfernen des höchstwertigen Buchstabens im Falle eines Unentschieden wurde geklärt - dies ändert auch die Stoppbedingung geringfügig - Wenn ein Wort einen Buchstaben oder null Buchstaben lang ist, wird der Kürzungsvorgang gestoppt

Steve
quelle
Sie sollten sich für die Eingabe entscheiden und nicht der Wahl überlassen, da dies einen großen Unterschied in den Programmen ausmacht. Indem Sie eine Eingabemethode auswählen und angeben, entfernen Sie "kreative Interpretationen" und stellen eine Herausforderung, die für alle gleich ist.
MtnViewMark
@MtnViewMark - Verstanden, aber effektiv versuche ich, das Lesen der Eingabe aus der Zeichenanzahl zu entfernen. Ich interessiere mich nicht für die klügste oder kürzeste Art, die zwei Wörter zu lesen. Das Erfordernis einer bestimmten Methode behindert auch bestimmte Sprachen - ich denke, ich versuche nur, das Problem zu lösen.
Steve
1
@Steve - Dann solltest du die Ausgabe auch nicht als "Anzeige" angeben, ja? Ich denke jedoch, dass Sie möglicherweise zu viel aus dem Problem herausholen. Ein cleveres und kurzes Golfspiel ergibt sich häufig aus der Kombination verschiedener Aspekte des Problems auf knifflige Weise, beispielsweise durch das Zusammenfassen eines Teils der Verarbeitung in die Eingabe oder Ausgabe. Was die Behinderung von Sprachen angeht, so können so ziemlich alle von ihnen Standard lesen und Standard schreiben.
MtnViewMark
@MtnViewMark - Fairer Punkt. Ich mache ein einfaches Update und räume es auf. Meine gewählte Sprache hat nur eine lange Leseweise von stdin, daher bin ich voreingenommen. :)
Steve
Gilt es als stdin, die Eingabe als Argument für main zu betrachten? Oh, und im Allgemeinen ist es wahrscheinlich der beste Weg, wenn Sie die Anforderungen an Streumaterial wie das Lesen von stdin und das Importieren oder Einschließen anderer Module oder Dateien so gering wie möglich halten möchten, dass das Puzzle eine Funktion anstelle eines ganzen Programms erfordert .
Jonathan M Davis

Antworten:

9

J 100

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

läuft so:

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

Eingaben werden noch nicht genau wie gewünscht akzeptiert.

Eelvex
quelle
9

APL (Dyalog) ( 91 86)

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

Erklärung (in der Reihenfolge der Ausführung):

  • ⎕ML←3: setze ML auf 3 (dies macht unter anderem die mittlere Partition aus).
  • G←Z⊂⍨','≠Z←⍞: Eingabe lesen, durch Komma trennen, in G speichern und an die Funktion übergeben.
  • +/¨⎕A∘⍳¨⍵: Berechnen Sie die Punktzahl für jedes Wort. ( ⎕Aist eine Liste mit dem Alphabet.)
  • Z←{2>⍴⍕⍵:⍵⋄∇+/⍎¨⍕⍵}¨: Berechne die digitale Wurzel für jede Punktzahl (indem du alle Ziffern summierst, solange es noch mehr als eine Ziffer gibt) und speichere sie in Z.
  • Z≡∪Z: Wenn alle Punkte eindeutig sind ...
  • :G[↑⍒Z]: ... dann das Wort mit der höchsten Punktzahl (aus der ursprünglichen Liste) ausgeben.
  • ⋄1∊↑¨⍴¨⍵:'STALEMATE': andernfalls (wenn es einen Gleichstand gibt), wenn eines der Wörter die Länge 1 hat, wird STALEMATE ausgegeben.
  • ⋄∇1∘↓¨⍵: Ansonsten entfernen Sie den ersten Buchstaben von jedem Wort und führen Sie die Funktion erneut aus.
Marinus
quelle
5

Rubin - 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]]

Tests:

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

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

$ ruby1.9 1128.rb <<< ZOO,ZOO
STALEMATE
Arnaud Le Blanc
quelle
Erste Zeile kann auf gekürzt werden d,e=(a,b=gets.split ?,).map{|w|w.bytes.sort}.
Ventero
Warum dies nicht weiter verkürzen, indem Sie ein anderes Wort verwenden, um ein Unentschieden zu bezeichnen? dh "TIE" vs "STALEMATE"
Gaffi
@ Gaffi, da die Spezifikation die Verwendung des Wortes "STALEMATE" erfordert.
Paul Prestidge
@chron Schande über mich, ich hörte auf zu lesen"If the words are of equal length and no winner is found after going through the shortening process, no winner is declared."
Gaffi
5

Haskell, 205 Zeichen

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(/=',')

Probeläufe:

> 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

  • Edit: (227 -> 219) bessere Auswahl des Gewinners, verkürzte Musterübereinstimmung w, importiertes älteres, kürzeres Modul
  • Bearbeiten: (219 -> 208) Nehmen Sie die Vorschläge von JB auf
  • Bearbeiten: (208 -> 205) Negative Zahlen behandeln und dabei ungerade Regeln für Bindestriche in Haskell ausnutzen
MtnViewMark
quelle
1
Es ist eine sehr nette Geste, den direkten Listenvergleich zu verwenden. Einige empfohlene Verbesserungen auf einen Blick: ',':b_:b(-2), wenn Sie nicht zu sehr mit der Mehrzeilenverarbeitung verbunden sind interact$unlines.map([...]).linesputStr.[...]=<<getLine(-11), wenn Sie sich erlauben, die Ausgabe zu lockern putStrprint(-1). Ich hasse diese Negationsoperation, die so viele Zeichen benötigt, aber ich kann keinen Weg finden, sie zu umgehen.
JB
Danke, JB! Ich habe die meisten Vorschläge berücksichtigt. Ich hatte das Gefühl, dass die Ausgabe der Spezifikation folgen sollte, insbesondere mit einem Zeilenumbruch. Aber ich wäre bereit, diese beiden Charaktere zu retten, wenn es knapp wird! :-)
MtnViewMark
Gute Arbeit mit den Abzügen!
JB
3

Perl, 224, 225, 229

Grundlegendes Golfen (noch nichts Schlaues):

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 und höher kann mit perl -M5.010 <file>oder ausgeführt werdenperl -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
JB
quelle
2

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]

Verwendet die Ausnahmebehandlung, um Stapelfehler abzufangen, die zu einer Pattsituation führen.

tmartin
quelle
2

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

Es stellte sich heraus, dass der folgende Code nicht mit der Spezifikation übereinstimmte, sodass ich überarbeiten und viel Länge hinzufügen musste (siehe oben). : - / Das kann vielleicht weiter gespielt werden, aber es ist schon ziemlich kompakt und ich bezweifle, dass ich es wieder auf ein konkurrenzfähiges Ergebnis bringen kann.

Das Original (siehe unten) hat den Buchstaben mit dem höchsten Wert nicht aus den Wörtern entfernt, als es einen Gleichstand gab.

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
Gaffi
quelle
2

Das hat mir wirklich Spaß gemacht und ist mein erster Beitrag. Obwohl es alt ist, ist mir aufgefallen, dass niemand eine PHP-Version erstellt hat.

<?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 Zeichen.

Jetzt bin ich mir nicht sicher, nach welchen Regeln ich anfangen soll, also habe ich mit $ f = 'CAN, CBN' als Eingabe begonnen. Ich hoffe das war richtig. Ich habe alle Tests bestanden, obwohl es nicht besonders elegant ist. Ich muss jetzt wirklich ein bisschen schlafen, aber es hat mir großen Spaß gemacht, das herauszufinden - danke für ein tolles Puzzle.

Codiert auf http://codepad.org/ZSDuCdin

Paul Drewett
quelle
Sie können $f=trim(fgets(fopen('php://stdin')));für die Aufnahme der Eingabe verwenden.
Élektra
Scratch das, $w=fgetcsv(STDIN);funktioniert besser.
Élektra
1

D: 326 Zeichen

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)]);}

Mehr leserlich:

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)]);
}
Jonathan M Davis
quelle
1

Mathematica

Einige Details fehlen noch

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"}
Dr. belisarius
quelle
1

Mathematica 220 207

Nachdem ich dies geschrieben hatte, bemerkte ich, dass dies der gleichen Argumentation folgt, die Belisarius benutzte:

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

Verwendung

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

Ergebnisse

Da die Antwort nicht wettbewerbsfähig ist (weil sie so langwierig ist), habe ich mich für ein Eingabeformat entschieden, das für Mathematica besser geeignet ist.

DavidC
quelle
1

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

Nicht so glücklich mit diesem wie ich gewesen sein könnte, aber ich werde es trotzdem aufstellen. Die tatsächliche Bewertung ist sehr präzise ( yFunktion), aber die ifs zum Vergleichen der Ergebnisse (in z) werden ziemlich lang.

Um es zu benutzen, rufe zmit deinen zwei Wörtern an (zB z 'FOO','BAR'). Es werden beide Wörter gewertet und das Wort mit der höheren Punktzahl zurückgegeben. Wenn es ein Unentschieden ist, wird es mit den geänderten Wörtern wiederkehren (die Originale behalten, um schließlich zurückzukehren, daher die zusätzlichen zwei Parameter), die es von dem erhältx Funktion .

Das entsprechende (erweiterte) Javascript für Interessenten:

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, "");
    }
  }
};
Johno
quelle
1

Schläger 479 Bytes

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

Ungolfed:

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

Testen:

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

Ausgabe:

"CAN"
"NO"
rnso
quelle
1

PHP, 339 (nicht spezifizierbar), 410 382 359 339 337 Bytes

$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]);}

EDIT 1 : +71 Bytes. Verwenden Sie STDINanstelle von fopen('php://stdin','r');und kurze Tags. Auch volle Übereinstimmung mit der Spezifikation.

EDIT 2 : -28 Bytes. Verwenden Sie fgetcsv(STDIN)anstelle von explode(',',trim(fgets(STDIN))), und verwenden Sie forSchleife anstelle von whileSchleife.

EDIT 3 : -23 Bytes. Zusammengeführte Funktionen aund bfür Schleifen zusammengeführt.

EDIT 4 : -20 Bytes. Verwandelte sich cvon einer rekursiven in eine Schleife. Entfernen Sie dann die Funktion cund fügen Sie ihren Code in den globalen Namespace ein.

EDIT 5 : -2 Bytes. Danke an @Titus für die -rFlagge.

Élektra
quelle
1
Keine Notwendigkeit für ein PHP-Tag mit -rFlagge
Titus
0

JAVA

    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");
        }
Aman ZeeK Verma
quelle
Der obige Code ersetzt im Falle eines Unentschieden alle max. Zeichen. Ist das erforderlich?
Aman ZeeK Verma
0

C ++, 473 (Ich leihe mir ein Eisen aus)

#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;}

Ich bin sicher, ich könnte es irgendwie verkürzen, aber ich bin müde.

Bearbeiten: ursprünglich verwendetes Befehlszeilenargument, geändert zur Verwendung von cin. Es ist wahrscheinlich ein paar Zeichen länger, aber ich bin zu müde, um es zu erzählen.

Wug
quelle
0

Python: 383 Zeichen

führe die Funktion aus 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))
Ashwini Chaudhary
quelle
0

F #, 559 533 530 Bytes

Noch nicht konkurrenzfähig. Ich bin sicher, c kann ebenso wie die letzten paar Zeilen kürzer gemacht werden. Hier tut es auch weh, keinen einfacheren Zugriff auf Befehlszeilenargumente zu haben.

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

Probieren Sie es online!

  • 3 Bytes gespart, indem s durch Vergleich mit string auf string beschränkt wurde

Ungolfed-Version

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
Brunner
quelle
0

PHP, 296 281 267 Bytes

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;

Laufen Sie mit -noder versuchen Sie es online (TiO enthält eine Aufschlüsselung).

Im Februar 2011 war die aktuelle PHP-Version 5.3.5; also konnte ich nicht

  • benutze Shorthand List Assignment ( [$a,$b]=fgetcsv(...)und so)
  • Alias count_charsInline
  • Indexfunktion ergibt sich direkt
  • Verwenden Sie negative Zeichenfolgenindizes anstelle von substr

Aber keiner hätte viel gespart; es macht also nicht viel aus.

Die teuersten Dinge waren (natürlich) die Schleifen und Regel Nr. 4 ( 40 - 36 Bytes).

Titus
quelle