Я провів увесь сьогоднішній день на турнірі Super Smash Bros., і я почав думати про деякі термінології, які ми використовуємо при описі наборів. Це три види сетів, які я бачу, що грали на турнірах:

• Найкраще з 3 (Bo3)
  • Зіграно три гри. Переможець набору - гравець, який виграв більшість ігор.
  • Якщо один гравець виграє дві гри в сеті, вони одразу оголошуються переможцем, оскільки супернику було б неможливо наздогнати.
• Найкраще з 5 (Bo5)
  • Зіграно п'ять ігор. Переможець набору - гравець, який виграв більшість ігор.
  • Якщо один гравець виграє три ігри набору, їх негайно оголошують переможцем, бо суперник не зможе наздогнати.
• Перший до 5 (Ft5)
  • Гаразд, я трохи обдурив своє формулювання. Цей вид набору не є частиною турніру, але ви часто бачите, як вони відбуваються на місці проведення. Це традиційно той тип набору, який ви будете грати, якщо ви кинули виклик іншому гравцеві, а гроші на черзі.
  • Це так просто, як це звучить: Гравці повторно грають в ігри, поки один з них не виграє п’ять, і той гравець не буде оголошений переможцем.

Очевидно, що Bo3 і Bo5 дуже схожі, відрізняються лише кількістю ігор, що граються. Але Ft5 явно відрізняється ... правда? Не зовсім! Як би не знизився набір Bo3, переможець виграє рівно дві гри. Переможець набору Бо5 виграє рівно 3 ігри. Чому б не назвати їх Ft2 або Ft3? Ця ж логіка, застосована у зворотному напрямку, покаже, що Ft5 точно такий же, як Bo9.

Мета цього завдання - визначити синонім заданого формату.

Специфікація

Ваша програма або функція займе один рядок із введення . Перші два символи будуть 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. Результат 17007, якщо рядок був Bo, і 18036, якщо рядок був Ft.

Потім він обчислює обидва можливих результатів, num * 2 - 1і (num + 1)/2та поміщає це в списку 2 входи. Потім програма індексує цей список із вказаним вище номером 17007 або 18036. Завдяки модульній індексації Pyth це вибирає потрібне число. Потім результат друкується автоматично.

Оскільки pвідбитки не мають зворотного нового рядка, але при неявній друку є зворотний новий рядок, два наступні відбитки виходять у правильному форматі.

Пітон 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 байт

Чи можу я отримати якісь проблеми з вибором мови? : с

#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 знаків

Дуже просте рішення: (Завдяки підземніймонорельсі за видалення одного байта!)

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

Одного разу моя відповідь була лише ~ 2х тривалістю найкращої відповіді Pyth!

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

Матлаб, 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 ...

Рубі, 82 байт

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

Викликається з аргументом, щоб збити кілька байт.
Перше повідомлення, пропозиції вітаються. :)

EDIT: Я позбувся 12 байт, змінивши математику. Оскільки числа Бо є непарними, вони завжди будуть мати десятковий знак після ділення на 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);}