分享 最难面试的 IT 公司！-- 你敢来挑战吗？
以下只是文案
↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓
找工作=简历 + 面试？No ! 拉勾网携手 ThoughtWorks 招代码奇才，不看简历，代码说话。无需干爹，不必爸爸是李刚，you can you up.
从看到消息这一秒开始——你就可以潜心写代码，Java，C++ , C# , Ruby，Javascript , Python 都可以，鼓励使用单元测试，展示你出色的面向对象能力。
5 月 4 日上午 9:00 前把作品传回来给我们； 5 月 4 日——7 日，我们会夜以继日推敲你的代码； 5 月 8 日——9 日，通过代码测试的你，会接到我们温柔的电话； 5 月 10 日——11 日，来 ThoughtWorks 感受一天独特面试。（包括逻辑笔试、结对编程、技术对话）
ThoughtWorks 被评为全球最难面试科技公司，就算没吃到猪肉，你也将成为一个见过猪跑的人！ “世之奇伟、瑰怪、非常之观，常在于险远，而人之所罕至焉，故非有志者不能至也”，国际环境，风口行业，神一样的队友，不看简历，代码说话。程序猿们！爆发吧！扬眉吐气、验明正身的时刻到了！
查阅题目、上传作品戳这里：http://www.lagou.com/subject/s_thoughtworks.html?joinName=shouye
↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑
这样会吸引到你们去参加活动么？
我看微博上好多人蠢蠢欲动，但是实际行动的貌似不多。
How about u!
for(i=1;i<101;i++){print((i%3?"":"Fizz")+(i%5?"":"Buzz")+(i%7?"":"Whizz")||i)}
通俗版 APL 解法
A←,/(100 1⍴'' '' 'Fizz'),(100 1⍴'' '' '' '' 'Buzz'),(100 1⍴'' '' '' '' '' '' 'Whizz')
N←(A∊⊂'')/⍳100
A[N]←N
A
写了一个让人觉得高（看）大（不）上（懂）Ruby 函数式：
n = [3,5,7]
w = %w(Fizz Buzz Whizz)
l = -> a,fn {[fn.(a)] + a.combination(2).map{|_| fn.(_)} + a}
ns, ws = l.(n, -> _ {_.inject(:lcm)}), l.(w, -> _ {_.join})
1.upto(100).map{|i| i.to_s =~ /#{n[0]}/ ? w[0] : (f = ns.find_index{|l| i % l == 0}) ? ws[f] : i }
手机打的…不然应该可以写成一行？求指导…
Spc = ARGV
M = lambda {|i,n|
t = ((i%n[0].to_i == 0)?"Fizz":"") +
((i%n[1].to_i == 0)?"Bizz":"") +
((i%n[2].to_i == 0)?"Whizz":"")
!(t.empty?)?t:i
}
for i in 1...100 do
puts ((i.to_s.include?Spc[0])?
"Fizz":(M.call(i.to_i,Spc)))
end
觉得好像运算做得有点多，变量也比较多…
A←,/(100 1⍴'' '' 'Fizz'),(100 1⍴'' '' '' '' 'Buzz'),(100 1⍴'' '' '' '' '' '' 'Whizz')
N←(A∊⊂'')/⍳100
A[N]←N
T←(×+/(⍕100 1⍴⍳100)∊'3')/⍳100
A[T]←(⍴T)/⊂'Fizz'
A
⍝ 有100名学生排成一队按顺序报数
A←⍳100
⍝ 如果所报数字是3的倍数
M←0=3|⍳100
⍝ 那么不能说该数字，而要说Fizz
A[M/⍳100]←⊂'Fizz'
⍝ 如果所报数字是5的倍数
M←0=5|⍳100
⍝ 那么不能说该数字，而要说Buzz
A[M/⍳100]←⊂'Buzz'
⍝ 如果所报数字是7的倍数
M←0=7|⍳100
⍝ 那么不能说该数字，而要说Whizz
A[M/⍳100]←⊂'Whizz'
⍝ 如果所报数字是3和5的倍数
M←0=15|⍳100
⍝ 那么不能说该数字，而是要说FizzBuzz
A[M/⍳100]←⊂'FizzBuzz'
⍝ 如果所报数字是3和7的倍数
M←0=21|⍳100
⍝ 那么不能说该数字，而是要说FizzWhizz
A[M/⍳100]←⊂'FizzWhizz'
⍝ 如果所报数字是5和7的倍数
M←0=35|⍳100
⍝ 那么不能说该数字，而是要说BuzzWhizz
A[M/⍳100]←⊂'BuzzWhizz'
⍝ 如果所报数字是3、5和7的倍数
M←0=105|⍳100
⍝ 那么不能说该数字，而是要说FizzBuzzWhizz
A[M/⍳100]←⊂'FizzBuzzWhizz'
⍝ 如果所报数字中包含了3
M←∨/(⍕100 1⍴⍳100)∊'3'
⍝ 那么只报Fizz
A[M/⍳100]←⊂'Fizz'
⍝ 显示结果
A
┌─┬─┬────┬─┬────┬────┬─────┬─┬────┬────┬──┬────┬───[...277 columns of output...]──┐
│1│2│Fizz│4│Buzz│Fizz│Whizz│8│Fizz│Buzz│11│Fizz│Fiz[...277 columns of output...]zz│
└─┴─┴────┴─┴────┴────┴─────┴─┴────┴────┴──┴────┴───[...277 columns of output...]──┘
class Fizz
def initialize(*ns)
h = Hash[ns.zip(%w(Fizz Buzz Whizz))]
@rs = [->(i){i.to_s.index(ns[0].to_s) ? h[ns[0]] : ''}, ->(i){ns.inject('') {|s,n| i%n==0 ? s+h[n] : s}}, ->(i){i.to_s}]
end
def rule(i)
@rs.each {|r| s = r.call(i); return s if s.length > 0 }
end
def reports
1.upto(100).each {|i| puts rule(i)}
end
end
Fizz.new(3,5,7).reports
quakewang 果然高大上
import Data.Char
tran (a,b,c) n =
if a `elem` (show n) then "Fizz" -- rule5
else if result /= [] then result else show n
where
result = check a "Fizz" ++ check b "Buzz" ++ check c "Whizz"
check t s = if n `mod` (digitToInt t) == 0 then s else []
main = do (a:',':b:',':c:_) <- getContents
mapM_ (putStrLn . (tran (a,b,c))) [1..100]
n = [3, 5, 7] w = %w(Fizz Buzz Whizz) ns = [n.inject(:)]+n.combination(2).map { |b| b.inject(:) } + n ws = [w.join]+w.combination(2).map { |b| b.join } + w 1.upto(20).map { |i| i.to_s =~ /#{n[0]}/ ? w[0] : (f = ns.find_index { |l| i % l == 0 }) ? ws[f] : i }
floor 15 good
n = [3, 5, 7]
w = %w(Fizz Buzz Whizz)
l = lambda { |a, fn| [fn.call(a)] + a.combination(2).map { |b| fn.call(b) } + a }
ns = l.call(n, lambda { |a| a.inject(:*) })
ws = l.call(w, lambda { |a| a.join })
1.upto(10).map { |i| i.to_s =~ /#{n[0]}/ ? w[0] : (f = ns.find_index { |l| i % l == 0 }) ? ws[f] : i }
函数数据流风格
fizzfy = ->((n, words)) {n % 3 == 0 ? [n, words << 'Fizz'] : [n, words]}
buzzfy = ->((n, words)) {n % 5 == 0 ? [n, words << 'Buzz'] : [n, words]}
whizzfy = ->((n, words)) {n % 7 == 0 ? [n, words << 'Whizz'] : [n, words]}
special_fizzfy = -> ((n, words)) {n.to_s.include?("3") ? [n, ["Fizz"]] : [n, words]}
initialize = ->(n) {[n, []]}
normalize = -> ((n, words)) {words.empty? ? n : words.reduce(:+)}
puts (1..100).map(&initialize).map(&fizzfy).map(&buzzfy).map(&whizzfy).map(&special_fizzfy).map(&normalize)
