Nous espérons donc tous être familiers avec la notation des cellules du tableur «A1».

Il s'agit simplement d'une représentation alphanumérique du positionnement de ladite cellule au sein d'une grille. La ou les lettres représentent le positionnement des colonnes de la cellule et le nombre représente la ligne.

La partie «lettre» peut comprendre une ou plusieurs lettres de l'alphabet anglais à 26 lettres, qui doivent toutes être des majuscules. Ces cartes correspondent aux nombres grâce à l'utilisation de la numération bijective à 26 adiques. La partie «nombre» peut être constituée de tout entier positif non nul.

Le défi, écrire un programme qui, étant donné la notation A1 de n'importe quelle cellule sous la forme d'une chaîne unique, peut produire une chaîne contenant la position de la colonne représentée sous forme de nombre, suivi d'un espace, puis du numéro de ligne.

Exemples d'entrées / sorties ci-dessous:

A1
>>1 1
B10
>>2 10
AC4 
>>29 4
AAC753
>>705 753
F123
>>6 123
GL93
>>194 93

C'est mon premier défi, d'où la relative simplicité et la pauvreté potentielle des critères.

EDIT : La chaîne doit être composée de lettres suivies de chiffres et le critère gagnant est la longueur de code la plus courte (si cela peut être une chose)

EDIT : lié à cela mais fait le processus inverse avec un index de départ différent. Certains diront que ce fait rend le puzzle lié plus intéressant.

05AB1E , 12 11 octets

áÇ64-₂βð¹þJ

Utilise l' encodage 05AB1E . Essayez-le en ligne!

Microsoft Excel, 43 octets.

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

Je ne pouvais pas m'en empêcher, je devais juste utiliser le bon outil pour le travail. Prend une entrée sur A1.

Cas de test

Microsoft Excel, 40 octets

Version en langue portugaise du Brésil.

=COL(INDIRETO(A1))&" "&LIN(INDIRETO(A1))

Version traduite (et donc golfée) de la solution d' ATaco .

Python 2 , 94 91 73 octets

^{-3 octets grâce à Jonathan Allan
-18 octets grâce à tsh}

s=input().strip
a=s(`3**39`);t=0
for n in a:t=t*26+ord(n)-64
print t,s(a)

Essayez-le en ligne!

Cela abuse de la façon dont cela .stripfonctionne, en supprimant tous les chiffres avec a=s(`3**39`)où `3**39`est juste un moyen plus court de générer les chiffres de 0à 9, cela ne stockera que les caractères sur aqui seront utilisés pour supprimer les caractères des numéros surs(a)

Google Sheets, 43 octets

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

Essayez-le en ligne!

A1est la cellule d'entrée. J'espère que le lien ci-dessus fonctionne, je n'ai jamais essayé le golf de code avec Google Sheets auparavant.

JavaScript, 72 octets

x=>x.replace(/\D+/,s=>[...s].reduce((n,v)=>n*26+parseInt(v,36)-9,0)+' ')

Proton , 113 octets

k=>{b=(s=k.strip)('0123456789');str(sum(map((a=>26**a[1][0]*(ord(a[1][1])-64)),enumerate(b[to by-1]))))+' '+s(b)}

Essayez-le en ligne!

-19 octets empruntant l'algorithme de Rod ( note à soi: ajout de listcomps )

Dyalog APL, 44 octets

(26⊥¯65+⎕AV⍳(a~⎕D)),⎕A~⍨a←⍞

Essayez-le en ligne!

Pyth - 31 octets

Première tentative, très naïve.

