Bugün hepsini bir Super Smash Bros. turnuvasında geçirdim ve setleri tanımlarken kullandığımız bazı terminolojileri düşünmeye başladım. Bunlar turnuvalarda oynadığım üç çeşit set:

• En İyiler (Bo3)
  • Üç oyun oynanır. Setin galibi, oyunların çoğunu kazanan oyuncudur.
  • Tek bir oyuncu setin iki maçını kazanırsa, hemen kazanan olarak ilan edilir, çünkü rakibin yetişmesi imkansızdır.
• 5'in en iyisi (Bo5)
  • Beş oyun oynanır. Setin galibi, oyunların çoğunu kazanan oyuncudur.
  • Tek bir oyuncu setin üç oyununu kazanırsa, hemen kazanan olarak ilan edilir, çünkü rakibin yetişmesi imkansızdır.
• İlk 5'e (Ft5)
  • Tamam, daha önce anlattığım kelimelerle biraz kandırdım. Bu tür bir set parçası değil bir turnuvanın , ancak genellikle mekanda gerçekleştiğini görürsünüz. Bu, geleneksel olarak başka bir oyuncuya meydan okuduysanız ve para çevrimiçi ise oynayacağınız settir.
  • Göründüğü kadar basit: Oyuncular, biri beş kazanana kadar tekrar tekrar oyun oynuyor ve bu oyuncu kazanan ilan ediliyor.

Açıkçası, Bo3 ve Bo5 çok benzerdir, sadece oynanan oyunların sayısında farklılık gösterir. Ama Ft5 açıkça farklı ... değil mi? Pek sayılmaz! Bir Bo3 seti nasıl düşerse inin, kazanan tam olarak iki oyun kazanmış olacak. Bir Bo5 setinin galibi tam olarak 3 oyun kazanmış olacak. Neden onlara Ft2 veya Ft3 demiyorsunuz? Tersine uygulanan aynı mantık, Ft5'in Bo9 ile tam olarak aynı olduğunu gösterecektir.

Bu zorluğun amacı belirli bir formatın eşanlamlılığını belirlemektir.

Şartname

Programınız veya işleviniz girişten tek bir dize alacaktır . İlk iki karakter Boveya Ftolur ve ardından bir sayı gelir. Program / fonksiyon çıktı alacak karşısında öneki ve giriş ve çıkış dizeleri aynı anlama böyle bir sayı ile bir dize.

İle başlayan herhangi bir dize Botek bir sayı ile biter.

Giriş dizesindeki sayının hiçbir zaman 200'den büyük olmayacağını varsayabilirsiniz. Ayrıca, doğru çıktının 200'den büyük bir sayı içereceği hiçbir zaman girdi almayacağınızı da varsayabilirsiniz. Aynı şekilde, girdi ve doğru çıktı numaraları her zaman 0'dan büyük olmak.

Örnekler

Bo3 -> Ft2
Ft2 -> Bo3

Bo5 -> Ft3
Ft3 -> Bo5

Bo9 -> Ft5
Ft5 -> Bo9

Bo51 -> Ft26
Ft26 -> Bo51

Bo199 -> Ft100
Ft100 -> Bo199

Pyth, 23 bayt

@,/hKsttz2tyKCp-"BoFt"z

Test odası.

Nasıl çalışır:

İlk olarak, bulmak Boveya Ftprogramından girdi karakterleri filtreleyen, BoFtile, -"BoFt"z.

Bu ile hemen yazdırılır p. pgirdisini de döndürür. Bu dize tabanı 256. dize olsaydı sonuç 17007 olduğu gibi bayt yorumlamak bir sayıya dönüştürülür Bove dize olsaydı 18.036 olduğunuFt .

Daha sonra, her iki muhtemel sonuçları hesaplar, num * 2 - 1ve(num + 1)/2 bir 2 giriş listesinde bu koyar. Daha sonra, program 17007 veya 18036 numaralı numarayla bu listeye endeksler. Pyth'in modüler indekslenmesi nedeniyle, bu uygun sayıyı seçer. Sonuç daha sonra otomatik olarak yazdırılır.

