Ti verrà data una stringa che contiene solo lettere dell'alfabeto inglese, sia minuscole che maiuscole (ASCII 65-90 e 97-122). Il tuo compito è produrre la versione Fizz-Buzzified della String.

Come Fizz-Buzzify una stringa?

• Ogni lettera che ha un indice pari nell'alfabeto inglese (l'alfabeto deve essere 1-indicizzato:) a->1,b->2,...,z->26verrà trasformata fizzse è minuscola e FIZZse è maiuscola ( f -> fizz, F -> FIZZ).

• Ogni lettera che ha un indice dispari nell'alfabeto inglese verrà trasformata buzzse è minuscola e BUZZse è maiuscola ( e -> buzz, E -> BUZZ).

• Facciamo un esempio, per illustrare l'algoritmo, usando la stringa CodeGolf(spazi aggiunti per maggiore chiarezza):

  "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 è più conveniente per la tua lingua, puoi anche lasciare spazi singoli tra i gruppi ( fizz, buzz, FIZZ, BUZZ). Quindi, un risultato simile fizzBUZZbuzzbuzzpuò anche essere restituito come fizz BUZZ buzz buzz. Altri separatori non sono ammessi.

Casi test:

Ingresso -> Uscita 

"uovo" -> "buzzbuzzbuzz"
"CodeGolf" -> "BUZZbuzzfizzbuzzBUZZbuzzfizzfizz"
"Ripristina" -> "FIZZbuzzbuzzbuzzfizz"
"ATOM" -> "BUZZFIZZBUZZBUZZ"
"yOuArEgReAt" -> "buzzBUZZbuzzBUZZfizzBUZZbuzzFIZZbuzzBUZZfizz"

• È possibile utilizzare qualsiasi metodo standard per l'I / O.

• Si applicano le lacune predefinite .

• Ti è consentito solo inserire input nel tipo di stringa nativo della tua lingua. Lo stesso vale per l'output.

• Si può presumere che l'input non sarà vuoto.

• Vince il codice più breve in byte in ogni lingua. Buona fortuna e Fizz-Buzz!

Carbone , 26 24 byte

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

Provalo online! Originariamente ispirato a @CarlosAlejo. Modifica: salvato 2 byte ripetendo ciclicamente le lettere di fizz / buzz invece di assegnarle a un temporaneo. Spiegazione:

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

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

Python 3 , 73 69 byte

4 byte grazie agli ovs.

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

Provalo online!

C (gcc) , 75 byte

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

Provalo online!

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

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

Provalo online!

Molto giocabile, molto byte, quindi Java!

Molto golfato da @KevinCruijssen da 9 byte!

JavaScript (ES6), 79 77 byte

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

Casi test

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 byte

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

Gelatina , 21 byte

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

Provalo online!

Pyth , 23 21 byte

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

Suite di test .

Plain English , 820 632 610 byte

Il signor Xcoder ha suggerito di eliminare una trappola di errore non necessaria, che ha consentito di risparmiare 22 byte.

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.

Codice non golfato:

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.

L'IDE inglese normale è disponibile su github.com/Folds/english . L'IDE funziona su Windows. Si compila in codice x86 a 32 bit.

Carbone , 40 36 byte

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

Provalo online!

Spiegazione:

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

Un'alternativa con lo stesso numero di byte:

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

Provalo online! ( Versione dettagliata )

• 4 byte salvati grazie a Neil!

> <> , 68 byte

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

Provalo online o guardalo nel parco giochi per pesci !

(Ma guarda la risposta di Aaron che è più corta di 13 byte!)

Se non hai familiarità con> <>, c'è un pesce che nuota attraverso il codice in 2D e i bordi si avvolgono. I simboli >, <, ^e vimpostare la direzione del pesce, /e \sono specchi che riflettono esso, e ?significa "fare la prossima istruzione, se la cosa in cima alla pila è diverso da zero, altrimenti saltare la prossima istruzione".

Nella prima riga, il pesce assume un carattere di input ( i); se è -1 per EOF, si ferma ( :0(?;); ottiene il charcode mod 2 ( :2%$); e inserisce uno o uno 0 nello stack a seconda che il codice char sia minore o maggiore del charcode di "^" ( "^"(). Le tre righe successive reindirizzano il pesce verso la giusta stringa di fizz / ronzio, quindi l'ultima riga lo stampa (uno oper ogni personaggio) e rimanda il pesce all'inizio.

> <> , 55 byte

Basato sulla risposta di Non un albero .

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

Invece di rappresentare i 4 possibili output nel codice, rappresento solo le loro versioni in maiuscolo e ne aggiungo 32 al codice del carattere per ottenere gli equivalenti minuscoli.

Provalo online!

Codice modificato per l' interprete online , che riempie il suo spazio dei codici con celle vuote:

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

Perl5 , 50 + 1 byte

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

Crea un elenco di 128 elementi che associa i caratteri ASCII alla parola del codice corretta.

05AB1E , 22 byte

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

Provalo online!

Spiegazione

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

Soluzione alternativa a 22 byte

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

PHP , 67 byte

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

Provalo online!

F # , 154 153 145 byte

salvato 1 9 byte grazie 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""

Provalo online!

Mathematica, 134 byte

""<>{(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 byte

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

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

q / kdb +, 48 byte

Soluzione:

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

Esempi:

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"

Spiegazione:

Abbastanza semplice, prendi la stringa di input, esegui il cast in valori ASCII, crea un elenco di 1 o 0 a seconda che sia dispari o pari (suggerimento A = 65 = dispari), quindi usa questo elenco per indicizzare in un elenco di fizze buzz. Trasmetti questo su una stringa e quindi per i casi in cui l'input è <91 (inferiore a una Z) applichiamo la upperfunzione per ottenere a FIZZo a BUZZ.

q viene interpretato da destra a sinistra:

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

Rubino , 61 + 1 = 62 byte

Usa la -pbandiera.

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

Provalo online!

Swift 4 , 144 135 byte

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

Un-giocato a 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()
    )
}

Quello che sto facendo è passare in rassegna ogni personaggio della stringa. Converto ciascuno nel suo valore ASCII, quindi controllo per vedere se è pari o dispari, quindi controllo per vedere se è maiuscolo o minuscolo e output il valore corrispondente dal loop. Quindi unisco tutti gli elementi dell'array risultante in un'unica stringa e lo stampo.

Questa soluzione utilizza Swift 4, quindi non è ancora possibile testarlo online facilmente.

Grazie a @ Mr.Xcoder per avermi salvato 9 byte!

R, 150 123 108 byte

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

Deve essere più breve usando ASCII? È stato più corto. Vedi la cronologia delle modifiche per la vecchia risposta, utilizzata letters.

Controlla ogni lettera per (1) se è maiuscola o meno ( >91) e se è a fizzo a buzz.

Giava

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