标签: fizzbuzz

我一直在阅读ruby中的条件样式表达式.但是我遇到了一个我无法理解的定义经典FizzBu​​zz问题.我理解FizzBu​​zz问题,甚至在使用三元运算符找到以下快速解决方案之前编写了自己的问题.如果有人可以向我解释这个链如何工作以满足FizzBu​​zz问题,那将非常感谢:)

for i in 0...100
  puts i%3==0 ? i%5==0 ? "FizzBuzz" : "Buzz" : i%5==0 ? "Fizz" : i
end

有人可以为FizzBu​​zz更正我的这段代码吗？似乎有一个小错误.下面的代码打印所有数字,而不是仅打印不能被3或5整除的数字.

编写从打印数的程序1来100.但是对于三的倍数,打印"Fizz"而不是数字,并且对于五的倍数,打印"Buzz".对于三和五的倍数的数字,打印"FizzBuzz".

function isDivisible(numa, num) {
  if (numa % num == 0) {
    return true;
  } else {
    return false;
  }
};

function by3(num) {
  if (isDivisible(num, 3)) {
    console.log("Fizz");
  } else {
    return false;
  }
};

function by5(num) {
  if (isDivisible(num, 5)) {
    console.log("Buzz");
  } else {
    return false;
  }
};

for (var a=1; a<=100; a++) {
  if (by3(a)) {
    by3(a);
    if (by5(a)) {
      by5(a);
      console.log("\n");
    } …

我还在学习Haskell,我想知道使用一行代码表达以下语句是否有一种不那么冗长的方式:

map (\x -> (x, (if mod x 3 == 0 then "fizz" else "") ++ 
 if mod x 5 == 0 then "buzz" else "")) [1..100]

产品: [(1,""),(2,""),(3,"fizz"),(4,""),(5,"buzz"),(6,"fizz"),(7,""),(8,""),(9,"fizz"),(10,"buzz"),(11,""),(12,"fizz"),(13,""),(14,""),(15,"fizzbuzz"),(16,""),(17,""),(18,"fizz"),(19,""),(20,"buzz"),(21,"fizz"),(22,""),(23,""),(24,"fizz"),(25,"buzz"),(26,""),(27,"fizz"),(28,""),(29,""),(30,"fizzbuzz")等

感觉就像我对语法的斗争比我应该做的更多.我在Haskell中已经看到了其他问题,但是我正在寻找在单个语句中表达这一点的最佳方式(试图理解如何更好地处理语法).

我最近接受了采访,要求我制作传统的FizzBu​​zz解决方案:

输出1到100之间的数字列表.

• 对于3和5的所有倍数,该数字将替换为"FizzBu​​zz"
• 对于所有剩余的3的倍数,该数字将替换为"Fizz"
• 对于所有剩余的5的倍数,该数字将替换为"Buzz"

我的解决方案是用Java编写的,但这不是必需的.面试官很想看到一些TDD的证据,所以本着这种精神,我开始制作我自己的本土FizzBu​​zz单元测试:

public class FizzBuzzTest {

    @Test
    public void testReturnsAnArrayOfOneHundred() {
        String[] result = FizzBuzz.getResultAsArray();
        assertEquals(100, result.length);
    }

    @Test
    public void testPrintsAStringRepresentationOfTheArray() {
        String result = FizzBuzz.getResultAsString();
        assertNotNull(result);
        assertNotSame(0, result.length());
        assertEquals("1, 2", result.substring(0, 4));
    }

    @Test
    public void testMultiplesOfThreeAndFivePrintFizzBuzz() {
        String[] result = FizzBuzz.getResultAsArray();

        // Check all instances of "FizzBuzz" in array
        for (int i = 1; i <= 100; i++) {
            if ((i % 3) == 0 && (i % 5) == 0) {
                assertEquals("FizzBuzz", …

Rosettacode.org在Ruby中提供了这个出色的单行FizzBu​​zz解决方案.

1.upto(100){|n|puts'FizzBuzz '[i=n**4%-15,i+13]||n}

麻烦的是,我不明白.令我困惑的部分是"4模数-15的力量".有没有人有解释或参考解释？我想用这种方法在其他问题中选择子串.有关FizzBu​​zz的更多信息,请参阅[ https://rosettacode.org/wiki/FizzBu​​zz ]

我目前正在接受关于Javascript的代码学院课程,并且我坚持使用FizzBu​​zz任务.我需要从1-20计算,如果数字可以被3个打印嘶嘶声,5个打印嗡嗡声,可以被两个打印fizzbuzz整除,否则只需打印数字.我能用if/else if语句来做,但是我想用switch语句来尝试它,并且无法得到它.我的控制台只记录默认值并打印1-20.有什么建议？

for (var x = 0; x<=20; x++){
        switch(x){
            case x%3==0:
                console.log("Fizz");
                break;
            case x%5===0:
                console.log("Buzz");
                break;
            case x%5===0 && x%3==0:
                console.log("FizzBuzz");
                break;
            default:
                console.log(x);
                break;
        };


};

[ANSWER] Go不缓冲标准输出.切换到缓冲版本并手动刷新使其更接近您的预期.避免fmt使其运行速度尽可能快.

我正在尝试在Go中编写FizzBu​​zz程序.

func main() {
  for i := 1; i <= 1000000; i++ {
    fmt.Println(fizzbuzz(i))
  }
}

func fizzbuzz(n int) string {
  fizzy := n%3 == 0
  buzzy := n%5 == 0

  switch {
  case fizzy && buzzy:
    return "FizzBuzz"
  case fizzy:
    return "Fizz"
  case buzzy:
    return "Buzz"
  default:
    return fmt.Sprint(n)
  }
}

当我为1到100万的数字运行时,只需不到一秒钟即可完成.当我用C,Rust,Haskell或Python编写等效程序时,它需要从半秒(Python)到零秒(Rust和Haskell).

这是预期的,还是我错过了一些Go-fu？为什么go似乎比其他语言慢？

[编辑]

按照Robert Harvey的建议运行探查器.

看起来100%的时间花在了fmt.(*fmt).fmt_complex上,我猜这与Println(？)有关.还尝试使用strconv.Itoa而不是fmt.Sprint的程序,我获得了轻微的性能提升(~0.2s),但基本结果相同.

印刷是否缓慢,如果是这样,为什么？

[编辑]

对于jgritty等效的Python程序和时序.我对打印速度慢的原因感兴趣？我不知道幕后做些什么吗？

$ cat fizzbuzz.py
def fizzbuzz(n):
    fizzy = n%3 == 0
    buzzy = n%5 == 0

    if fizzy …

我有一个测验,我写了这段代码:

如果它被3整除则打印Fizz,如果它可以被5整除则打印Buzz.如果FizzBu​​ss可被两者整除,则打印它.否则,它将打印1到100之间的数字.

但是在我到家后,我想知道是否可以用更少的代码写它.但是,我不能用更短的代码出来.我可以用更短的代码吗？谢谢.

这是我写的,我认为它运作良好.但我可以用更少的代码完成它.

#include <stdio.h>

int main(void)
{
    int i;
    for(i=1; i<=100; i++)
    {
        if(((i%3)||(i%5))== 0)
            printf("number= %d FizzBuzz\n", i);
        else if((i%3)==0)
            printf("number= %d Fizz\n", i);
        else if((i%5)==0)
            printf("number= %d Buzz\n", i);
        else
            printf("number= %d\n",i);

    }

    return 0;
}

这里着名的"fizz buzz"程序在Go中使用switch/case和if/else条件.问题是使用switch/case会产生意外的输出,而if/else(具有相同的条件)工作正常.我知道golang中的switch/case与其他C系列语言不同,但是这个代码片段有什么问题？

func main() {
const (
    FIZZ = 3
    BUZZ = 5
)

//section with switch/case gives unexpected output
for i := 1; i <= 30; i++ {
    switch {
    case i % FIZZ == 0:
        fmt.Printf("%d fizz\t", i%3)
        fallthrough
    case i % BUZZ == 0:
        fmt.Printf("%d buzz\t", i%5)
    }
    fmt.Printf("\t%d\n", i)
}

fmt.Printf("now towards the if/else\n")

//section with if/else works as expected
for i := 1; i <= 30; i++ {
    if i % FIZZ == 0 { …

我们今天谈到了“fizz buzz”编程测试，我想用 C++ 来实现它，但是用元编程。理想情况下，它会在编译期间生成输出。

我当前的代码使用模板，但它仍然必须执行才能产生输出。在Ideone上查看。

我仍然使用std::cout <<为了在屏幕上打印输出。在FizzBuzz<i>::value将给要么i，-1（嘶嘶声）， -2（巴兹），或-3（FizzBu​​zz）。然后word<value>为负数定义并给出char const *：

template <int i>
struct Print {
    static void print() {
        Print<i - 1>::print();
        auto const value = FizzBuzz<i>::value;
        if (value < 0) {
            std::cout << word<value>() << std::endl;
        } else {
            std::cout << value << std::endl;
        }
    }
};

由于递归，循环消失了，有一个Print<0>可以阻止它。

是否有某种方法可以打印出word<value>()或value，哪些是在编译期间已知的？这可能不适用于每个编译器，因此我对适用于 GCC 和/或 Clang 的解决方案感到满意。