Die Herausforderung

Der kürzeste Code nach Zeichenanzahl, der das numerische Äquivalent einer Excel-Spaltenzeichenfolge ausgibt.

Zum Beispiel ist die ASpalte 1, Bist 2 usw. Sobald Sie drücken Z, wird die nächste Spalte AA, dann ABund so weiter.

Testfälle:

A:    1
B:    2
AD:   30
ABC:  731
WTF:  16074
ROFL: 326676

Die Codeanzahl umfasst die Eingabe / Ausgabe (dh das vollständige Programm).

Perl, 36 34 33 31 30 17 15 11 Zeichen

$_=()=A..$_

Verwendung:

$ echo -n WTF | perl -ple '$_=()=A..$_'
16074

Reduziert auf 17 durch Verwendung von echo -n, um einen chopAnruf zu vermeiden .

Reduziert auf 15 durch Verwendung von say anstelle von print.

Reduziert auf 11 durch Verwendung von -p anstelle von say.

Erläuterung: AWird im Zeichenfolgenkontext ausgewertet und erstellt A..$_eine Liste, die bei "A" beginnt und die Zeichenfolge bis zur Eingabezeichenfolge erhöht. Perl interpretiert den ++Operator (und damit ..) für Zeichenfolgen in einem alphabetischen Kontext, z. B. für $_="AZ";$_++;printAusgaben BA.

=()=(auch bekannt als "goatse" -Operator ) erzwingt die Auswertung eines Ausdrucks im Listenkontext und gibt die Anzahl der von diesem Ausdruck zurückgegebenen Elemente zurück, dh $scalar = () = <expr>entspricht @list = <expr>; $scalar = @list.

Excel, 9 Zeichen :)

Verwenden Sie das richtige Werkzeug für den Job:

=COLUMN()

J , 17 12 10 Zeichen

26#.64-~av

Beispiel:

26#.64-~av  'WTF'
16074

Erläuterung:

• J analysiert von rechts nach links.
• avgibt eine Liste der ascii - Indizes von jedem der Zeichen in seinem Argument, so zum Beispiel av'ABC'zurückkehrt 65 66 67.
• Dann subtrahieren wir 64 von jedem Element dieser Liste mit dem Verb 64-~.
• Dann konvertieren wir die Liste mit dem #.Verb in Basis 26 .

Brainf * ck, 81 Zeichen (kein Leerzeichen)

,[>>>[->>+++++[-<+++++>]<+<]>[-<+>]<<++++++++[<++++++++>-]<[<->-]<[>>>+<<<-],]>>>

Erläuterung

,[  // get character input into p[0], enter loop if it isn't null (0)
>>>[->>+++++[-<+++++>]<+<] // take what's in p[3] and multiply by 26, storing it in p[4]
>[-<+>] // copy p[4] back to p[3]
<<++++++++[<++++++++>-]< // store 64 in p[1]
[<->-]< // subtract p[1], which is 64, from the input char to get it's alphabetical index
[>>>+<<<-] // add p[0] to p[3]
,] // get another character and repeat
>>> // move to p[3], where our final result is stored

Sie werden also feststellen, dass ich den numerischen Wert zum Drucken nicht in eine ASCII-Zeichenfolge konvertiert habe. Das würde wahrscheinlich den Spaß ruinieren. Aber ich habe den Gefallen getan, den Zeiger mit dem Ergebnis auf die Zelle zu bewegen, also ist es zumindest für die Maschine nützlich.

Hey, was weißt du, ich habe C # geschlagen!

Ruby 1.8.7, 53 50 46 44 24 17 Zeichen

p ('A'..$_).count

Verwendung:

$ echo -n ROFL | ruby -n a.rb
326676
$ echo -n WTF | ruby -n a.rb
16074
$ echo -n A | ruby -n a.rb
1

APL

13 Zeichen

Geben Sie den Wert ein in x:

x←'WTF'

Berechnen Sie es dann mit:

26⊥(⎕aV⍳x)-65

Der einzige Grund, warum ich mich geschlagen habe, sind die Klammern. Ich denke, es sollte eine Möglichkeit geben, es neu zu ordnen, um die Notwendigkeit für sie zu vermeiden, aber es war ein langer Tag. Ideen?

(Heh, du Perl-Programmierer mit deinen über 30 Zeichenlösungen bist so süß!)

Excel (nicht betrügen), 25 Zeichen

Unterstützt bis zu XFD:

=COLUMN(INDIRECT(A1&"1"))

