Ich habe heute den ganzen Tag bei einem Super Smash Bros.-Turnier verbracht und über die Terminologie nachgedacht, die wir bei der Beschreibung von Sets verwenden. Dies sind die drei Arten von Sätzen, die ich bei Turnieren gesehen habe:

• Best of 3 (Bo3)
  • Es werden drei Spiele gespielt. Der Gewinner des Sets ist der Spieler, der die meisten Spiele gewonnen hat.
  • Wenn ein einzelner Spieler zwei Spiele des Satzes gewinnt, wird er sofort zum Gewinner erklärt, da der Gegner nicht aufholen kann.
• Best of 5 (Bo5)
  • Es werden fünf Spiele gespielt. Der Gewinner des Sets ist der Spieler, der die meisten Spiele gewonnen hat.
  • Wenn ein einzelner Spieler drei Spiele des Satzes gewinnt, wird er sofort zum Gewinner erklärt, da der Gegner nicht aufholen kann.
• Zuerst bis 5 (Ft5)
  • Okay, ich habe ein bisschen mit meinem Wortlaut vorhin geschummelt. Diese Art von Set ist nicht Teil eines Turniers, aber Sie werden oft sehen, wie sie am Veranstaltungsort stattfinden. Dies ist traditionell die Art von Set, die Sie spielen, wenn Sie einen anderen Spieler herausgefordert haben und Geld auf dem Spiel steht.
  • Es ist so einfach wie es sich anhört: Die Spieler spielen wiederholt Spiele, bis einer von ihnen fünf gewonnen hat und dieser Spieler zum Gewinner erklärt wird.

Offensichtlich sind Bo3 und Bo5 sehr ähnlich und unterscheiden sich nur in der Anzahl der gespielten Spiele. Aber Ft5 ist eindeutig anders ... oder? Nicht wirklich! Egal wie ein Bo3-Satz ausfällt, der Gewinner hat genau zwei Spiele gewonnen. Der Gewinner eines Bo5-Sets hat genau 3 Spiele gewonnen. Warum nennst du sie nicht Ft2 oder Ft3? Dieselbe Logik, die umgekehrt angewendet wird, zeigt, dass Ft5 genauso ist wie Bo9.

Ziel dieser Herausforderung ist es, das Synonym eines festgelegten Formats zu bestimmen.

Spezifikation

Ihr Programm oder Ihre Funktion nimmt eine einzelne Zeichenfolge von der Eingabe . Die ersten beiden Zeichen sind Booder Ft, gefolgt von einer Zahl. Das Programm / Funktion Ausgang ein String mit dem anderen Präfix und einer Zahl , so dass die Eingangs- und Ausgangs Strings das gleiche bedeuten.

Jede Zeichenfolge, die mit beginnt Bo, endet mit einer ungeraden Zahl.

Sie können davon ausgehen, dass die Zahl in der Eingabezeichenfolge niemals größer als 200 sein wird. Sie können auch davon ausgehen, dass Sie niemals eine Eingabe erhalten, für die die richtige Ausgabe eine Zahl größer als 200 enthalten würde. Ebenso werden die Eingabe- und die richtige Ausgabenummer immer verwendet größer als 0 sein.

Beispiele

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

Testsuite.

Wie es funktioniert:

Um zuerst das Booder zu finden Ft, filtert das Programm die Zeichen in der Eingabe aus BoFt, mit -"BoFt"z.

Dies wird sofort mit gedruckt p. pgibt auch seine Eingabe zurück. Diese Zeichenfolge wird in eine Zahl umgewandelt, die die Bytes als Basis 256 interpretiert. Das Ergebnis ist 17007, wenn die Zeichenfolge war Bo, und 18036, wenn die Zeichenfolge war Ft.

Als nächstes berechnet es die beiden möglichen Ergebnisse, num * 2 - 1und (num + 1)/2und legt diese in einem 2 Eintrag Liste. Anschließend indiziert das Programm diese Liste mit der obigen Nummer 17007 oder 18036. Aufgrund der modularen Indizierung von Pyth wird die richtige Nummer ausgewählt. Das Ergebnis wird dann automatisch ausgedruckt.