jd,s*V.u*26NQ1_hMxLGr-QK@`UTQZK

Essayez-le en ligne ici .

Perl 5 , 35 + 1 (-p) = 36 octets

map$r=$r*26-64+ord,/\D/g;s/\D*/$r /

Essayez-le en ligne!

L' mapinstruction traite la colonne comme un nombre base26 et la convertit en décimal. La substitution remplace les lettres par les chiffres. L'entrée et la sortie sont implicites dans l' -pindicateur.

Mathematica, 108 octets

StringReplace[c:LetterCharacter..~~r:DigitCharacter..:>ToString@FromDigits[ToCharacterCode@c-64,26]<>" "<>r]

La forme opérateur StringReplaceprend la partie alphabétique cde la chaîne, la convertit en une liste de codes de caractères, soustrait 64de chaque point de code, interprète le résultat comme un 26entier de base , convertit cet entier en un String, puis StringJoinun espace sa suivi par la partie numérique r.

Utilisation d'une expression régulière (également 108octets):

StringReplace[RegularExpression["([A-Z]+)(.+)"]:>ToString@FromDigits[ToCharacterCode@"$1"-64,26]<>" "<>"$2"]

Gelée ,  16  15 octets

ØAɓi@€ḟ0ḅ26,⁸Kḟ

Un programme complet acceptant la chaîne comme argument et affichant le résultat

Essayez-le en ligne!

Comment?

ØAɓi@€ḟ0ḅ26,⁸Kḟ - Main link: list of characters, ref  e.g. "AAC753"
ØA              - uppercase alphabet yield               = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  ɓ             - dyadic chain separation, call that B and place it on the right
   i@€          - first index for €ach (swap arguments)    [1,1,3,0,0,0]
      ḟ0        - filter discard zeros                     [1,1,3]
        ḅ26     - convert from base 26 to integer           705
            ⁸   - chain's left argument (ref)              "AAC753"
           ,    - pair                                     [705,['A','A','C','7','5','3']]
             K  - join with spaces                         [705,' ','A','A','C','7','5','3']
              ḟ - filter discard those in right (B)        [705,' ','7','5','3']
                - implicit print                        >>>705 753

Remarque: la conversion à partir d'une liste de nombres à l'aide de l'atome de conversion de base ḅpermet aux lieux d'être en dehors de la plage attendue, donc la conversion à partir de, disons [2,26,1]( "BZA") en utilisant ḅ26est calculée comme 2 × 26 ² + 26 × 26 ¹ + 1 × 26 ⁰ = 2029 même si la représentation "attendue" l'aurait été [3,0,1].

Mathematica, 77 72 69 68 octets

#/.{a__,b__?DigitQ}:>{f=FromDigits;f[LetterNumber@{a},26],f[b<>""]}&

Prend une liste de personnages.

Essayez-le sur Wolfram Sandbox

Usage

#/.{a__,b__?DigitQ}:>{f=FromDigits;f[LetterNumber@{a},26],f[b<>""]}&[{"G", "L", "9", "3"}]

{194, 93}

ou

#/.{a__,b__?DigitQ}:>{f=FromDigits;f[LetterNumber@{a},26],f[b<>""]}&[Characters["GL93"]]

{194, 93}

Explication

#/.

Dans l'entrée remplacer ...

{a__,b__?DigitQ}

Une liste contenant deux séquences aet b(avec 1 ou plusieurs éléments), où se bcompose uniquement de caractères numériques ... (Mathematica utilise la correspondance de motifs paresseux, donc aucune vérification n'est requise pour a)

:>

dans...

f=FromDigits;

Réglez fsur la fonction de conversion numérique-entier.

LetterNumber@{a}

Convertissez aen lettres (a -> 1, b -> 2, etc.).

{f[ ... ,26],f[b<>""]}

Convertissez ce qui précède de la base-26 en décimal et convertissez-le ben décimal.

Haskell, 67 octets

(\(l,n)->show(foldl(\a->(a*26-64+).fromEnum)0l)++" "++n).span(>'9')

Essayez-le en ligne.

Rétine , 85 octets

[A-Z]
$& 
[T-Z]
2$&
[J-S]
1$&
T`_L`ddd
\d+
$*
{`\G1(?=.* .* )
26$*
}` (.* )
$1
1+
$.&

Essayez-le en ligne! Explication:

[A-Z]
$& 

Séparez les lettres les unes des autres et le numéro final.

[T-Z]
2$&
[J-S]
1$&
T`_L`ddd

Convertissez les lettres en décimales.

\d+
$*

Convertissez tout en unaire.

{`\G1(?=.* .* )
26$*
}` (.* )
$1

Tant qu'il y a au moins trois nombres, multipliez le premier par 26 et ajoutez-le au second.

1+
$.&

Convertissez tout en décimal.

Rubis , 50 48 + 1 = 51 49 octets

Utilise le -pdrapeau. -2 octets de m-chrzan.

sub(/\D+/){i=0;$&.bytes{|b|i=26*i+b-64};"#{i} "}

Essayez-le en ligne!

> <>, 42 octets

0i88*-:0(?\$2d**+!
$n88*+48*o\
oi:0(?;   >

Essayez-le en ligne

Explication:

0i88*-:0(?\$2d**+! Read in the Letters part of the input
0                  Push an initial 0 to the stack
 i                 Read a character of input
  88*-             Subtract 64 to get from the ascii code to its value ('A'=1,'B'=2 etc.)
      :0(?\        If the value is less than 0, break out of this loop
           $2d**   Multiply our accumulator by 26
                +  Add our new number to the accumulator
                 ! don't add a new zero to the stack

La boucle ci-dessus lira le premier numéro de la partie des nombres (par exemple, «3» dans «AB34») avant de se rompre, et en aura déjà soustrait 64, donc le bit de code suivant doit gérer cela

$n88*+48*o\        Output a space, and prepare to output the first number we read in during the previous loop
          \        Loop round to the left end of this line
$n                 Output the value of the letters part as a number
  88*+             Add the 64 we subtracted from the first number
      48*o         Output a space
          \        Enter the next loop

Cette boucle commence par sortir un caractère qui sera soit le 1er caractère lu par la première boucle, soit le caractère lu par l'itération précédente de cette boucle.

oi:0(?;   >        Output the numbers part, by just echoing it
          >        Loop round to the start of the line
o                  Output the character
 i                 Read in the next character
  :0(?;            If the value read in was less than 0, terminate

Rubis, 64 61 59 octets

->s{s.sub(/\D+/){"#{$&.bytes.reduce(0){|t,b|t*26+b-64}} "}}

Économisé 2 octets grâce à Value Ink.

Fenêtre Excel-VBA immédiate, 44 45 octets ( 36 35)

Set v=Range([A1]):?trim(v.Column &" "&v.Row);

1 octet ajouté pour supprimer la nouvelle ligne de fin

Ou pour 35 avec des espaces blancs de premier plan

Set v=Range([A1]):?v.Column""&v.Row

1 octet enregistré grâce à @TaylorScott!

Les deux prennent l'entrée de la cellule A1, la sortie vers la fenêtre VBE Immediate

Lua, 127 octets

Quelques belles manipulations de cordes y aller, j'utilise une fonction qui n'est généralement jamais utilisée lors du golf dans lua: D. La meilleure façon de jouer au golf serait de trouver une autre façon d'itérer sur la partie colonne de l'entrée tout en étant capable de conserver la position de chaque lettre. Je n'ai pas ^^ '.

Essayez-le en ligne!

I=...l=I:gsub("%d",""):reverse()r=0
for i=1,#l
do
r=r+(l:sub(i,i):byte()-64)*math.pow(26,i-1)end
print(r.." "..I:gsub("%a",""))

Explication

I=...                       -- shorthand for the input
l=I:gsub("%d","")           -- shorthand for the column part
   :reverse()               -- letters are put in reverse order to calculate their weight
r=0                         -- column number
for i=1,#l                  -- iterate over the letters of the input
do
  r=r+                      -- add to the column number
      (l:sub(i,i):byte()-64)-- the byte value of the current letter minus 64 (A=1 this way)
      *math.pow(26,i-1)     -- then apply its weight in base 26
end
print(r                     -- output the column number
        .." "               -- a space
        ..I:gsub("%a",""))  -- and the row number