Você receberá uma String que contém apenas letras do alfabeto inglês, minúsculas e maiúsculas (ASCII 65-90 e 97-122). Sua tarefa é produzir a versão Fizz-Buzzified da String.

Como Fizz-Buzzify uma String?

• Cada letra que tem um índice par no alfabeto inglês (o alfabeto deve ser indexado 1:) a->1,b->2,...,z->26será transformada em fizzminúsculas e FIZZmaiúsculas ( f -> fizz, F -> FIZZ).

• Cada letra que tenha um índice ímpar no alfabeto inglês será transformada em buzzminúsculas e em BUZZmaiúsculas ( e -> buzz, E -> BUZZ).

• Vamos dar um exemplo, para ilustrar o algoritmo, usando a string CodeGolf(espaços adicionados para maior clareza):

  "C o d e G o l f" ->  "BUZZ buzz fizz buzz BUZZ buzz fizz fizz"
   ^ ^ ^ ^ ^ ^ ^ ^
   1 1 0 1 1 1 0 0       (1 is odd index, 0 is even index)
  

• Se for mais conveniente para o seu idioma, você também pode deixar espaços únicos entre os grupos ( fizz, buzz, FIZZ, BUZZ). Portanto, um resultado como fizzBUZZbuzzbuzztambém pode ser retornado como fizz BUZZ buzz buzz. Outros separadores não são permitidos.

Casos de teste:

Entrada -> Saída 

"ovo" -> "buzzbuzzbuzz"
"CodeGolf" -> "BUZZbuzzfizzbuzzBUZZbuzzfizzfizz"
"Redefinir" -> "FIZZbuzzbuzzbuzzfizz"
"Átomo" -> "BUZZFIZZBUZZBUZZ"
"yOuArEgReAt" -> "buzzBUZZbuzzBUZZfizzBUZZbuzzFIZZbuzzBUZZfizz"

• Qualquer método padrão para E / S pode ser usado.

• Aplicam-se lacunas padrão .

• Você só pode receber informações no tipo String nativo do seu idioma. O mesmo se aplica à saída.

• Você pode assumir que a entrada não estará vazia.

• O código mais curto em bytes em todos os idiomas vence. Boa Sorte e Fizz-Buzz!

Carvão , 26 24 bytes

ＦθＦ⎇﹪℅ι²buzz¦fizz⎇№αι↥κκ

Experimente online! Originalmente inspirado por @CarlosAlejo. Editar: economizou 2 bytes repetindo as letras de fizz / buzz em vez de atribuir a um temporário. Explicação:

Ｆθ          Loop over the input (i = loop variable)
  Ｆ         Choose and loop over the word (k = loop variable)
   ⎇        Ternary
    ﹪℅ι²    If i has an odd ASCII code
    buzz
    fizz
            Print (implicit)
  ⎇         Ternary
   №αι      If i is an uppercase letter
    ↥κ      Uppercase(k)
     κ      k

C #, 92 bytes

using System.Linq;a=>string.Concat(a.Select(x=>x%2<1?x<97?"FIZZ":"fizz":x<97?"BUZZ":"buzz"))

Python 3 , 73 69 bytes

4 bytes graças a ovs.

lambda s:"".join("fbFBiuIUzzZZzzZZ"[(c<"a")*2+ord(c)%2::4]for c in s)

Experimente online!

C (gcc) , 75 bytes

f(char*s){for(;*s;++s)printf(*s>90?*s%2?"buzz":"fizz":*s%2?"BUZZ":"FIZZ");}

Experimente online!

Java (OpenJDK 8) , 105 100 94 91 90 bytes

s->{for(int i:s.getBytes())System.out.print(i%2<1?i>90?"fizz":"FIZZ":i>90?"buzz":"BUZZ");}

Experimente online!

Muito jogável, muito bytes, então Java!

Muito jogado por @KevinCruijssen por 9 bytes!

JavaScript (ES6), 79 77 bytes

