Ho passato tutto il giorno oggi ad un torneo di Super Smash Bros. e ho iniziato a pensare ad alcuni termini che usiamo per descrivere i set. Questi sono i tre tipi di set che vedo giocati nei tornei:

• Il meglio di 3 (Bo3)
  • Vengono giocate tre partite. Il vincitore del set è il giocatore che ha vinto la maggior parte delle partite.
  • Se un singolo giocatore vince due partite del set, viene immediatamente dichiarato vincitore, poiché sarebbe impossibile per l'avversario recuperare.
• Il meglio di 5 (Bo5)
  • Vengono giocate cinque partite. Il vincitore del set è il giocatore che ha vinto la maggior parte delle partite.
  • Se un singolo giocatore vince tre partite del set, viene immediatamente dichiarato vincitore, poiché sarebbe impossibile per l'avversario recuperare.
• Primi a 5 (Ft5)
  • Ok, ho barato un po 'con le mie parole prima. Questo tipo di set non fa parte di un torneo, ma spesso li vedrai accadere sul posto. Questo è tradizionalmente il tipo di set che giocherai se hai sfidato un altro giocatore e il denaro è sulla linea.
  • È semplice come sembra: i giocatori giocano ripetutamente fino a quando uno di loro non ne ha vinti cinque e quel giocatore viene dichiarato vincitore.

Ovviamente, Bo3 e Bo5 sono molto simili, differendo solo per il numero di partite giocate. Ma Ft5 è chiaramente diverso ... giusto? Non proprio! Indipendentemente dal modo in cui un set Bo3 si abbassa, il vincitore avrà vinto esattamente due partite. Il vincitore di un set Bo5 avrà vinto esattamente 3 partite. Perché non chiamarli Ft2 o Ft3? La stessa logica, applicata al contrario, mostrerà che Ft5 è esattamente lo stesso di Bo9.

L'obiettivo di questa sfida è determinare il sinonimo di un formato prestabilito.

specificazione

Il tuo programma o funzione prenderà una singola stringa dall'input . I primi due caratteri saranno Boo Fte saranno seguiti da un numero. La volontà programma / funzione uscita una stringa con il prefisso opposto e un numero tale che le stringhe di input e output significano la stessa cosa.

Qualsiasi stringa che inizia con Botermina con un numero dispari.

Si può presumere che il numero nella stringa di input non sarà mai maggiore di 200. Si può anche supporre che non si riceverà mai input per il quale l'output corretto includerebbe un numero maggiore di 200. Allo stesso modo, i numeri di input e output corretti saranno sempre essere maggiore di 0.

Esempi

Bo3 -> Ft2
Ft2 -> Bo3

Bo5 -> Ft3
Ft3 -> Bo5

Bo9 -> Ft5
Ft5 -> Bo9

Bo51 -> Ft26
Ft26 -> Bo51

Bo199 -> Ft100
Ft100 -> Bo199

Pyth, 23 byte

@,/hKsttz2tyKCp-"BoFt"z

Suite di test.

Come funziona:

Innanzitutto, per trovare Boo Ft, il programma filtra i caratteri nell'input da BoFt, con -"BoFt"z.

Questo viene immediatamente stampato con p. prestituisce anche il suo input. Quella stringa viene convertita in un numero che interpreta i byte come base 256. Il risultato è 17007 se la stringa era Bo, e 18036 se la stringa era Ft.

Successivamente, calcola entrambi i possibili risultati, num * 2 - 1e (num + 1)/2e mette questo in una lista 2 di entrata. Quindi, il programma indicizza tale elenco con il numero sopra, 17007 o 18036. A causa dell'indicizzazione modulare di Pyth, questo seleziona il numero corretto. Il risultato viene quindi stampato automaticamente.

Poiché le pstampe senza newline finale, ma la stampa implicita ha la nuova riga finale, le due stampe successive vengono visualizzate esattamente nel formato giusto.

Python 2, 59

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

In brevi sfide in cui sono consentite funzioni, la brevità di lambdasolito vince anche quando il codice deve ripetersi a causa dell'incapacità di assegnare variabili.

Controlliamo in quale caso ci troviamo con il confronto delle stringhe s>'C'. Quindi, ottieni il prefisso giusto con il trucco per tagliare la lista 'FBto'[s>'C'::2].

Per ottenere il numero, dobbiamo valutare i caratteri oltre il secondo e fare uno *2+1o entrambi /2-1. Lo facciamo puntando su una di queste due espressioni come stringhe, ancora una volta scelte dall'elenco di sezioni, valutando il risultato e trasformando quel numero in una stringa.

Modifica: Salvato un carattere (59):

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

Non chiedere nemmeno ...

Metaprogrammazione di modelli C ++ 11, 305 byte

Modifica: altri 100 byte di sconto

Ricevo qualche tipo di handicap per la mia scelta della lingua? : 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'>{};

Esempi:

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

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

Provalo online

Niente di molto elaborato qui. Calcolo dei due risultati possibili e selezione di uno dei due in base alla prima lettera nell'input. Aggiornerò se mi viene in mente qualcosa di meglio.

Spiegazione:

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 byte

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

Questo si avvale del fatto che 'B' ^ 'F' == 4 e 'o' ^ 't' == 27.

Provalo online nell'interprete CJam .

Javascript (ES6), 50 47 caratteri

Soluzione molto semplice: (Grazie a undergroundmonorail per la rimozione di un 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)
}

Per una volta la mia risposta era solo ~ 2x la lunghezza della migliore risposta Pyth!

Haskell, 69 byte

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

Ragionevolmente semplice.

Pyth - 31 byte

Abbastanza semplice, utilizza zip e indicizzazione modulare per ottenere lo switch. Il calcolo effettivo è davvero semplice.

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

Suite di test .

Julia, 63 byte

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 byte

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

Esempi:

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

Powershell, 111

La parolaccia di PowerShell e le parentesi richieste sono di nuovo la sua rovina. Anche il golf del .Substring(0,2)to [0..1]-join''salva solo 2 byte ciascuno, e un altro paio di byte salvati con un implicito Elsegrazie alexit comando. Oh bene. Buon aggiornamento sulle stringhe di separazione.

Codice:

$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

Spiegazione

$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 byte (37 + 1 per -p)

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

Utilizzo : salva come 54768.pl ed esegui come:

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

o interattivamente:

perl -p 54768.pl
Bo199
# Ft100

FSharp - 153 143 byte

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

aggiornamenti

1. Eliminato alcuni byte passando dal pattern matching a un semplice if ... then ...

Rubino, 82 byte

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

Chiamato con un argomento per eliminare alcuni byte.
Primo post, suggerimenti benvenuti. :)

EDIT: mi sono sbarazzato di 12 byte modificando la mia matematica. Poiché i numeri Bo sono dispari, dopo la divisione per 2 avranno sempre un decimale, il che significa che posso semplicemente troncare e aggiungere 1 invece di utilizzare ceilper arrotondare.

PHP, 85 79 75 byte

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

Utilizzo:
chiama lo script con un argomento:php -d error_reporting=0 script.php Bo5

Non ridicolmente breve come gli altri, ma questo è il mio primo post:

JS, 143 byte

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

Versione 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 byte

Nuovo al code-golf, R e questo sito. Quindi ecco qui:

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 byte

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