Installation:

2. Geben Sie die Formel in Zelle A2 ein.

Verwendung:

1. Geben Sie die Spaltenzeichenfolge in Zelle A1 ein.
2. Lesen Sie das Ergebnis in Zelle A2.

54 Zeichen plus viele Anweisungen

Unterstützt ROFL auch:

(A2)  =MAX(B:B)
(B2)  =IFERROR(26*B1+CODE(MID(A$1,ROW()-1,1))-64,0)

Installation:

1. Löschen Sie die gesamte Tabelle.
2. Geben Sie die Formel (A2) in Zelle A2 ein.
3. Geben Sie die Formel (B2) in Zelle B2 ein.
4. Füllen Sie die Formel (B2) so weit wie möglich nach unten.

Verwendung:

4. Geben Sie die Spaltenzeichenfolge in Zelle A1 ein.
5. Lesen Sie das Ergebnis in Zelle A2.

C # 156 146 118 Zeichen

using System.Linq;class P{static void Main(string[]a){System.Console.Write(
a[0].Aggregate(0,(t,c)=>(t+c-64)*26)/26);}}

Ungolfed:

using System.Linq;
class P
{
    static void Main(string[] a)
    {
        System.Console.Write(a[0]
            .Aggregate(0, (t, c) => (t + c - 64) * 26) / 26);
    }
}

Golfscript - 16 Zeichen

[0]\+{31&\26*+}*


$ echo -n WTF | ./golfscript.rb excel.gs
16074
$ echo -n ROFL | ./golfscript.rb excel.gs
326676

Haskell, 50 51 56 Zeichen

main=interact$show.foldl(\x->(26*x-64+).fromEnum)0

Verwendung:

~:166$ echo -n "ROFL" | ./a.out
326676
~:167$ echo -n "WTF" | ./a.out
16074

Python, 64 49 Zeichen

s=0
for c in raw_input():s=26*s+ord(c)-64
print s

Sie können auch ersetzen raw_input()mit input()zu reduzieren , die Zeichenanzahl von 4, aber das erfordert dann die Eingabe in Anführungszeichen es enthalten.

Und hier ist eine Unterroutine mit 47 Zeichen:

f=lambda x:len(x)and 26*f(x[:-1])+ord(x[-1])-64

k4 (kdb +), 11 Zeichen

26/:1+.Q.A?

Erläuterung:

• k4 analysiert links von rechts
• .Q.A ist in k4 definiert - es ist der Vektor "ABC...XYZ"
• ? ist der Suchoperator - der Index der ersten Übereinstimmung für Elemente im y-Argument innerhalb des x-Arg
• +1, um den Index zu versetzen
• 26/: zur Basis 26 konvertieren

Eine Einschränkung - dies funktioniert nur, wenn aufgelistete Typen übergeben werden:

  26/:1+.Q.A? "AD"
30

  26/:1+.Q.A? "WTF"
16074

aber:

  26/:1+.Q.A? ,"A"
1

Powershell, 42 Zeichen

[char[]]$args[($s=0)]|%{$s=$s*26+$_-64};$s

JavaScript 1.8: 66 Zeichen

function a(p)Array.reduce(p,function(t,d)t*26+d.charCodeAt()-64,0)

Javascript 1.8: 72 Zeichen

function a(p)(t=0,p.replace(/./g,function(d)t=t*26+d.charCodeAt()-64),t)

JavaScript 1.6: 83 Zeichen

function a(p){t=0;p.split("").map(function(d){t=t*26+d.charCodeAt(0)-64});return t}

JavaScript: 95 Zeichen

function a(p){r=0;t=1;l=p.length;for(i=0;i<l;i++){r+=(p.charCodeAt(l-1-i)-64)*t;t*=26}return r}

JavaScript: 105 Zeichen

function a(p,i){i=i||0;l=p.length;return p?(p.charCodeAt(l-1)-64)*Math.pow(26,i)+a(p.slice(0,l-1),i+1):0}

Verwendung:

a("A")        // 1
a("B")        // 2
a("AD")       // 30
a("ABC")      // 731
a("WTF")      // 16074
a("ROFL")     // 326676

Scala, 30 Zeichen

print((0/:args(0))(_*26+_-64))" 

Beispiel:

C:\>scala -e "print((0/:args(0))(_*26+_-64))" AD
30

C89, 58 Zeichen

s;main(c){while(c=getchar()+1)s=26*s+c-65;printf("%d",s);}

