我今天整整都是在Super Smash Bros.比赛中度过的，我开始考虑在描述场景时使用的一些术语。这是我在锦标赛中看到的三组比赛：

• 最好的3（Bo3）
  • 进行了三场比赛。比赛的获胜者是赢得大部分比赛的玩家。
  • 如果一个玩家赢得了本局的两场比赛，他们将立即被宣布为获胜者，因为对手不可能追上。
• 最好的5（Bo5）
  • 玩了五场比赛。比赛的获胜者是赢得大部分比赛的玩家。
  • 如果一个玩家赢得了该局的三场比赛，他们将立即被宣布为获胜者，因为对手不可能追上。
• 第1至5（Ft5）
  • 好吧，我之前的措词有点作弊。这种场景不是比赛的一部分，但是您经常会看到它们在场地中发生。传统上，如果您已经挑战了另一个玩家并且钱就到了，这就是您将要玩的那种背景。
  • 听起来很简单：玩家反复玩游戏，直到其中一位赢得五分，然后宣布该玩家为赢家。

显然，Bo3和Bo5非常相似，只是玩的次数不同。但是Ft5明显不同...对吗？并不是的！无论Bo3组合如何下降，获胜者都将赢得两场比赛。Bo5组的赢家将赢得3场比赛。为什么不称它们为Ft2或Ft3？反向应用相同的逻辑将表明Ft5与Bo9完全相同。

这个挑战的目的是确定集合格式的同义词。

规格

您的程序或函数将从input中获取单个字符串。前两个字符为Bo或Ft，后跟一个数字。程序/函数将输出带有相反前缀和数字的字符串，以使输入和输出字符串含义相同。

以开头的任何字符串Bo都将以奇数结尾。

您可能会假设输入字符串中的数字永远不会大于200。也可能会假设您永远不会收到正确的输出包含大于200的数字的输入。同样，输入和正确的输出数字将始终大于0。

例子

Bo3 -> Ft2
Ft2 -> Bo3

Bo5 -> Ft3
Ft3 -> Bo5

Bo9 -> Ft5
Ft5 -> Bo9

Bo51 -> Ft26
Ft26 -> Bo51

Bo199 -> Ft100
Ft100 -> Bo199

Pyth，23个字节

@,/hKsttz2tyKCp-"BoFt"z

测试套件。

怎么运行的：

首先，要找到Bo或者Ft，该程序过滤掉从输入的字符BoFt，用-"BoFt"z。

立即用印出p。p还返回其输入。该字符串将转换为数字，将字节解释为以256为基数。如果字符串为Bo，则结果为17007，如果字符串为，则结果为18036 Ft。

接下来，它计算两种可能的结果，num * 2 - 1并将(num + 1)/2其放入2条目列表。然后，程序使用上面的数字17007或18036索引到该列表中。由于Pyth的模块化索引，因此选择了正确的数字。然后自动打印结果。

由于p打印没有尾随换行符，但是隐式打印确实具有尾随换行符，因此连续两次打印都以正确的格式输出。

Python 2，59

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

在允许功能的简短挑战中，lambda即使由于无法分配变量而必须重复执行代码，通常也要简短一些。

我们通过字符串比较来检查哪种情况s>'C'。然后，使用列表切片技巧获取正确的前缀'FBto'[s>'C'::2]。

为了获得数量，我们必须评估超过第二的人物，做任何*2+1或/2-1给它。为此，我们将这两个表达式中的任意一个作为字符串添加，然后再次通过列表切片进行选择，评估结果并将该数字转换为字符串。

编辑：保存了一个字符（59）：

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

甚至都不问...

C ++ 11模板元编程，305字节

编辑：关闭了另外100个字节

我在选择语言时会遇到障碍吗？：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'>{};

例子：

#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个字节

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

在线尝试

这里没有什么非常详细的。计算两个可能的结果，并根据输入中的第一个字母选择两个。如果我想出更好的东西会更新。

说明：

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个字节

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

这使得使用的事实'B' ^ 'F' == 4和'o' ^ 't' == 27。

在CJam解释器中在线尝试。

Javascript（ES6），50 47个字符

非常简单的解决方案：（感谢undergroundmonorail删除了一个字节！）

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

取消高尔夫：

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

有一次，我的答案仅为最佳Pyth答案的2倍！

Haskell，69个字节

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

合理直接。

Pyth-31个字节

非常简单，使用zip和模块化索引来进行切换。实际计算非常简单。

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

测试套件。

朱莉娅63字节

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

取消高尔夫：

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个字节

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

例子：

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

Powershell，111

PowerShell的冗长性和所需的括号再次成为其劣势。即使打高尔夫球到.Substring(0,2)，[0..1]-join''每个命令也仅节省2个字节，而隐含的Else感谢exit命令也节省了另外几个字节。那好吧。分隔字符串方面的良好复习。

码：

$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)

用法：

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

说明

$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个字节（对于，为37 +1 -p）

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

用法：另存为54768.pl并运行为：

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

或以交互方式：

perl -p 54768.pl
Bo199
# Ft100

FSharp - 153个 143字节

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.)

更新

1. 通过从模式匹配切换到简单模式，减少了几个字节 if ... then ...

Ruby，82字节

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

用一个参数来敲除几个字节。
第一篇文章，欢迎提出建议。:)

编辑：通过改变我的数学摆脱了12个字节。由于Bo数是奇数，它们在除以2后将始终有一个小数，这意味着我可以截断并加1，而不用ceil舍入。

PHP，85 79 75字节

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

用法：
使用参数调用脚本：php -d error_reporting=0 script.php Bo5

不像其他人那么荒谬，但这是我的第一篇文章：

JS，143字节

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

非高尔夫版本：

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字节

R和此站点是代码高尔夫的新手。因此，这里去：

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个字节

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