Se le dará una cadena que solo contiene letras del alfabeto inglés, tanto en minúsculas como en mayúsculas (ASCII 65-90 y 97-122). Su tarea es generar la versión Fizz-Buzzified de String.

¿Cómo Fizz-Buzzify una cadena?

• Cada letra que tenga un índice par en el alfabeto inglés (el alfabeto debe estar indexado en 1 a->1,b->2,...,z->26) se convertirá en fizzminúsculas y FIZZen mayúsculas ( f -> fizz, F -> FIZZ).

• Cada letra que tenga un índice impar en el alfabeto inglés se convertirá buzzsi está en minúscula y BUZZsi está en mayúscula ( e -> buzz, E -> BUZZ).

• Veamos un ejemplo, para ilustrar el algoritmo, usando la cadena CodeGolf(espacios añadidos para mayor claridad):

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

• Si es más conveniente para su idioma, también puede dejar espacios individuales entre los grupos ( fizz, buzz, FIZZ, BUZZ). Por lo tanto, un resultado como fizzBUZZbuzzbuzztambién se puede devolver como fizz BUZZ buzz buzz. No se permiten otros separadores.

Casos de prueba:

Entrada -> Salida 

"huevo" -> "buzzbuzzbuzz"
"CodeGolf" -> "BUZZbuzzfizzbuzzBUZZbuzzfizzfizz"
"Restablecer" -> "FIZZbuzzbuzzbuzzfizz"
"ATOM" -> "BUZZFIZZBUZZBUZZ"
"yOuArEgReAt" -> "buzzBUZZbuzzBUZZfizzBUZZbuzzFIZZbuzzBUZZfizz"

• Se puede usar cualquier método estándar para E / S.

• Se aplican las lagunas predeterminadas .

• Solo puede ingresar datos en el tipo de cadena nativo de su idioma. Lo mismo se aplica para la salida.

• Puede suponer que la entrada no estará vacía.

• El código más corto en bytes en cada idioma gana. Buena suerte y Fizz-Buzz!

Carbón , 26 24 bytes

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

Pruébalo en línea! Originalmente inspirado por @CarlosAlejo. Editar: guardado 2 bytes al recorrer las letras de fizz / buzz en lugar de asignar a un temporal. Explicación:

Ｆθ          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 gracias a los ovs.

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

Pruébalo en línea!

C (gcc) , 75 bytes

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

Pruébalo en línea!

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

Pruébalo en línea!

Mucho golfable, muy bytes, ¡así que Java!

Muy jugado 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 prueba

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

Jalea , 21 bytes

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

Pruébalo en línea!

Pyth , 23 21 bytes

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

Banco de pruebas .

La llanura Inglés , 820 632 610 bytes

El Sr. Xcoder sugirió eliminar una trampa de error innecesaria, que ahorró 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 sin golf:

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.

El IDE en inglés simple está disponible en github.com/Folds/english . El IDE se ejecuta en Windows. Se compila en código x86 de 32 bits.

Carbón , 40 36 bytes

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

Pruébalo en línea!

Explicación:

Ｆθ                                      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"

Una alternativa con el mismo número de bytes:

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

Pruébalo en línea! ( Versión detallada )

• ¡4 bytes guardados gracias a Neil!

> <> , 68 bytes

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

¡Pruébelo en línea o mírelo en el área de juegos para peces !

(¡Pero mira la respuesta de Aaron, que es 13 bytes más corta!)

Si no está familiarizado con> <>, hay un pez que nada a través del código en 2D y los bordes se envuelven. Los símbolos >, <, ^y vestablecer la dirección de los peces, /y \son espejos que reflejan la misma, y ?significa "hacer la siguiente instrucción si la cosa superior de la pila no es cero, de lo contrario saltar por encima de la siguiente instrucción".

En la primera línea, el pez toma un carácter de input ( i); si es -1 para EOF, se detiene ( :0(?;); obtiene el mod charcode 2 ( :2%$); y empuja un 1 o 0 en la pila dependiendo de si el código de char es menor o mayor que el código de char de "^" ( "^"(). Las siguientes tres líneas redirigen al pez a la cadena derecha de fizz / buzz, luego la última línea lo imprime (una opara cada personaje) y envía el pez de regreso al inicio.

> <> , 55 bytes

Basado en la respuesta de Not a tree .

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

En lugar de representar los 4 resultados posibles en el código, solo represento sus versiones en mayúsculas y agrego 32 al código de caracteres para obtener los equivalentes en minúsculas.

Pruébalo en línea!

Código modificado para el intérprete en línea , que rellena su espacio de código con celdas vacías:

<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*",$_]'

Crea una lista de 128 elementos que asigna caracteres ASCII a la palabra de código adecuada.

05AB1E , 22 bytes

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

Pruébalo en línea!

Explicación

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

Solución 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)];

Pruébalo en línea!

F # , 154 153 145 bytes

ahorrado 1 9 bytes gracias 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""

Pruébalo en línea!

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

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

q / kdb +, 48 bytes

Solución:

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

Ejemplos:

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"

Explicación:

Bastante sencillo, tome la cadena de entrada, convierta en valores ASCII, cree una lista de 1 o 0 dependiendo de si es impar o par (pista A = 65 = impar), luego use esta lista para indexar en una lista de fizzy buzz. Convierta esto en una cadena, y luego para los casos en que la entrada sea <91 (inferior a una Z) aplicaremos la upperfunción para obtener a FIZZo a BUZZ.

q se interpreta de derecha a izquierda:

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

Ruby , 61 + 1 = 62 bytes

Usa la -pbandera.

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

Pruébalo en línea!

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

Sin golf:

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

Lo que estoy haciendo es recorrer cada carácter en la cadena. Convierto cada uno a su valor ASCII, luego verifico si es par o impar, y luego verifico si es mayúscula o minúscula y obtengo el valor correspondiente del bucle. Luego unir todos los elementos de la matriz resultante en una sola cadena e imprimirlo.

Esta solución utiliza Swift 4, por lo que todavía no hay forma de probarlo fácilmente en línea.

¡Gracias a @ Mr.Xcoder por salvarme 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')))

Tiene que ser más corto usando ASCII? Fue más corto. Ver historial de edición de respuesta de edad, que utiliza letters.

Comprueba cada letra para (1) si es mayúscula o no ( >91) y si es a fizzo a buzz.

Java

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