J'ai passé toute la journée à un tournoi Super Smash Bros., et j'ai commencé à penser à une partie de la terminologie que nous utilisons pour décrire les sets. Ce sont les trois types de sets que je vois joués lors des tournois:

• Le meilleur des 3 (Bo3)
  • Trois matchs sont joués. Le gagnant de l'ensemble est le joueur qui a remporté la majorité des matchs.
  • Si un seul joueur remporte deux matchs du set, il est immédiatement déclaré vainqueur, car il serait impossible à l'adversaire de rattraper son retard.
• Le meilleur des 5 (Bo5)
  • Cinq matchs sont joués. Le gagnant de l'ensemble est le joueur qui a remporté la majorité des matchs.
  • Si un seul joueur remporte trois matchs du set, il est immédiatement déclaré vainqueur, car il serait impossible à l'adversaire de rattraper son retard.
• Premier à 5 (Ft5)
  • D'accord, j'ai un peu triché avec ma formulation plus tôt. Ce genre d'ensemble ne fait pas partie d'un tournoi, mais vous les verrez souvent se produire sur le site. C'est traditionnellement le genre de set que vous jouerez si vous avez défié un autre joueur et que l'argent est en jeu.
  • C'est aussi simple que cela puisse paraître: les joueurs jouent à plusieurs reprises jusqu'à ce que l'un d'eux en remporte cinq, et ce joueur est déclaré vainqueur.

Évidemment, Bo3 et Bo5 sont très similaires, ne différant que par le nombre de parties jouées. Mais Ft5 est clairement différent ... non? Pas vraiment! Peu importe comment un ensemble Bo3 descend, le vainqueur aura remporté exactement deux matchs. Le vainqueur d'un set Bo5 aura remporté exactement 3 matchs. Pourquoi ne pas les appeler Ft2 ou Ft3? La même logique, appliquée à l'envers, montrera que Ft5 est exactement le même que Bo9.

L'objectif de ce défi est de déterminer le synonyme d'un format défini.

spécification

Votre programme ou fonction prendra une seule chaîne d' entrée . Les deux premiers caractères seront Boou Ft, et ils seront suivis d'un nombre. Le programme / fonction affichera une chaîne avec le préfixe opposé et un nombre tel que les chaînes d'entrée et de sortie signifient la même chose.

Toute chaîne commençant par Bose terminera par un nombre impair.

Vous pouvez supposer que le nombre dans la chaîne d'entrée ne sera jamais supérieur à 200. Vous pouvez également supposer que vous ne recevrez jamais d'entrée pour laquelle la sortie correcte inclurait un nombre supérieur à 200. De même, les numéros d'entrée et de sortie corrects seront toujours être supérieur à 0.

Exemples

Bo3 -> Ft2
Ft2 -> Bo3

Bo5 -> Ft3
Ft3 -> Bo5

Bo9 -> Ft5
Ft5 -> Bo9

Bo51 -> Ft26
Ft26 -> Bo51

Bo199 -> Ft100
Ft100 -> Bo199

Pyth, 23 octets

@,/hKsttz2tyKCp-"BoFt"z

Suite de tests.

Comment ça fonctionne:

Tout d'abord, pour trouver le Boou Ft, le programme filtre les caractères dans l'entrée à partir de BoFt, avec -"BoFt"z.

Ceci est immédiatement imprimé avec p. prenvoie également son entrée. Cette chaîne est convertie en un nombre interprétant les octets comme la base 256. Le résultat est 17007 si la chaîne était Bo, et 18036 si la chaîne étaitFt .

Ensuite, il calcule les résultats possibles, num * 2 - 1et (num + 1)/2et met cela dans une liste d'entrée 2. Ensuite, le programme indexe dans cette liste avec le numéro ci-dessus, 17007 ou 18036. En raison de l'indexation modulaire de Pyth, cela sélectionne le numéro approprié. Le résultat est ensuite imprimé automatiquement.

Etant donné que les pimpressions sans nouvelle ligne de fin, mais l'impression implicite ont la nouvelle ligne de fin, les deux impressions successives sortent exactement au bon format.

Python 2, 59

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

Dans les défis courts où les fonctions sont autorisées, la brièveté de l' lambdaemporte généralement même lorsque le code doit se répéter en raison de l'impossibilité d'affecter des variables.

Nous vérifions dans quel cas nous sommes en comparant les chaînes s>'C'. Ensuite, obtenez le bon préfixe avec l'astuce de découpage de liste 'FBto'[s>'C'::2].

Pour obtenir le nombre, nous devons évaluer les caractères au-delà du second et faire soit *2+1ou /2-1pour lui. Pour ce faire, nous plaçons l'une de ces deux expressions sous forme de chaînes, choisies à nouveau par le découpage de liste, en évaluant le résultat et en transformant ce nombre en chaîne.

Edit: enregistré un caractère (59):

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

Ne demandez même pas ...

Métaprogrammation de modèle C ++ 11, 305 octets

Edit: 100 autres octets de réduction

Est-ce que j'obtiens une sorte de handicap pour mon choix de langue? : 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'>{};

Exemples:

#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 octets

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

Essayez-le en ligne

Rien de très élaboré ici. Calculer les deux résultats possibles et choisir l'un des deux en fonction de la première lettre de l'entrée. Mettra à jour si je trouve quelque chose de mieux.

Explication:

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 octets

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

Cela utilise le fait que 'B' ^ 'F' == 4et 'o' ^ 't' == 27.

Essayez-le en ligne dans l' interpréteur CJam .

Javascript (ES6), 50 47 caractères

Solution très simple: (Merci à undergroundmonorail pour avoir supprimé un octet!)

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

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

Pour une fois, ma réponse n'était que de 2x la longueur de la meilleure réponse Pyth!

Haskell, 69 octets

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

Assez simple.

Pyth - 31 octets

Assez simple, utilise l'indexation zip et modulaire pour obtenir le commutateur. Le calcul réel est vraiment facile.

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

Suite de tests .

Julia, 63 octets

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

Non 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 octets

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

Exemples:

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

Powershell, 111

La verbosité de PowerShell et les parenthèses requises sont à nouveau sa chute. Golf Même le .Substring(0,2)à[0..1]-join'' arrêts seulement 2 octets chacun, et un autre couple d' octets enregistrés avec un implicite Elsegrâce à laexit commande. Tant pis. Bon recyclage sur les cordes de séparation.

Code:

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

Usage:

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

Explication

$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 octets (37 + 1 pour -p)

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

Utilisation : enregistrez sous 54768.pl et exécutez comme:

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

ou de manière interactive:

perl -p 54768.pl
Bo199
# Ft100

FSharp - 153 143 octets

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

Mises à jour

1. Suppression de quelques octets en passant de la correspondance de modèle à une simple if ... then ...

Rubis, 82 octets

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

Appelé avec un argument pour faire tomber quelques octets.
Premier post, suggestions bienvenues. :)

EDIT: Je me suis débarrassé de 12 octets en modifiant mes calculs. Étant donné que les nombres Bo sont impairs, ils auront toujours une décimale après la division par 2, ce qui signifie que je peux simplement tronquer et ajouter 1 au lieu d'utiliser ceilpour arrondir.

PHP, 85 79 75 octets

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

Utilisation:
appelez le script avec un argument:php -d error_reporting=0 script.php Bo5

Pas ridiculement court comme les autres, mais c'est mon premier post:

JS, 143 octets

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

Version non golfée:

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 octets

Nouveau sur le golf de code, R et ce site. Alors voilà:

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 octets

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