Pasé todo el día en un torneo de Super Smash Bros., y comencé a pensar en algo de la terminología que usamos para describir los sets. Estos son los tres tipos de sets que veo jugar en torneos:

• Lo mejor de 3 (Bo3)
  • Se juegan tres juegos. El ganador del set es el jugador que ganó la mayoría de los juegos.
  • Si un solo jugador gana dos juegos del set, se declara inmediatamente ganador, porque sería imposible para el oponente ponerse al día.
• Lo mejor de 5 (Bo5)
  • Se juegan cinco juegos. El ganador del set es el jugador que ganó la mayoría de los juegos.
  • Si un solo jugador gana tres juegos del set, se declara inmediatamente ganador, porque sería imposible que el oponente lo alcanzara.
• Primero a 5 (Ft5)
  • Bien, hice trampa un poco con mi redacción anterior. Este tipo de set no es parte de un torneo, pero a menudo los verás en el lugar. Este es tradicionalmente el tipo de set que jugarás si has desafiado a otro jugador y el dinero está en juego.
  • Es tan simple como parece: los jugadores juegan repetidamente hasta que uno de ellos ha ganado cinco, y ese jugador es declarado ganador.

Obviamente, Bo3 y Bo5 son muy similares, y solo difieren en la cantidad de juegos jugados. Pero Ft5 es claramente diferente ... ¿verdad? ¡Realmente no! No importa cómo se caiga un conjunto de Bo3, el ganador habrá ganado exactamente dos juegos. El ganador de un set de Bo5 habrá ganado exactamente 3 juegos. ¿Por qué no llamarlos Ft2 o Ft3? La misma lógica, aplicada en reversa, mostrará que Ft5 es exactamente lo mismo que Bo9.

El objetivo de este desafío es determinar el sinónimo de un formato establecido.

Especificación

Su programa o función tomará una sola cadena de entrada . Los primeros dos caracteres serán Boo Ft, y serán seguidos por un número. La voluntad del programa / función de salida de una cadena con el prefijo opuesto y un número tal que las cadenas de entrada y de salida significan la misma cosa.

Cualquier cadena que comience con Boterminará en un número impar.

Puede suponer que el número en la cadena de entrada nunca será mayor que 200. También puede suponer que nunca recibirá una entrada para la cual la salida correcta incluiría un número mayor que 200. Del mismo modo, los números de entrada y salida correctos siempre ser mayor que 0.

Ejemplos

Bo3 -> Ft2
Ft2 -> Bo3

Bo5 -> Ft3
Ft3 -> Bo5

Bo9 -> Ft5
Ft5 -> Bo9

Bo51 -> Ft26
Ft26 -> Bo51

Bo199 -> Ft100
Ft100 -> Bo199

Pyth, 23 bytes

@,/hKsttz2tyKCp-"BoFt"z

Banco de pruebas.

Cómo funciona:

Primero, para encontrar el Boo Ft, el programa filtra los caracteres en la entrada desde BoFt, con -"BoFt"z.

Esto se imprime inmediatamente con p. pTambién devuelve su entrada. Esa cadena se convierte en un número que interpreta los bytes como base 256. El resultado es 17007 si la cadena era Bo, y 18036 si la cadena era Ft.

A continuación, se calcula tanto los posibles resultados, num * 2 - 1y (num + 1)/2y pone esto en una lista 2 de entrada. Luego, el programa se indexa en esa lista con el número anterior, 17007 o 18036. Debido a la indexación modular de Pyth, esto selecciona el número apropiado. El resultado se imprime automáticamente.

Dado que las pimpresiones no tienen una nueva línea final, pero la impresión implícita tiene la nueva línea final, las dos impresiones sucesivas salen exactamente en el formato correcto.

Pitón 2, 59

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

En los desafíos cortos donde se permiten funciones, la brevedad lambdageneralmente gana incluso cuando el código debe repetirse debido a la incapacidad de asignar variables.

Verificamos en qué caso estamos con la comparación de cadenas s>'C'. Luego, obtenga el prefijo correcto con el truco de corte de lista 'FBto'[s>'C'::2].

Para obtener el número, debemos evaluar los caracteres más allá del segundo y hacer uno *2+1u otro /2-1. Hacemos esto agregando cualquiera de esas dos expresiones como cadenas, nuevamente elegidas por corte de lista, evaluando el resultado y convirtiendo ese número en una cadena.

Editar: Guardado un personaje (59):

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

Ni siquiera preguntes ...

Metaprogramación de plantilla C ++ 11, 305 bytes

Editar: Tengo otros 100 bytes de descuento

¿Recibo algún tipo de discapacidad para mi elección de idioma? :pag

#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'>{};

Ejemplos:

#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*(+?

Pruébalo en línea

Nada muy elaborado aquí. Calcular los dos resultados posibles y elegir uno de los dos en función de la primera letra de la entrada. Se actualizará si se me ocurre algo mejor.

Explicación:

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/?

Esto hace uso del hecho de que 'B' ^ 'F' == 4y 'o' ^ 't' == 27.

Pruébelo en línea en el intérprete de CJam .

Javascript (ES6), 50 47 caracteres

Solución muy simple: (¡Gracias al metro subterráneo para eliminar un byte!)

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

Sin golf:

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

¡Por una vez mi respuesta fue solo ~ 2 veces la longitud de la mejor respuesta de Pyth!

Haskell, 69 bytes

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

Razonablemente sencillo.

Pyth - 31 bytes

Bastante simple, utiliza la indexación zip y modular para obtener el cambio. El cálculo real es realmente fácil.

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

Banco de pruebas .

Julia, 63 bytes

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

Sin golf:

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

Ejemplos:

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

Powershell, 111

La palabrería de PowerShell y los paréntesis requeridos son su caída nuevamente. Incluso el golf .Substring(0,2)a [0..1]-join''sólo ahorra 2 bytes cada uno, y otra pareja de bytes salvado con una implícitas Elsegracias a laexit mando. Oh bien. Buen repaso en la separación de cuerdas.

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

Explicación

$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 : guardar como 54768.pl y ejecutar como:

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

o interactivamente:

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

Actualizaciones

1. Eliminó algunos bytes al cambiar de coincidencia de patrones a simple if ... then ...

Rubí, 82 bytes

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

Llamado con un argumento para eliminar algunos bytes.
Primer post, sugerencias bienvenidas. :)

EDITAR: Me libré de 12 bytes cambiando mis matemáticas. Como los números de Bo son impares, siempre tendrán un decimal después de dividir entre 2, lo que significa que puedo truncar y agregar 1 en lugar de usar ceilpara redondear.

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:
llame al script con un argumento:php -d error_reporting=0 script.php Bo5

No es ridículamente corto como los demás, pero esa es mi primera publicación:

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

Versión sin golf:

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

Nuevo en code-golfing, R, y este sitio. Entonces aquí va:

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