Yana pSonuna eklenmiş yeni satır ile baskılar, ancak örtük baskı sondaki yeni satır var, iki ardışık baskılar tam olarak doğru biçimde çıkıyor.

Python 2, 59

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

Fonksiyonlara izin verilen kısa zorluklarda, lambda değişkenlerin atanamaması nedeniyle kodun tekrarlanması gerektiğinde bile genellikle .

Dize karşılaştırması ile hangi durumda olduğumuzu kontrol ediyoruz s>'C'. Sonra, liste dilimleme hilesi ile doğru öneki alın 'FBto'[s>'C'::2].

Rakamı elde etmek için, ikincinin ötesindeki karakterleri değerlendirmeli ve ya *2+1ya /2-1da ona yapmalıyız . Bunu, bu iki ifadeden herhangi birini dize olarak takarak, yine liste dilimleme, sonucu değerlendirme ve bu sayıyı bir dizeye dönüştürerek seçerek yaparız.

Düzenleme: Bir char kaydetti (59):

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

Sorma bile ...

C ++ 11 Şablon Meta Programlama, 305 bayt

Düzenleme: Başka bir 100 bayt kapalı

Dil seçimim için herhangi bir engel var mı? : 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'>{};

Örnekler:

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

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

Çevrimiçi deneyin

Burada çok ayrıntılı bir şey yok. Olası iki sonucun hesaplanması ve girişteki ilk harfe göre ikisinden birinin seçilmesi. Daha iyi bir şey bulursam güncellenir.

Açıklama:

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 bayt

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

Bu markaları Aslında bunun kullanmak 'B' ^ 'F' == 4ve 'o' ^ 't' == 27.

CJam yorumlayıcısında çevrimiçi deneyin .

Javascript (ES6), 50 47 karakter

Çok basit bir çözüm: (Bir baytı çıkarmak için yeraltı monoray sayesinde!)

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

Bir keresinde cevabım en iyi Pyth cevabının uzunluğundan sadece 2 kat daha fazlaydı!

Haskell, 69 bayt

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

Oldukça basit.

Pyth - 31 bayt

Oldukça basit, anahtarı almak için zip ve modüler indeksleme kullanır. Gerçek hesaplama gerçekten kolaydır.

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

Test takımı .

Julia, 63 bayt

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 bayt

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

Örnekler:

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

Powershell, 111

PowerShell ve gerekli parantezlerin kelime dağarcığı yine çöküşüdür. Hatta golf .Substring(0,2)için [0..1]-join''sadece 2 her bayt, ve başka bir çift zımni ile kaydedilmiş bayt kaydeder Elsesayesinde exitkomuta. Oh iyi. Dizeleri ayırmak için iyi tazeleme.

Kod:

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

Kullanımı:

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

açıklama

$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 bayt (37 + 1 için -p)

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

Kullanımı : 54768.pl kaydedin ve şu şekilde çalıştırın:

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

veya etkileşimli olarak:

perl -p 54768.pl
Bo199
# Ft100

Fsharp - 153 143 bayt

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

Güncellemeler

1. Desen eşleşmesinden basit bir düzeye geçerek birkaç bayt kapatıldı if ... then ...

Ruby, 82 Bayt

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

Birkaç bayt çalmak için bir argüman ile çağrıldı.
İlk gönderi, önerilerinizi bekliyoruz. :)

EDIT: benim matematik değiştirerek 12 bayt kurtuldu. Bo sayıları tuhaf olduğu için, 2'ye böldükten sonra her zaman ondalık olurlar, yani ceilyuvarlamak için kullanmak yerine kısaltabilir ve 1 ekleyebilirim .

PHP, 85 79 75 Bayt

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

Kullanım:
Komut dosyasını bir argümanla arayın:php -d error_reporting=0 script.php Bo5

Diğerleri gibi gülünç kısa değil, ama bu benim ilk yazım:

JS, 143 bayt

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 Sürümü:

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 bayt

Kod golf, R ve bu sitede yeni. İşte böyle:

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 bayt

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