s=>s.replace(/./g,c=>['BUZZ','buzz','FIZZ','fizz'][parseInt(c,36)%2*2|c>'Z'])

Casos de teste

let f =

s=>s.replace(/./g,c=>['BUZZ','buzz','FIZZ','fizz'][parseInt(c,36)%2*2|c>'Z'])

console.log(f("egg"        )) // "buzzbuzzbuzz"
console.log(f("CodeGolf"   )) // "BUZZbuzzfizzbuzzBUZZbuzzfizzfizz"
console.log(f("Reset"      )) // "FIZZbuzzbuzzbuzzfizz"
console.log(f("ATOM"       )) // "BUZZFIZZBUZZBUZZ"
console.log(f("yOuArEgReAt")) // "buzzBUZZbuzzBUZZfizzBUZZbuzzFIZZbuzzBUZZfizz"

C #, 97 bytes

using System.Linq;s=>string.Concat(s.Select(c=>"fizzbuzzFIZZBUZZ".Substring(c%2*4+(c>96?0:8),2)))

Gelatina , 21 bytes

“=%“Ƈ×»ẋ13Œu;$ɓØWiЀị

Experimente online!

Pitão , 23 21 bytes

smr<d\a@c"fizzbuzz"4C

Conjunto de teste .

Plain Inglês , 820 632 610 bytes

O Sr. Xcoder sugeriu a eliminação de uma interceptação de erro desnecessária, que economizou 22 bytes.

A fizzy string is a string.
To convert a s string to a z fizzy string:
Clear the z.
Slap a r rider on the s.
Loop.
If the r's source's first is greater than the r's source's last, exit.
Put the r's source's first's target in a b byte.
If the b is not any letter, bump the r; repeat.
Put "FIZZ" in a t string.
If the b is d, put "BUZZ" in the t.
If the b is _, lowercase the t.
Append the t to the z.
Bump the r.
Repeat.
To decide if a b byte is d:
Put the b in a n number.
If the n is odd, say yes.
Say no.
To decide if a b byte is _:
Put the b in a c byte.
Lowercase the c.
If the c is the b, say yes.
Say no.

Código não destruído:

A fizzy string is a string.

To convert a string to a fizzy string:
  Clear the fizzy string.
  Slap a rider on the string.
  Loop.
    If the rider's source's first is greater than the rider's source's last, exit.
    Put the rider's source's first's target in a byte.
    If the byte is not any letter, bump the rider; repeat.
    Put "FIZZ" in another string.
    If the byte is odd, put "BUZZ" in the other string.
    If the byte is lower case, lowercase the other string.
    Append the other string to the fizzy string.
    Bump the rider.
  Repeat.

To decide if a byte is odd:
  Put the byte in a number.
  If the number is odd, say yes.
  Say no.

To decide if a byte is lower case:
  Privatize the byte.
  Lowercase the byte.
  If the byte is the original byte, say yes.
  Say no.

O IDE do inglês simples está disponível em github.com/Folds/english . O IDE é executado no Windows. Ele é compilado no código x86 de 32 bits.

Carvão , 40 36 bytes

Ｆθ¿№αι¿﹪⌕αι²FIZZ¦BUZZ¿﹪⌕βι²fizz¦buzz

Experimente online!

Explicação:

Ｆθ                                      for every char i in the input:
   ¿№αι                                    if i is found in the uppercase alphabet
       ¿﹪⌕αι²                             if i is an even uppercase char
              FIZZ¦BUZZ                    print "FIZZ" or else "BUZZ"
                       ¿﹪⌕βι²             if i is an even lowercase char
                              fizz¦buzz    print "fizz" or else "buzz"

Uma alternativa com a mesma contagem de bytes:

ＡfizzφＡbuzzχＦθ¿№αι¿﹪⌕αι²↥φ↥χ¿﹪⌕βι²φχ

Experimente online! ( Versão detalhada )

• 4 bytes salvos graças ao Neil!

