❶ （求演算法高手！）將一個正整數表示為N個不同的正整數之和。
200分懸賞啊，我要試一試啊。
首先是思路：
n能被拆分成不同的整數之和 =
S(1) = (n-1) + 1能被拆分成不同的整數之和
S(2) = (n-2) + 2能被拆分成不同的整數之和
。。。
S(n-1) = (n-1)能被拆分成不同的整數之和
最後一步：求並集
S(n) = Union( S(1), S(2), S(3), ..., S(n-1) )
=========================================
手動模擬一下這個演算法:
n=6 能被拆分成不同的整數之和
5 + 1能被拆分成不同的整數之和 => S1 = [5,1]
4 + 2能被拆分成不同的整數之和 => S2 = [4,2]
3 + 3能被拆分成不同的整數之和
這一步要遞歸
3能被拆分成不同的整數之和
= 2 + 1能被拆分成不同的整數之和 => [2,1]
= 1 + 2能被拆分成不同的整數之和 => 重復
=>S3 = [3,2,1]
2 + 4能被拆分成不同的整數之和，重復，S4=[]
1 + 5能被拆分成不同的整數之和，重復，S5=[]
S = Union( S1, S2, S3, S(4), S(5) )
= [[5,1], [4,2], [3,2,1]]
=========================================
最後就是代碼啦，python實現的
有2個函數，NumberSplit計算所有的拆分，checkuniq用來去重復的，去重復用了點python技巧，C++的話用hash_set應該也可以。
def NumberSplit( n ):
if n<0:
raise Exception
if n<3:
return [[n]]
sumArray = list()
for i in range(1,n):
t = NumberSplit(n-i)
for item in t:
if i in item:
continue
item.append(i)
sumArray.append(item)
return sumArray
def checkuniq(x):
for item in x:
item.sort()
return list(set(map(tuple, x)))
========================
試一下結果：
>>> checkuniq(NumberSplit(9))
[(1, 3, 5), (2, 7), (2, 3, 4), (1, 2, 6), (1, 8)]
整個大點的數字，呵呵有點慢，沒有優化。
>>> g=checkuniq(NumberSplit(20))
>>> g.sort()
[(1, 2, 3, 4, 10), (1, 2, 3, 5, 9), (1, 2, 3, 6, 8), (1, 2, 3, 14), (1, 2, 4, 5, 8), (1, 2, 4, 6, 7), (1, 2, 4, 13), (1, 2, 5, 12), (1, 2, 6, 11), (1, 2, 7, 10), (1, 2, 8, 9), (1, 2, 17), (1, 3, 4, 5, 7), (1, 3, 4, 12), (1, 3, 5, 11), (1, 3, 6, 10), (1, 3, 7, 9), (1, 3, 16), (1, 4, 5, 10), (1, 4, 6, 9), (1, 4, 7, 8), (1, 4, 15), (1, 5, 6, 8), (1, 5, 14), (1, 6, 13), (1, 7, 12), (1, 8, 11), (1, 9, 10), (1, 19), (2, 3, 4, 5, 6), (2, 3, 4, 11), (2, 3, 5, 10), (2, 3, 6, 9), (2, 3, 7, 8), (2, 3, 15), (2, 4, 5, 9), (2, 4, 6, 8), (2, 4, 14), (2, 5, 6, 7), (2, 5, 13), (2, 6, 12), (2, 7, 11), (2, 8, 10), (2, 18)]
❷ 如何應付不知名的爬蟲騷擾
一、手工識別和拒絕爬蟲的訪問
有相當多的爬蟲對網站會造成非常高的負載，因此識別爬蟲的來源IP是很容易的事情。最簡單的辦法就是用netstat檢查80埠的連接：
C代碼 netstat -nt | grep youhostip:80 | awk '{print $5}' | awk -F":" '{print $1}'| sort | uniq -c | sort -r -n netstat -nt | grep youhostip:80 | awk '{print $5}' | awk -F":" '{print $1}'| sort | uniq -c | sort -r -n
這行shell可以按照80埠連接數量對來源IP進行排序，這樣可以直觀的判斷出來網頁爬蟲。一般來說爬蟲的並發連接非常高。
如果使用lighttpd做Web Server，那麼就更簡單了。lighttpd的mod_status提供了非常直觀的並發連接的信息，包括每個連接的來源IP，訪問的URL，連接狀態和連接時間等信息，只要檢查那些處於handle-request狀態的高並發IP就可以很快確定爬蟲的來源IP了。
拒絕爬蟲請求既可以通過內核防火牆來拒絕，也可以在web server拒絕，比方說用iptables拒絕：
C代碼 iptables -A INPUT -i eth0 -j DROP -p tcp --dport 80 -s 84.80.46.0/24 iptables -A INPUT -i eth0 -j DROP -p tcp --dport 80 -s 84.80.46.0/24
直接封鎖爬蟲所在的C網段地址。這是因為一般爬蟲都是運行在託管機房裡面，可能在一個C段裡面的多台伺服器上面都有爬蟲，而這個C段不可能是用戶寬頻上網，封鎖C段可以很大程度上解決問題。
有些人提出一種腦殘的觀點，說我要懲罰這些爬蟲。我專門在網頁裡面設計動態循環鏈接頁面，讓爬蟲掉進陷阱，死循環爬不出來，其實根本用不著設置陷阱，弱智爬蟲對正常網頁自己就爬不出來，這樣做多此一舉不說，而且會讓真正的搜索引擎降低你的網頁排名。而且運行一個爬蟲根本不消耗什麼機器資源，相反，真正寶貴的是你的伺服器CPU資源和伺服器帶寬，簡單的拒絕掉爬蟲的請求是反爬蟲最有效的策略。
二、通過識別爬蟲的User-Agent信息來拒絕爬蟲
有很多爬蟲並不會以很高的並發連接爬取，一般不容易暴露自己；有些爬蟲的來源IP分布很廣，很難簡單的通過封鎖IP段地址來解決問題；另外還有很多各種各樣的小爬蟲，它們在嘗試Google以外創新的搜索方式，每個爬蟲每天爬取幾萬的網頁，幾十個爬蟲加起來每天就能消耗掉上百萬動態請求的資源，由於每個小爬蟲單獨的爬取量都很低，所以你很難把它從每天海量的訪問IP地址當中把它准確的挖出來。
這種情況下我們可以通過爬蟲的User-Agent信息來識別。每個爬蟲在爬取網頁的時候，會聲明自己的User-Agent信息，因此我們就可以通過記錄和分析User-Agent信息來挖掘和封鎖爬蟲。我們需要記錄每個請求的User-Agent信息，對於Rails來說我們可以簡單的在app/controllers/application.rb裡面添加一個全局的before_filter，來記錄每個請求的User-Agent信息：
Ruby代碼 logger.info "HTTP_USER_AGENT #{request.env["HTTP_USER_AGENT"]}" logger.info "HTTP_USER_AGENT #{request.env["HTTP_USER_AGENT"]}"
然後統計每天的proction.log，抽取User-Agent信息，找出訪問量最大的那些User-Agent。要注意的是我們只關注那些爬蟲的User-Agent信息，而不是真正瀏覽器User-Agent，所以還要排除掉瀏覽器User-Agent，要做到這一點僅僅需要一行shell：
Ruby代碼 grep HTTP_USER_AGENT proction.log | grep -v -E 'MSIE|Firefox|Chrome|Opera|Safari|Gecko' | sort | uniq -c | sort -r -n | head -n 100 > bot.log grep HTTP_USER_AGENT proction.log | grep -v -E 'MSIE|Firefox|Chrome|Opera|Safari|Gecko' | sort | uniq -c | sort -r -n | head -n 100 > bot.log
統計結果類似這樣：
C代碼 57335 HTTP_USER_AGENT Baispider+(+ http://www..com/search/spider.htm)56639 HTTP_USER_AGENT Mozilla/5.0 (compatible; Googlebot/2.1; + http://www.google.com/bot.html)42610 HTTP_USER_AGENT Mediapartners-Google 19131 HTTP_USER_AGENT msnbot/2.0b (+ http://search.msn.com/msnbot.htm)57335 HTTP_USER_AGENT Baispider+(+ http://www..com/search/spider.htm) 56639 HTTP_USER_AGENT Mozilla/5.0 (compatible; Googlebot/2.1; + http://www.google.com/bot.html) 42610 HTTP_USER_AGENT Mediapartners-Google 19131 HTTP_USER_AGENT msnbot/2.0b (+ http://search.msn.com/msnbot.htm)
從日誌就可以直觀的看出每個爬蟲的請求次數。要根據User-Agent信息來封鎖爬蟲是件很容易的事情，lighttpd配置如下：
C代碼 $HTTP["useragent"] =~ "qihoobot|^Java|Commons-HttpClient|Wget|^php|Ruby|Python" { url.rewrite = ( "^/(.*)" => "/crawler.html" ) } $HTTP["useragent"] =~ "qihoobot|^Java|Commons-HttpClient|Wget|^PHP|Ruby|Python" { url.rewrite = ( "^/(.*)" => "/crawler.html" ) }
使用這種方式來封鎖爬蟲雖然簡單但是非常有效，除了封鎖特定的爬蟲，還可以封鎖常用的編程語言和HTTP類庫的User-Agent信息，這樣就可以避免很多無謂的程序員用來練手的爬蟲程序對網站的騷擾。
還有一種比較常見的情況，就是某個搜索引擎的爬蟲對網站爬取頻率過高，但是搜索引擎給網站帶來了很多流量，我們並不希望簡單的封鎖爬蟲，僅僅是希望降低爬蟲的請求頻率，減輕爬蟲對網站造成的負載，那麼我們可以這樣做：
C代碼 $HTTP["user-agent"] =~ "Baispider+" { connection.delay-seconds = 10 } $HTTP["user-agent"] =~ "Baispider+" { connection.delay-seconds = 10 }
對網路的爬蟲請求延遲10秒鍾再進行處理，這樣就可以有效降低爬蟲對網站的負載了。
三、通過網站流量統計系統和日誌分析來識別爬蟲
有些爬蟲喜歡修改User-Agent信息來偽裝自己，把自己偽裝成一個真實瀏覽器的User-Agent信息，讓你無法有效的識別。這種情況下我們可以通過網站流量系統記錄的真實用戶訪問IP來進行識別。
主流的網站流量統計系統不外乎兩種實現策略：一種策略是在網頁裡面嵌入一段js，這段js會向特定的統計伺服器發送請求的方式記錄訪問量；另一種策略是直接分析伺服器日誌，來統計網站訪問量。在理想的情況下，嵌入js的方式統計的網站流量應該高於分析伺服器日誌，這是因為用戶瀏覽器會有緩存，不一定每次真實用戶訪問都會觸發伺服器的處理。但實際情況是，分析伺服器日誌得到的網站訪問量遠遠高於嵌入js方式，極端情況下，甚至要高出10倍以上。
現在很多網站喜歡採用awstats來分析伺服器日誌，來計算網站的訪問量，但是當他們一旦採用Google Analytics來統計網站流量的時候，卻發現GA統計的流量遠遠低於awstats，為什麼GA和awstats統計會有這么大差異呢？罪魁禍首就是把自己偽裝成瀏覽器的網路爬蟲。這種情況下awstats無法有效的識別了，所以awstats的統計數據會虛高。
其實作為一個網站來說，如果希望了解自己的網站真實訪問量，希望精確了解網站每個頻道的訪問量和訪問用戶，應該用頁面裡面嵌入js的方式來開發自己的網站流量統計系統。自己做一個網站流量統計系統是件很簡單的事情，寫段伺服器程序響應客戶段js的請求，分析和識別請求然後寫日誌的同時做後台的非同步統計就搞定了。
通過流量統計系統得到的用戶IP基本是真實的用戶訪問，因為一般情況下爬蟲是無法執行網頁裡面的js代碼片段的。所以我們可以拿流量統計系統記錄的IP和伺服器程序日誌記錄的IP地址進行比較，如果伺服器日誌裡面某個IP發起了大量的請求，在流量統計系統裡面卻根本找不到，或者即使找得到，可訪問量卻只有寥寥幾個，那麼無疑就是一個網路爬蟲。
分析伺服器日誌統計訪問最多的IP地址段一行shell就可以了：
C代碼 grep Processing proction.log | awk '{print $4}' | awk -F'.' '{print $1"."$2"."$3".0"}' | sort | uniq -c | sort -r -n | head -n 200 > stat_ip.log grep Processing proction.log | awk '{print $4}' | awk -F'.' '{print $1"."$2"."$3".0"}' | sort | uniq -c | sort -r -n | head -n 200 > stat_ip.log
然後把統計結果和流量統計系統記錄的IP地址進行對比，排除真實用戶訪問IP，再排除我們希望放行的網頁爬蟲，比方Google，網路，微軟msn爬蟲等等。最後的分析結果就就得到了爬蟲的IP地址了。以下代碼段是個簡單的實現示意：
Ruby代碼 whitelist = [] IO.foreach("#{RAILS_ROOT}/lib/whitelist.txt") { |line| whitelist << line.split[0].strip if line } realiplist = [] IO.foreach("#{RAILS_ROOT}/log/visit_ip.log") { |line| realiplist << line.strip if line } iplist = [] IO.foreach("#{RAILS_ROOT}/log/stat_ip.log") do |line| ip = line.split[1].strip iplist << ip if line.split[0].to_i > 3000 && !whitelist.include?(ip) && !realiplist.include?(ip) end Report.deliver_crawler(iplist) whitelist = [] IO.foreach("#{RAILS_ROOT}/lib/whitelist.txt") { |line| whitelist << line.split[0].strip if line } realiplist = [] IO.foreach("#{RAILS_ROOT}/log/visit_ip.log") { |line| realiplist << line.strip if line } iplist = [] IO.foreach("#{RAILS_ROOT}/log/stat_ip.log") do |line| ip = line.split[1].strip iplist << ip if line.split[0].to_i > 3000 && !whitelist.include?(ip) && !realiplist.include?(ip) end Report.deliver_crawler(iplist)
分析伺服器日誌裡面請求次數超過3000次的IP地址段，排除白名單地址和真實訪問IP地址，最後得到的就是爬蟲IP了，然後可以發送郵件通知管理員進行相應的處理。
四、網站的實時反爬蟲防火牆實現策略
通過分析日誌的方式來識別網頁爬蟲不是一個實時的反爬蟲策略。如果一個爬蟲非要針對你的網站進行處心積慮的爬取，那麼他可能會採用分布式爬取策略，比方說尋找幾百上千個國外的代理伺服器瘋狂的爬取你的網站，從而導致網站無法訪問，那麼你再分析日誌是不可能及時解決問題的。所以必須採取實時反爬蟲策略，要能夠動態的實時識別和封鎖爬蟲的訪問。
要自己編寫一個這樣的實時反爬蟲系統其實也很簡單。比方說我們可以用memcached來做訪問計數器，記錄每個IP的訪問頻度，在單位時間之內，如果訪問頻率超過一個閥值，我們就認為這個IP很可能有問題，那麼我們就可以返回一個驗證碼頁面，要求用戶填寫驗證碼。如果是爬蟲的話，當然不可能填寫驗證碼，所以就被拒掉了，這樣很簡單就解決了爬蟲問題。
用memcache記錄每個IP訪問計數，單位時間內超過閥值就讓用戶填寫驗證碼，用Rails編寫的示例代碼如下：
Ruby代碼 ip_counter = Rails.cache.increment(request.remote_ip) if !ip_counter Rails.cache.write(request.remote_ip, 1, :expires_in => 30.minutes) elsif ip_counter > 2000 render :template => 'test', :status => 401 and return false end ip_counter = Rails.cache.increment(request.remote_ip) if !ip_counter Rails.cache.write(request.remote_ip, 1, :expires_in => 30.minutes) elsif ip_counter > 2000 render :template => 'test', :status => 401 and return false end
這段程序只是最簡單的示例，實際的代碼實現我們還會添加很多判斷，比方說我們可能要排除白名單IP地址段，要允許特定的User-Agent通過，要針對登錄用戶和非登錄用戶，針對有無referer地址採取不同的閥值和計數加速器等等。
此外如果分布式爬蟲爬取頻率過高的話，過期就允許爬蟲再次訪問還是會對伺服器造成很大的壓力，因此我們可以添加一條策略：針對要求用戶填寫驗證碼的IP地址，如果該IP地址短時間內繼續不停的請求，則判斷為爬蟲，加入黑名單，後續請求全部拒絕掉。為此，示例代碼可以改進一下：
Ruby代碼 before_filter :ip_firewall, :except => :test def ip_firewall render :file => "#{RAILS_ROOT}/public/403.html", :status => 403 if BlackList.include?(ip_sec) end before_filter :ip_firewall, :except => :test def ip_firewall render :file => "#{RAILS_ROOT}/public/403.html", :status => 403 if BlackList.include?(ip_sec) end
我們可以定義一個全局的過濾器，對所有請求進行過濾，出現在黑名單的IP地址一律拒絕。對非黑名單的IP地址再進行計數和統計：
Ruby代碼 ip_counter = Rails.cache.increment(request.remote_ip) if !ip_counter Rails.cache.write(request.remote_ip, 1, :expires_in => 30.minutes) elsif ip_counter > 2000 crawler_counter = Rails.cache.increment("crawler/#{request.remote_ip}") if !crawler_counter Rails.cache.write("crawler/#{request.remote_ip}", 1, :expires_in => 10.minutes) elsif crawler_counter > 50 BlackList.add(ip_sec) render :file => "#{RAILS_ROOT}/public/403.html", :status => 403 and return false end render :template => 'test', :status => 401 and return false end ip_counter = Rails.cache.increment(request.remote_ip) if !ip_counter Rails.cache.write(request.remote_ip, 1, :expires_in => 30.minutes) elsif ip_counter > 2000 crawler_counter = Rails.cache.increment("crawler/#{request.remote_ip}") if !crawler_counter Rails.cache.write("crawler/#{request.remote_ip}", 1, :expires_in => 10.minutes) elsif crawler_counter > 50 BlackList.add(ip_sec) render :file => "#{RAILS_ROOT}/public/403.html", :status => 403 and return false end render :template => 'test', :status => 401 and return false end
如果某個IP地址單位時間內訪問頻率超過閥值，再增加一個計數器，跟蹤他會不會立刻填寫驗證碼，如果他不填寫驗證碼，在短時間內還是高頻率訪問，就把這個IP地址段加入黑名單，除非用戶填寫驗證碼激活，否則所有請求全部拒絕。這樣我們就可以通過在程序裡面維護黑名單的方式來動態的跟蹤爬蟲的情況，甚至我們可以自己寫個後台來手工管理黑名單列表，了解網站爬蟲的情況。
這個策略已經比較智能了，但是還不夠好！我們還可以繼續改進：
1、用網站流量統計系統來改進實時反爬蟲系統
還記得嗎？網站流量統計系統記錄的IP地址是真實用戶訪問IP，所以我們在網站流量統計系統裡面也去操作memcached，但是這次不是增加計數值，而是減少計數值。在網站流量統計系統裡面每接收到一個IP請求，就相應的cache.decrement(key)。所以對於真實用戶的IP來說，它的計數值總是加1然後就減1，不可能很高。這樣我們就可以大大降低判斷爬蟲的閥值，可以更加快速准確的識別和拒絕掉爬蟲。
2、用時間窗口來改進實時反爬蟲系統
爬蟲爬取網頁的頻率都是比較固定的，不像人去訪問網頁，中間的間隔時間比較無規則，所以我們可以給每個IP地址建立一個時間窗口，記錄IP地址最近12次訪問時間，每記錄一次就滑動一次窗口，比較最近訪問時間和當前時間，如果間隔時間很長判斷不是爬蟲，清除時間窗口，如果間隔不長，就回溯計算指定時間段的訪問頻率，如果訪問頻率超過閥值，就轉向驗證碼頁面讓用戶填寫驗證碼。
最終這個實時反爬蟲系統就相當完善了，它可以很快的識別並且自動封鎖爬蟲的訪問，保護網站的正常訪問。不過有些爬蟲可能相當狡猾，它也許會通過大量的爬蟲測試來試探出來你的訪問閥值，以低於閥值的爬取速度抓取你的網頁，因此我們還需要輔助第3種辦法，用日誌來做後期的分析和識別，就算爬蟲爬的再慢，它累計一天的爬取量也會超過你的閥值被你日誌分析程序識別出來。
總之我們綜合運用上面的四種反爬蟲策略，可以很大程度上緩解爬蟲對網站造成的負面影響，保證網站的正常訪問。
❸ 從資料庫查詢對象返回一個list集合跟返回一個Object[]對象集合有什麼區別阿 為什麼que
前一個是一個結果集，後一個只是一個其中的一條記錄的對象，用前一個方法再加上遍歷就能獲取所有返回對象
❹ TypeScript 類型挑戰 Medium
[[toc]]
Medium , #infer , #built-in
實現 TS 內置的 ReturnType<T> ，但不可以使用它。
答案
Medium , #union , #built-in
不使用 Omit 實現 TypeScript 的 Omit<T, K> 泛型。
Omit 會創建一個省略 K 中欄位的 T 對象。
答案
Medium , #readonly , #object-keys
實現一個通用 MyReadonly2<T, K> ，它帶有兩種類型的參數 T 和 K 。
K 指定應設置為Readonly的 T 的屬性集。如果未提供 K ，則應使所有屬性都變為只讀，就像普通的 Readonly<T> 一樣。
答案
Medium , #readonly , #object-keys , #deep
實現一個通用的 DeepReadonly<T> ，它將對象的每個參數及其子對象遞歸地設為只讀。
您可以假設在此挑戰中我們僅處理對象。數組，函數，類等都無需考慮。但是，您仍然可以通過覆蓋盡可能多的不同案例來挑戰自己。
答案
Medium , #infer , #tuple , #union
實現泛型 TupleToUnion<T> ，它返回元組所有值的合集。
答案
Medium , #application
在 JavaScript 中我們很常會使用可串聯（Chainable/Pipeline）的函數構造一個對象，但在 TypeScript 中，你能合理的給他附上類型嗎？
在這個挑戰中，你可以使用任意你喜歡的方式實現這個類型 - Interface, Type 或 Class 都行。你需要提供兩個函數 option(key, value) 和 get() 。在 option 中你需要使用提供的 key 和 value 擴展當前的對象類型，通過 get 獲取最終結果。
你只需要在類型層面實現這個功能 - 不需要實現任何 TS/JS 的實際邏輯。
你可以假設 key 只接受字元串而 value 接受任何類型，你只需要暴露它傳遞的類型而不需要進行任何處理。同樣的 key 只會被使用一次。
答案
Medium , #array
實現一個通用 Last<T> ，它接受一個數組 T 並返回其最後一個元素的類型。
答案
Medium , #array
實現一個通用 Pop<T> ，它接受一個數組 T 並返回一個沒有最後一個元素的數組。
額外 ：同樣，您也可以實現 Shift ， Push 和 Unshift 嗎？
答案
Medium , #array , #built-in
鍵入函數 PromiseAll ，它接受PromiseLike對象數組，返回值應為 Promise<T> ，其中 T 是解析的結果數組。
答案
Medium , #union , `#map
有時，您可能希望根據某個屬性在聯合類型中查找類型。
在此挑戰中，我們想通過在聯合類型 Cat | Dog 中搜索公共 type 欄位來獲取相應的類型。換句話說，在以下示例中，我們期望 LookUp<Dog | Cat, 'dog'> 獲得 Dog ， LookUp<Dog | Cat, 'cat'> 獲得 Cat 。
答案
Medium , #template-literal
實現 TrimLeft<T> ，它接收確定的字元串類型並返回一個新的字元串，其中新返回的字元串刪除了原字元串開頭的空白字元串。
答案
Medium , #template-literal
實現 Trim<T> ，它是一個字元串類型，並返回一個新字元串，其中兩端的空白符都已被刪除。
答案
Medium , #template-literal
實現 Capitalize<T> 它將字元串的第一個字母轉換為大寫，其餘字母保持原樣。
答案
Medium , #template-iteral
實現 Replace<S, From, To> 將字元串 S 中的第一個子字元串 From 替換為 To 。
答案
Medium , #template-literal
實現 ReplaceAll<S, From, To> 將一個字元串 S 中的所有子字元串 From 替換為 To 。
答案
Medium , #arguments
實現一個泛型 AppendArgument<Fn, A> ，對於給定的函數類型 Fn ，以及一個任意類型 A ，返回一個新的函數 G 。 G 擁有 Fn 的所有參數並在末尾追加類型為 A 的參數。
答案
Medium , #union
實現聯合類型的全排列，將聯合類型轉換成所有可能的全排列數組的聯合類型。
答案
https://github.com/type-challenges/type-challenges/issues/614
Note
Medium , #template-literal
計算字元串的長度，類似於 String#length 。
答案
Medium , #array
在這個挑戰中，你需要寫一個接受數組的類型，並且返回扁平化的數組類型。
答案
Medium , #object-keys
實現一個為介面添加一個新欄位的類型。該類型接收三個參數，返回帶有新欄位的介面類型。
答案
Medium , #math , #template-literal
實現一個接收string,number或bigInt類型參數的 Absolute 類型,返回一個正數字元串。
答案
Medium , #union , #string
實現一個將接收到的String參數轉換為一個字母Union的類型。
答案
Medium , #object
實現聯合類型的全排列，將聯合類型轉換成所有可能的全排列數組的聯合類型。
答案
Medium , #
FooBarBaz -> foo-bar-baz
答案
Medium , #object
獲取兩個介面類型中的差值屬性。
答案
Medium , #array
在類型系統中實現類似於 Python 中 any 函數。類型接收一個數組，如果數組中任一個元素為真，則返回 true ，否則返回 false 。如果數組為空，返回 false 。
答案
Medium , #union , #utils
實現 IsNever 類型, 解析輸入 T 類型為 never 返回 true 否則 返回 false
答案
Medium , #union , #utils
實現 IsUnion 類型, 解析輸入 T 類型為聯合類型 返回 true 否則 返回 false
答案
Medium
實現 ReplaceKeys 類型, 它將替換聯合類型中類型的鍵值， 如果該類型沒有這個Key則跳過，如果有則替換。
答案
Medium
從對象類型中排除索引簽名。
答案
https://github.com/type-challenges/type-challenges/issues/3542
Medium
實現類型 PercentageParser。根據規則 /^(+|-)?(d*)?(\%)?$/ 匹配類型 T。
匹配的結果由三部分組成，分別是：[ 正負號 , 數字 , 單位 ]，如果沒有匹配，則默認是空字元串。
答案
Medium
從字元串中剔除指定字元。
答案
Medium , Math
給定一個正整數作為類型的參數，要求返回的類型是該數字減 1。
答案
Medium , object
從 F 中選出類型相同的屬性
答案
Medium , #object
保留沒有在U中指定的類型的欄位
答案
Medium ， #template-literal
實現 StartsWith<T, U> ,接收兩個string類型參數,然後判斷 T 是否以 U 開頭,根據結果返回 true 或 false
答案
Medium , #object
實現一個通用的 PartialByKeys<T, K> ，它接收兩個類型參數 T 和 K 。
K 指定應設置為可選的 T 的屬性集。當沒有提供 K 時，它就和普通的 Partial<T> 一樣使所有屬性都是可選的。
答案
Medium , #object
實現一個通用的 RequiredByKeys<T, K> ，它接收兩個類型參數 T 和 K 。
K 指定應設為必選的 T 的屬性集。當沒有提供 K 時，它就和普通的 Required<T> 一樣使所有的屬性成為必選的。
答案
Medium , #readonly , object-keys
實現一個通用的類型 Mutable<T> ，使類型 T 的全部屬性可變（非只讀）。
答案
Medium , #object
1
答案
Medium
給定只包含字元串的元組，和類型U, 遞歸構建對象
答案
Medium , #tuple
實現類型版本的數組反轉 Array.reverse
答案
Medium , #arguments
實現類型版本的 lodash _.flip 函數
類型 FlipArguments<T> 需要函數 T 並返回一個新的函數類型。這個函數類型擁有相同的參數，但參數類型是被反轉的。
答案
Medium , #array
按深度遞歸展平陣列。
答案
Medium
塊、元素、修飾符方法 (BEM) 是 CSS 中類的流行命名約定。例如，塊組件將表示為 btn ，依賴於塊的元素將表示為 btn__price ，改變塊樣式的修飾符將表示為 btn--big 或 btn__price--warning 。實現 BEM<B, E, M> 從這三個參數生成字元串聯合。其中 B 是字元串文字，E 和 M 是字元串數組（可以為空）。
答案
Medium , #object
實現二叉樹中序遍歷的類型版本。
答案
Medium
實現類型 just-flip-object :
答案
Medium
實現泛型 Fibonacci<T> 傳入數字 T 返回正確的 Fibonacci number .
1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, ...
答案
Medium
實現類型 AllCombinations<S> 返回所有字元組合.
答案
Medium ， #array
實現類型 GreaterThan<T, U> 來比較大小，就像 T > U 。不需要考慮負數
1
答案
Medium , #tuple
實現 Zip<T, U> 類型。 T, U 必須為 Tuple
答案
Medium , #tuple
實現 IsTuple , 接收類型 T 判斷 T 是否為元組類型
答案
Medium ， #tuple
實現 Chunk<T, N> , 它有兩個必填的類型參數， T 必須為 tuple , N 必須為大於1的數字
答案
Medium , tuple
Fill , 一個常用的 JavaScript 函數, 我們用類型實現它. Fill<T, N, Start?, End?> , 它接收4個類型參數, T , N 是必填參數 T 為元組, N 為 any, Start , End 是可選參數，為大於零的數子.
為了模擬真實的功能，測試中可能會包含一些邊界條件，希望大家喜歡:)
答案
Medium
實現 TrimRight<T> 它採用精確的字元串類型並返回一個刪除了空格結尾的新字元串。
答案
Medium , #union , #array
實現一個像 Lodash.without 函數一樣的泛型 Without<T, U>，它接收數組類型的 T 和數字或數組類型的 U 為參數，會返回一個去除 U 中元素的數組 T。
答案
Medium , template-literal
實現類型版本的 Math.trunc . 它接受字元串或數字返回整數部分，提出小數部分
答案
Medium , #array
實現類型版本的 Array.indexOf<T, U> , 它接收數組T 和 U 返回U在T中的索引值
答案
Medium , #array
實現類型版 Array.join<T, U> 接收數組T和字元串或數字 U
答案
Medium , #array
實現類型版本的 Array.lastIndexOf<T, U> , 它接收數組T 和 U 返回U在T中的反向索引值
答案
Medium , #array
實現類型版本的 Lodash.uniq , 它接收數組T，返回去重後的T
答案
Medium
實現 MapTypes<T, R> 它將對象 T 中的類型轉換為類型 R 定義的不同類型，類型 R 具有以下結構。
答案
Medium , #tuple
構造一個給定長度的元組
答案
Medium
有時我們想限制數字的范圍......例如。
答案
Medium , #array , #application , #string
給定一個字元串數組，進行置換和組合。它對於像video controlsList這樣的類型也很有用
答案
Medium , #union
給定一個唯一元素數組，返回所有可能的子序列。
子序列是一個序列，可以通過刪除一些元素或不刪除任何元素而從數組中派生，而不改變其餘元素的順序。
答案
❺ 關於用python計算豎乘的問題，具體要求和希望輸出格式如下
草稿版
#coding:utf-8
'''
***
x***
------------
****
****
****
------------
******
eachstartisanumber;
sumforeachlineshallbesame
'''
importrandomasRND
defNumberListFactory(width=3):
standard=range(10)
ret=[]
foriinxrange(0,width):
ifi==0:
value=standard.pop(RND.randint(1,len(standard)-1))
else:
value=standard.pop(RND.randint(0,len(standard)-1))
ret.append(value)
returnret
defNumber2List(num):
ret=[]
tmp=0
foriinxrange(len(str(num))-1,0,-1):
key=(num-tmp)/(10**i)
ret.append(key)
tmp=tmp+key*(10**i)
ret.append(num-tmp)
returnret
defList2Number(lst):
ret=0
foriinxrange(0,len(lst)):
ret+=lst[i]*(10**(len(lst)-i-1))
returnret
defList2String(lst):
return''.join([str(i)foriinlst])
defIsUniq(lst):
foriinlst:
tmp=lst[:]
tmp.remove(i)
ifiintmp:
returnFalse
returnTrue
counter=0
result=None
whileresultisNone:
counter+=1
p1=NumberListFactory()
p2=NumberListFactory()
standard=sum(p1)
ifstandard!=sum(p2):
continue
else:
multiResult=[]
foriinxrange(len(p2)-1,-1,-1):
tmp=Number2List(p2[i]*List2Number(p1))
iflen(tmp)!=4:#
continue
else:
ifIsUniq(tmp):
multiResult.append(tmp)
#filterresultwhenzero
iflen(multiResult)!=3:
continue
#
flag=True
forjinmultiResult:
ifstandard!=sum(j):
flag=False
break
ifflagisFalse:
continue
#
result=Number2List(List2Number(p1)*List2Number(p2))
iflen(result)!=6orstandard!=sum(result)orIsUniq(result)isFalse:
result=None
continue
else:
print'SUMofLine->{}'.format(standard)
print'LoopID:{} '.format(counter)
print'{}'.format(List2String(p1))
print'x{}'.format(List2String(p2))
print'-'*12
forkinxrange(len(multiResult)-1,-1,-1):
print'{}{}'.format(''*k*2,List2String(multiResult[len(multiResult)-1-k]))
print'-'*12
printList2String(result)
print' Over'
可以的話，做一些優化。
❻ python運維自動化取頁面數據
1、linux系統基礎，這個不用說了，是基礎中的基礎，連這個都不會就別幹了，參考書籍，可以看鳥哥linux基礎篇，至少要掌握這書60%內容，沒必須全部掌握，但基本命令總得會吧
2、網路服務，服務有很多種，每間公司都會用到不同的，但基礎的服務肯定要掌握，如FTP, DNS,SAMBA, 郵件, 這幾個大概學一下就行，LAMP和LNMP是必須要熟練，我所指的不是光光會搭建，而是要很熟悉裡面的相當配置才行，因為公司最關鍵的絕對是WEB伺服器，所以nginx和apache要熟悉，特別是nginx一定要很熟悉才行，至少有些公司還會用tomcat，這個也最好學一下。其實網路服務方面不用太擔心，一般公司的環境都已經搭建好，就算有新伺服器或讓你整改，公司會有相應的文檔讓你參照來弄，不會讓你亂來的，但至少相關的配置一定要學熟，而且肯定是編譯安裝多，那些模塊要熟悉一下他的作用，特別是PHP那些模塊。
這面2點只是基礎，也是必要條件，不能說是工具，下以才是真正的要掌握的工具。
3、shell腳本和另一個腳本語言，shell是運維人員必須具備的，不懂這個連入職都不行，至少也要寫出一些系統管理腳本，最簡單也得寫個監控CPU，內存比率的腳本吧，這是最最最基本了，別以為會寫那些猜數字和計算什麼數的，這些沒什麼作用，只作學習意義，寫系統腳本才是最有意義，而另一個腳本語言是可選的，一般是3P，即python, perl和php，php就不需要考慮了，除非你要做開發，我個人建議學python會比較好，難實現自動化運維，perl是文本處理很強大，反正這兩個學一個就行了。
4、sed和awk工具，必須要掌握，在掌握這兩個工具同時，還要掌握正則表達式，這個就痛苦了，正則是最難學的表達式，但結合到sed和awk中會很強大，在處理文本內容和過濾WEB內容時十分有用，不過在學shell的同時一般會經常結合用到的，所以學第3點就會順便學第4點。
5、文本處理命令，sort , tr , cut, paste, uniq, tee等，必學，也是結合第3點時一並學習的。
6、資料庫，首選mysql，別問我為什麼不學sqlserver和oracle，因為linux用得最多絕對是mysql，增刪改查必學，特別要學熟查，其它方面可能不太需要，因為運維人員使用最多還是查，哪些優化和開發語句不會讓你弄的。
7、防火牆，不學不行，防火牆也算是個難點，說難不難，說易不易，最重要弄懂規則，如果學過CCNA的朋友可能會比較好學，因為iptables也有NAT表，原理是一樣的，而FILTER表用得最多，反正不學就肯定不合格。
8、監控工具，十分十分重要，我個人建議，最好學這3個，cacti，nagios，zibbix，企業用得最多應該是nagios和 zibbix，反正都學吧，但nagios會有點難，因為會涉及到用腳本寫自動監控，那個地方很難。
❼ python 怎麼合並多行為一行
#readdatafromfile
withopen("data_src.txt",'rt')assrc:
data=[ln.strip()forlninsrc]
#','join
withopen("data_sto.txt",'wt')assto:
sto.write(','.join(list(set(data))))
python 中 set 是 「unordered collection of unique elements」 可以自動實現剔除重復數據。
❽ python編程的題目，應該怎麼做啊謝謝了！問題描述如下。
用字典統計每個字元出現的次數