Passei o dia todo hoje em um torneio Super Smash Bros. e comecei a pensar em algumas das terminologias que usamos ao descrever sets. Estes são os três tipos de sets que vejo jogados em torneios:

• Melhor de 3 (Bo3)
  • Três jogos são disputados. O vencedor do set é o jogador que venceu a maioria dos jogos.
  • Se um único jogador vence dois jogos do set, ele é imediatamente declarado vencedor, porque seria impossível para o adversário recuperar o atraso.
• Melhor de 5 (Bo5)
  • Cinco jogos são disputados. O vencedor do set é o jogador que venceu a maioria dos jogos.
  • Se um único jogador vence três jogos do set, ele é imediatamente declarado vencedor, porque seria impossível para o adversário recuperar o atraso.
• Primeiro a 5 (Ft5)
  • Ok, eu trapacei um pouco com o meu texto mais cedo. Esse tipo de cenário não faz parte de um torneio, mas muitas vezes você os vê acontecendo no local. Tradicionalmente, esse é o tipo de jogo que você jogará se tiver desafiado outro jogador e o dinheiro estiver em jogo.
  • É tão simples quanto parece: os jogadores jogam repetidamente até que um deles tenha ganho cinco, e esse jogador seja declarado vencedor.

Obviamente, o Bo3 e o Bo5 são muito semelhantes, diferindo apenas no número de jogos disputados. Mas Ft5 é claramente diferente ... certo? Na verdade não! Não importa como um set de Bo3 diminua, o vencedor terá vencido exatamente dois jogos. O vencedor de um conjunto Bo5 terá vencido exatamente 3 jogos. Por que não chamá-los de Ft2 ou Ft3? A mesma lógica, aplicada ao contrário, mostrará que Ft5 é exatamente o mesmo que Bo9.

O objetivo deste desafio é determinar o sinônimo de um formato definido.

Especificação

Seu programa ou função terá uma única sequência de caracteres da entrada . Os dois primeiros caracteres serão Boor Fte serão seguidos por um número. O programa / função produzirá uma sequência com o prefixo oposto e um número tal que as sequências de entrada e saída tenham o mesmo significado.

Qualquer sequência iniciada com Boterminará em um número ímpar.

Você pode assumir que o número na cadeia de entrada nunca será maior que 200. Você também pode assumir que nunca receberá entrada para a qual a saída correta incluiria um número maior que 200. Da mesma forma, os números de entrada e saída corretos sempre serão ser maior que 0.

Exemplos

Bo3 -> Ft2
Ft2 -> Bo3

Bo5 -> Ft3
Ft3 -> Bo5

Bo9 -> Ft5
Ft5 -> Bo9

Bo51 -> Ft26
Ft26 -> Bo51

Bo199 -> Ft100
Ft100 -> Bo199

Pitão, 23 bytes

@,/hKsttz2tyKCp-"BoFt"z

Suíte de teste.

Como funciona:

Primeiro, para encontrar o Boou Ft, o programa filtra os caracteres na entrada de BoFt, com-"BoFt"z .

Isso é imediatamente impresso com p. ptambém retorna sua entrada. Essa sequência é convertida em um número que interpreta os bytes como base 256. O resultado é 17007 se a sequência for Boe 18036 se a sequência for Ft.

Em seguida, calcula os dois resultados possíveis num * 2 - 1e(num + 1)/2 e coloca isso em uma lista 2 entrada. Em seguida, o programa indexa nessa lista com o número acima, 17007 ou 18036. Devido à indexação modular de Pyth, isso seleciona o número apropriado. O resultado é impresso automaticamente.

Como as pimpressões sem nova linha final, mas a impressão implícita tem a nova linha final, as duas impressões sucessivas são exibidas exatamente no formato correto.

Python 2, 59

lambda s:'FBto'[s>'C'::2]+`eval(s[2:]+'/*22+-11'[s>'C'::2])`

Em breves desafios em que funções são permitidas, a brevidade de lambda geralmente vence mesmo quando o código deve se repetir devido à incapacidade de atribuir variáveis.

Verificamos em qual caso estamos com a comparação de strings s>'C'. Em seguida, obtenha o prefixo certo com o truque de fatiar a lista 'FBto'[s>'C'::2].

Para obter o número, devemos avaliar os caracteres além do segundo e fazer um *2+1ou outro /2-1. Fazemos isso aderindo a uma dessas duas expressões como cadeias, novamente escolhidas por fatias de lista, avaliando o resultado e transformando esse número em uma cadeia.

Editar: salvou um char (59):

lambda s:eval("''FBto''++``%%ss/*22+-11``"[s>'C'::2]%s[2:])

Nem pergunte ...

Metaprogramação de modelos C ++ 11, 305 bytes

Editar: obtive mais 100 bytes de desconto