> <> , 68 bytes

<vv?("^"$%2:;?(0:i
v\?\"zzif"
v \\"zzub"
v \ "ZZIF"
v  \"ZZUB"
\oooo

Experimente online ou assista ao playground de peixes !

(Mas veja a resposta de Aaron que é 13 bytes mais curta!)

Se você não está familiarizado com> <>, há um peixe que nada pelo código em 2D e as bordas se abrem. Os símbolos >, <, ^e vdefinir o sentido do peixe, /e \são espelhos que reflectem-lo, e? significa "fazer a próxima instrução se o topo coisa na pilha não é zero, caso contrário, saltar sobre a próxima instrução".

Na primeira linha, o peixe assume um caractere de input ( i); se for -1 para EOF, ele pára ( :0(?;); obtém o código de modificação mod 2 ( :2%$); e pressiona 1 ou 0 na pilha, dependendo se o código é menor ou maior que o código de "^" ( "^"(). As próximas três linhas redirecionam o peixe para a seqüência correta de efervescência / zumbido, depois a última linha o imprime (uma opara cada caractere) e envia o peixe de volta ao início.

> <> , 55 bytes

Baseado na resposta Não é uma árvore .

<v%2$)"^":;?(0:i
 \?v"ZZIF"
~v >"ZZUB"!
^>{:}" "*+ol1=?

Em vez de representar as 4 saídas possíveis no código, eu apenas represento suas versões em maiúsculas e adiciono 32 ao código de caractere para obter os equivalentes de maiúsculas e minúsculas.

Experimente online!

Código modificado para o intérprete online , que preenche seu espaço de código com células vazias:

<v%2$)"^":;?(0:i
 \?v"ZZIF"
~v >"ZZUB"     !
^>{:}" "*+o l1=?

Perl5 , 50 + 1 bytes

perl -nE'say+((FIZZ,BUZZ)x48,(fizz,buzz)x16)[unpack"C*",$_]'

Cria uma lista de 128 itens que mapeia caracteres ASCII para a palavra de código apropriada.

05AB1E , 22 bytes

v‘FIZZÒÖ‘#yÇÉèAyåil}J?

Experimente online!

Explicação

v                        # for each char y of input string
 ‘FIZZÒÖ‘#               # push the list ['FIZZ','BUZZ']
          yÇÉ            # check if y has an odd character code
             è           # use this to index into the list
              Ayåi       # if y is a member of the lowercase alphabet
                  l}     # convert to lowercase
                    J?   # unwrap from list and print

Solução alternativa de 22 bytes

ÇÉAISå·+‘FIZZÒÖ‘#Dl«èJ

PHP , 67 bytes

for(;$c=$argn[$i++];)echo[FIZZ,BUZZ,fizz,buzz][ord($c)%2+2*($c>Z)];

Experimente online!

F # , 154 153 145 bytes

salvou 1 9 bytes graças a @Mr. Xcoder

let g s=
 Seq.map(fun c->match int c with
|x when x>64&&x<91->if x%2=0 then"FIZZ"else"BUZZ"
|x->if x%2=0 then"fizz"else"buzz")s
|>String.concat""

Experimente online!

Mathematica, 134 bytes

""<>{(s=Max@ToCharacterCode@#;If[96<s<123,If[EvenQ@s,c="fizz",c="buzz"]];If[64<s<91,If[EvenQ@s,c="FIZZ",c="BUZZ"]];c)&/@Characters@#}&

Java 8, 89 bytes

s->s.chars().mapToObj(i->i%2<1?i>90?"fizz":"FIZZ":i>90?"buzz":"BUZZ").collect(joining());

Assume import static java.util.stream.Collectors.*;

q / kdb +, 48 bytes

Solução:

raze{@[($)`fizz`buzz x mod 2;(&)x<91;upper]}"i"$

Exemplos:

q)raze{@[($)`fizz`buzz x mod 2;(&)x<91;upper]}"i"$"egg"
"buzzbuzzbuzz"
q)raze{@[($)`fizz`buzz x mod 2;(&)x<91;upper]}"i"$"CodeGolf"
"BUZZbuzzfizzbuzzBUZZbuzzfizzfizz"
q)raze{@[($)`fizz`buzz x mod 2;(&)x<91;upper]}"i"$"Reset"
"FIZZbuzzbuzzbuzzfizz"
q)raze{@[($)`fizz`buzz x mod 2;(&)x<91;upper]}"i"$"ATOM"
"BUZZFIZZBUZZBUZZ"
q)raze{@[($)`fizz`buzz x mod 2;(&)x<91;upper]}"i"$"yOuArEgReAt"
"buzzBUZZbuzzBUZZfizzBUZZbuzzFIZZbuzzBUZZfizz"