Die Eingabe (stdin) darf nur AZ enthalten, andere Zeichen (einschließlich Zeilenumbrüche) sind nicht zulässig.

Erläuterung der Konzepte - Excelcification

Nett. Ich habe vor langer Zeit meine eigene Version mit etwas mehr Erklärung unter http://aboutdev.wordpress.com/2009/12/19/excelcification-brain-teaser-code/ geschrieben . Obwohl es keine ganz optimierte Version ist!

Zu Ihrer Information. Die Basis-26-Arithmetik heißt hexavigesimal und die maximale Spalte von Excel ist XFD , die in 16383 konvertiert wird (wobei 0 als erste Zelle verwendet wird), was zufällig genau 2 ^ 14 Zellen sind .

Kann jemand erraten, warum es 2 ^ 14 ist?

Common Lisp, 103 128 Zeichen

(defun x(s)(reduce(lambda(x y)(+(* 26 x)y))(map 'vector(lambda(b)(-(char-code b)(char-code #\A)-1))s)))

C #, 117 111 Zeichen

Kein Wettbewerb im Vergleich zu Perl, Ruby und APL, aber eine Verbesserung gegenüber den anderen bisher gegebenen C # / Java-Antworten.

Dies verwendet die Horner-Regel .

class C{static void Main(string[]a){int t=0;foreach(var c in a[0]){t=(t+c-64)*26;}System.Console.Write(t/26);}}

Perl, 34 Zeichen

map$\=26*$\-64+ord,pop=~/./g;print

Vielen Dank an mobrule für einige Vorschläge.

C #, 148 Zeichen

using System;class P{static void Main(string[]a){var r=0d;int j=0,i=a[0].
Length;while(i-->0)r+=(a[0][i]-64)*Math.Pow(26,j++);Console.WriteLine(r);}}

Ungolfed:

using System;
class P
{
    static void Main(string[] a)
    {
        var r = 0d;
        int j = 0, i = a[0].Length;
        while (i-- > 0)
            r += (a[0][i] - 64) * Math.Pow(26, j++);

        Console.WriteLine(r);
    }
}

Python - 63 Zeichen

>>> f = Lambda z: reduzieren (Lambda x, y: 26 * x + y, [ord (c) -64 für c in z])

>>> f ('ROFL')

326676

Clojure:

user> (reduce #(+ (* 26 %1) %2) (map #(- (int %) 64) "AD"))
30
user> (reduce #(+ (* 26 %1) %2) (map #(- (int %) 64) "ROFL"))
326676

51 Zeichen plus die Anzahl der Zeichen in der Eingabezeichenfolge.

C:

int r=0;
while(*c)r=r*26+*c++-64;

Die Zeichenfolge wird in 'c' gespeichert, der Wert in 'r'.

Ruby 1.9, 21 Zeichen

p'A'.upto(gets).count

Tests:

$ echo -n A| ruby x.rb
1
$ echo -n WTF| ruby x.rb
16074
$ echo -n ROFL| ruby x.rb
326676

Common Lisp, 86 Zeichen.

(defun z(s)(let((a 0))(map nil(lambda(v)(setf a(+(* 26 a)(digit-char-p v 36)-9)))s)a))

Java: 112 124 Zeichen

class C{public static void main(String[]a){int r=0;for(int b:a[0].getBytes())r=26*r+b-64;System.out.print(r);}}

Common Lisp, 81 Zeichen

(defun y(s)(reduce(lambda(x y)(+(* 26 x)(-(char-code y)64)))s :initial-value 0))

Komisch, dass ich als neuer Benutzer meine eigene Antwort posten kann, aber nicht die eines anderen kommentieren kann. Na ja, entschuldige, wenn ich das falsch mache!

MATLAB: 24 Zeichen

polyval(input('')-64,26)

Verwendung:

>> polyval(input('')-64,26)
(after pressing enter) 'WTF'

ans =

       16074

Hinweis: Sie können es auf 16 Zeichen reduzieren, wenn Sie die Zeichenfolge vorab speichern x, aber ich dachte, es wäre ein Betrug:

>> x = 'WTF'

x =

WTF

>> polyval(x-64,26)

ans =

       16074

PHP - 73 Zeichen

$n=$argv[1];$s=$i=0;while($i<strlen($n))$s=$s*26+ord($n[$i++])-64;echo$s;

Verwendung:

php -r '$n=$argv[1];$s=$i=0;while($i<strlen($n))$s=$s*26+ord($n[$i++])-64;echo$s;' AA

> 27