Da pAusdrucke ohne nachgestellte Zeilenvorschubzeile, der implizite Ausdruck jedoch die nachgestellte Zeilenvorschubzeile enthält, werden die beiden aufeinanderfolgenden Ausdrucke im genau richtigen Format ausgegeben.

Python 2, 59

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

Bei kurzen Herausforderungen, bei denen Funktionen zulässig sind, lambdagewinnt in der Regel die Kürze , auch wenn sich der Code aufgrund der Unfähigkeit, Variablen zuzuweisen, wiederholen muss.

Wir überprüfen, in welchem ​​Fall wir uns befinden, und vergleichen die Zeichenfolgen s>'C'. Holen Sie sich dann das richtige Präfix mit dem List-Slicing-Trick 'FBto'[s>'C'::2].

Um die Nummer zu erhalten, müssen wir die Zeichen über die Sekunde hinaus auswerten und entweder tun *2+1oder tun /2-1. Wir tun dies, indem wir einen dieser beiden Ausdrücke als Zeichenfolgen verwenden, die wiederum durch Aufteilen von Listen ausgewählt werden, das Ergebnis auswerten und diese Zahl in eine Zeichenfolge umwandeln.

Bearbeiten: Ein Zeichen gespeichert (59):

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

Frag nicht mal ...

C ++ 11 Template Metaprogramming, 305 Bytes

Edit: Noch 100 Bytes übrig

Bekomme ich ein Handicap für meine Sprachwahl? : 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'>{};

Beispiele:

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

Probieren Sie es online aus

Hier ist nichts sehr Aufwendiges. Berechnen der beiden möglichen Ergebnisse und Auswählen eines der beiden anhand des ersten Buchstabens in der Eingabe. Wird aktualisiert, wenn mir etwas Besseres einfällt.

Erläuterung:

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

Dies macht sich die Tatsache zunutze, dass 'B' ^ 'F' == 4und 'o' ^ 't' == 27.

Probieren Sie es online im CJam-Interpreter aus .

Javascript (ES6), 50 47 Zeichen

Sehr einfache Lösung: (Dank undergroundmonorail zum Entfernen eines Bytes!)

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

Ausnahmsweise war meine Antwort nur ~ 2x so lang wie die beste Pyth-Antwort!

Haskell, 69 Bytes

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

Ziemlich unkompliziert.

Pyth - 31 Bytes

Ziemlich einfach, verwendet Reißverschluss und modulare Indizierung, um den Schalter zu erhalten. Die eigentliche Berechnung ist denkbar einfach.

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

Testsuite .

Julia, 63 Bytes

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

Beispiele:

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

Powershell, 111

Die Wortgewandtheit von PowerShell und die erforderlichen Klammern sind erneut der Nachteil. Auch Golf spielen die .Substring(0,2)auf [0..1]-join''nur speichert 2 Bytes jedem, und ein anderes Paar Bytes mit einer stillschweigenden gespeichert Elsedank des exitBefehls. Naja. Gute Auffrischung beim Trennen von Saiten.

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)

Verwendung:

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

Erläuterung

$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 für -p)

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

Verwendung : Als 54768.pl speichern und ausführen als:

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

oder interaktiv:

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

Aktualisierung

1. Hat ein paar Bytes verloren, indem vom Mustervergleich zum einfachen gewechselt wurde if ... then ...

Rubin, 82 Bytes

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

Wird mit einem Argument aufgerufen, um ein paar Bytes abzuschlagen.
Erster Beitrag, Anregungen willkommen. :)

BEARBEITEN: 12 Bytes durch Ändern meiner Mathematik losgeworden. Da die Bo-Zahlen ungerade sind, haben sie nach der Division durch 2 immer eine Dezimalstelle, was bedeutet, dass ich nur 1 abschneiden und addieren kann, anstatt aufzurunden ceil.

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

Verwendung:
Rufen Sie das Skript mit einem Argument auf:php -d error_reporting=0 script.php Bo5

Nicht so lächerlich kurz wie die anderen, aber das ist mein erster Beitrag:

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

Ungolfed Version:

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

Neu in Code-Golf, R und dieser Website. Also los geht's:

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