Explicação:

Bastante simples, pegue a string de entrada, converta-a em valores ASCII, crie uma lista de 1 ou 0 dependendo se é ímpar ou par (dica A = 65 = ímpar) e use essa lista para indexar em uma lista de fizze buzz. Faça a conversão para uma string e, nos casos em que a entrada for <91 (menor que um Z), aplicamos a upperfunção para obter um FIZZou umBUZZ .

q é interpretado da direita para a esquerda:

raze{@[string `fizz`buzz x mod 2;where x < 91;upper]}"i"$ / ungolfed version
                                                     "i"$ / cast input to ascii values
    {                                               }     / anonymous lambda
     @[                         ;            ;     ]      / apply 
                                              upper       / upper-case
                                 where x < 91             / indices where input is less than 91 (ie uppercase)
                         x mod 2                          / returns 0 if even and 1 if odd
              `fizz`buzz                                  / 2 item list, which we are indexing into
       string                                             / cast symbols to strings `buzz -> "buzz"
raze                                                      / raze (merge) list into a single string

Rubi , 61 + 1 = 62 bytes

Usa a -pbandeira.

gsub(/./){k=$&.ord%2*4;$&<?_?"FIZZBUZZ"[k,4]:"fizzbuzz"[k,4]}

Experimente online!

Swift 4 , 144 135 bytes

func f(s:String){print(s.map{let d=Int(UnicodeScalar("\($0)")!.value);return d%2<1 ?d>90 ?"fizz":"FIZZ":d>90 ?"buzz":"BUZZ"}.joined())}

Sem golfe:

func f(s:String){
    print(
        s.map{
            let d=Int(UnicodeScalar("\($0)")!.value)
            return d%2 < 1 ? d > 90 ? "fizz" : "FIZZ" : d > 90 ? "buzz" : "BUZZ"
        }.joined()
    )
}

O que estou fazendo é fazer um loop sobre cada caractere na string. Eu converto cada um para o seu valor ASCII, depois verifico se é par ou ímpar e, em seguida, verifico se está em maiúsculas ou minúsculas e produzo o valor correspondente do loop. Em seguida, uno todos os elementos da matriz resultante em uma única sequência e a imprimo.

Esta solução usa o Swift 4, portanto ainda não há como testá-lo online facilmente.

Obrigado a @ Mr.Xcoder por me salvar 9 bytes!

R, 150 123 108 bytes

i=ifelse
cat(i(sapply(el(strsplit(scan(,''),'')),utf8ToInt)>91,i(x%%2,'buzz','fizz'),i(x%%2,'BUZZ','FIZZ')))

Tem que ser mais curto usando ASCII? Foi mais curto. Veja o histórico de edições para obter respostas antigas, usadasletters .

Verifica cada letra em busca de (1) se é maiúsculo ou não ( >91) e se é um fizzou um buzz.

Java

str.chars().forEach(ch ->{
    if(ch >= 97)
        strb.append(ch % 2 == 0 ? "fizz" : "buzz");
    else
        strb.append(ch % 2 == 0 ? "FIZZ" : "BUZZ");
});