Recebo algum tipo de deficiência para a minha escolha de idioma? : p

#define C wchar_t
#define T };template<C p
#define L C...l>struct
#define X l...>
C a{T,L I{T,C c,L I<p,c,X:I<10*p+c-'0',X{T>struct I<p>{enum E{v=p};T,L S{T,C c,C d,L G:G<p/10,c,d,p%10+'0',X{T,L G<0,p,X{typedef S<p,X t;T,L F{T,L F<p,'o',X:G<(I<0,X::v+1)/2,'F','t'>{T,L F<p,'t',X:G<I<0,X::v*2-1,'B','o'>{};

Exemplos:

#include <type_traits>
static_assert(I<0,'5'>::v == 5, "fail");
static_assert(I<0,'1','0','5'>::v == 105, "fail");
static_assert(I<0,'5','1'>::v == 51, "fail");
static_assert(std::is_same<typename G<5,'B','o'>::t, S<'B','o','5'>>::value, "fail");
static_assert(std::is_same<typename G<51,'F','t'>::t, S<'F','t','5','1'>>::value, "fail");
static_assert(std::is_same<typename F<'B','o','3'>::t, S<'F','t','2'>>::value, "fail");
static_assert(std::is_same<typename F<'F','t','2'>::t, S<'B','o','3'>>::value, "fail");
static_assert(std::is_same<typename F<'B','o','5'>::t, S<'F','t','3'>>::value, "fail");
static_assert(std::is_same<typename F<'F','t','3'>::t, S<'B','o','5'>>::value, "fail");
static_assert(std::is_same<typename F<'B','o','7'>::t, S<'F','t','4'>>::value, "fail");
static_assert(std::is_same<typename F<'F','t','4'>::t, S<'B','o','7'>>::value, "fail");
static_assert(std::is_same<typename F<'B','o','1','1'>::t, S<'F','t','6'>>::value, "fail");
static_assert(std::is_same<typename F<'F','t','6'>::t, S<'B','o','1','1'>>::value, "fail");
static_assert(std::is_same<typename F<'B','o','1','0','5'>::t, S<'F','t','5','3'>>::value, "fail");
static_assert(std::is_same<typename F<'F','t','5','3'>::t, S<'B','o','1','0','5'>>::value, "fail");
static_assert(std::is_same<typename F<'B','o','1','9','5'>::t, S<'F','t','9','8'>>::value, "fail");
static_assert(std::is_same<typename F<'F','t','9','8'>::t, S<'B','o','1','9','5'>>::value, "fail");
int main() {}

CJam, 29 bytes

l('B=\1>i"Ft"1$)2/+"Bo"@2*(+?

Experimente online

Nada muito elaborado aqui. Calculando os dois resultados possíveis e escolhendo um dos dois com base na primeira letra da entrada. Será atualizado se eu apresentar algo melhor.

Explicação:

l     Get input.
(     Pop off first character.
'B=   Compare with 'B.
\1>   Get rest of input to top of stack, and slice off first character.
i     Convert to integer.
"Ft"  String part of first possible output.
1$    Copy input value to top.
)2/   Increment, and divide by 2.
+     Concatenate with string part.
"Bo"  String part of second possible output.
@     Move input value to top.
2*(   Multiply by 2, and decrement.
+     Concatenate with string part.
?     Ternary to pick one of the two constructed outputs, based on comparison
      of first input character with 'B.

CJam, 27 bytes

4 27]r.^(_o'B=\(oi_2*(\)2/?

Isso faz uso do fato de que 'B' ^ 'F' == 4e 'o' ^ 't' == 27.

Experimente online no intérprete CJam .

Javascript (ES6), 50 47 caracteres

Solução muito simples: (Obrigado ao undergroundmonorail por remover um byte!)

x=>(y=x.slice(2),x<'C'?'Ft'+-~y/2:'Bo'+(y*2-1))

Ungolfed:

function(x){
  y = x.slice(2); // everything after the 'Ft' or 'Bo'
  return x<'C' ? 'Ft'+Math.ceil(y/2) : 'Bo'+(y*2-1)
}

Pela primeira vez, minha resposta foi apenas aproximadamente o dobro da duração da melhor resposta de Pyth!

Haskell, 69 bytes

f('B':_:x)="Ft"++show(div(read x)2+1)
f(_:_:x)="Bo"++show(2*read x-1)

Razoavelmente direto.

Pitão - 31 bytes

Bastante simples, usa indexação zip e modular para obter a opção. O cálculo real é realmente fácil.

s@C,Jc"FtBo"2,h/Ksttz2tyKhxJ<z2

Conjunto de teste .

Julia, 63 bytes

x->(y=int(x[3:end]);join([x<"C"?"Ft":"Bo",x<"C"?(y+1)÷2:2y-1]))

Ungolfed:

function f(x::String)
    # Extract the number at the end
    y = int(x[3:end])

    # If x is lexographically less than "C", we have
    # "best of," so we need "first to." Otherwise we
    # need "best of."
    if x < "C"
        join(["Ft", (y+1)÷2])
    else
        join(["Bo", 2y-1])
    end
end

Matlab, 95 bytes

function f(s)
t='Bo';a=2;b=-1;if s(1)<70
t='Ft';a=.5;b=a;end
[t num2str(str2num(s(3:end))*a+b)]

Exemplos:

>> f('Ft5')
ans =
Bo9
>> f('Bo51')
ans =
Ft26

Powershell, 111

A redação do PowerShell e os parênteses necessários são sua queda novamente. Mesmo golfe o .Substring(0,2)que [0..1]-join''só poupa 2 bytes cada, e outro casal bytes salvos com uma implícitas Elsegraças ao exitcomando. Ah bem. Boa atualização na separação de strings.

Código:

$b=($a=$args[0])[0..1]-join'';$c=+($a[2..($a.Length-1)]-join'');if($b-eq"Bo"){"Ft"+($c+1)/2;exit};"Bo"+(2*$c-1)

Uso:

PS C:\Scripts\Golfing> .\ssb_tourney.ps1 Bo199
Ft100

Explicação

$b=($a=$args[0])[0..1]-join''      # Take in the command-line argument as $a, recast as
                                   # array, suck out the first two characters, save as $b
$c=+($a[2..($a.Length-1)]-join'')  # Do a similar trick with the right-hand side of $a,
                                   # re-cast it as an integer with the +
if($b-eq"Bo"){                     # If the first letters are "Bo"
    "Ft"+($c+1)/2                  # Implied write of the answer
    exit
}
"Bo"+(2*$c-1)                      # Implied write of the other answer, only reached if
                                   # the input is "Ft", else we would have hit the exit

Perl 5, 38 bytes (37 + 1 para -p)

$_=/Bo/?Ft.(.5+$'/2):Bo.(2*s/Ft//r-1)

Uso : salve como 54768.pl e execute como:

perl -p 54768.pl <<< 'Bo3'
# Ft2

ou interativamente:

perl -p 54768.pl
Bo199
# Ft100

FSharp - 153 143 bytes

let t(s:string)=
 let c=s.[2..]|>Seq.map string|>Seq.reduce(+)|>float
 if s.[0]='B'then sprintf"Ft%.0f"(ceil(c/2.)) else sprintf"Bo%.0f"(c*2.-1.)

Atualizações

1. Derrubou alguns bytes alternando da correspondência de padrões para uma simples if ... then ...

Ruby, 82 bytes

x=$*[0]
y=x.match(/..(\d*)/)[1].to_i
x=~/Bo/?(puts"Ft#{y/2+1}"):(puts"Bo#{y*2-1}")

Chamado com um argumento para eliminar alguns bytes.
Primeiro post, sugestões bem-vindas. :)

EDIT: Se livrou de 12 bytes, alterando minha matemática. Como os números Bo são ímpares, eles sempre terão um decimal depois de dividir por 2, o que significa que eu posso truncar e adicionar 1 em vez de usar ceilpara arredondar para cima.

PHP, 85 79 75 bytes

<?php
$f=$argv[1];$s=substr($f,2);echo strpos($f,Bo)===0?Ft.($s+1)/2:Bo.($s*2-1);

Uso:
chame o script com um argumento:php -d error_reporting=0 script.php Bo5

Não é ridiculamente curto como os outros, mas esse é o meu primeiro post:

JS, 143 bytes

f=prompt("","");n=parseInt(f.match(/\d{1,}/));s=0;r=0;if(f.match(/B/)){r=(n+1)/2;s="Ft"+r;}if(f.match(/F/)){r=n*2-1;s="Bo"+r;}alert(f+" : "+s);

Versão Ungolfed:

var f = prompt("", "");
var n = parseInt(f.match(/\d{1,}/));
var s = 0;
var r = 0;

if (f.match(/B/)) {
  r = (n + 1)/ 2;
  s = "Ft"+r;
 }
if (f.match(/F/)) {
  r = n * 2 - 1;
  s = "Bo"+r;
 }
alert(f+" : "+s);

R, 144 bytes

Novo no código de golfe, R e neste site. Então aqui vai:

a=function(){n=readline();z="Bo";p=(as.numeric(gsub("[^0-9]","",n)));if(grepl(z,n)==TRUE){x="Ft";b=(p+1)/2}else{x="Bo";b=p*2-1};cat(x);cat(b)}

C #, 110 bytes

string f(string s){var b=s[0]=='B';var o=s.Remove(0,2);int i=int.Parse(o)/2;return b?"Ft"+(i+1):"Bo"+(4*i-1);}