我见过一篇文章，其中学生使用网络流量在该国的IPv6图上绘制了他们的大学。[图片]

您的目标很简单，但是很难实现。在CPU图上绘制文本MAIL（因为它是一维图上可以读取的少数几个单词之一）。

它看起来应该像这样：

详细说明符合条件的内容：

• 该代码不需要跨平台（因此您不需要未知的API来处理）。
• 您可以在拥有的任何常规CPU使用率实用程序中捕获它。
• 该图在另一台计算机上看起来更糟：这次我相信您。
• 基本CPU使用率百分比必须是连续的，因此，如果生成随机波并突出显示类似于MAIL的内容，那显然是作弊行为。
• 您可以选择要使用的最大负载，但是必须足够大才能清楚地看到它。
• 您必须遵循示例的线性关系。（对于M来说，它是这样的：基本百分比，然后突然增加到指定的最大值，逐渐下降到较低的百分比，再回到最大值，然后突然下降到基本百分比。）
• 如果这难以理解，那么选民终将注意到。

有标准漏洞。也发布图片！

Python，143

from time import*
while 1:
 sleep((ord('00012345654321000~~~D:6300036:D~~~000~~~000DDDD~~~~~'[int(time())%52])-48)*0.001);x=10**5
 while x:x-=1

字符串的每个字符对应于活动的一秒，从ASCII字符0（最大负载）到~（非常轻负载）。该程序在时间同步循环上运行，因此您可以运行多个实例以获得更好的结果。

我在带有Intel Core i7的OS X上使用了Python 2.7.6，但是它应该可以在其他计算机上进行一些调整（调整0.001）。下面的屏幕截图是在进行大量背景活动时拍摄的。

更新-我能够以time()/10更低的更新频率生成更清晰的图形：

最后，这是高尔夫版本（123字节）及其结果：

from time import*
while 1:
 sleep((ord('002464200~~A5005A~~00~~00DDD~~'[int(time()/2)%30])-48)*0.001);x=10**5
 while x:x-=1

Python中，358个 281 268 221 194字节

去年是如此。这使用多个进程和系统调用来实现两个彩色 CPU图形！

import os,time
A='%-99o'%int('t12q2lxqkap48euoej9429cstbnazl63ubyryteo49u',36)
for i in'0123456':
 t=os.fork()
 while t<1:T=int(time.time())%50;(time.sleep,(id,os.urandom)[i<A[T+49]])[i<A[T]](1)

活动监视器（OS X 10.9）的输出：

MenuMeters的输出：

所有输出均以1s的更新速度生成。没有重要的后台任务在运行，尽管此输出很容易击败任何单线程CPU任务。

此代码假定您具有8个核心。修改更少/更多应该很容易。它可以移植到Linux / UNIX系统（尽管它仅在OS X上进行了测试），并且应该为可以将用户与系统CPU时间区分开的任何CPU监视器产生相同的双色输出。

从本质上讲，这可以通过启动七个进程来实现，每个进程将选择花费1秒钟的睡眠时间，以用户模式旋转或旋转内核。内核模式下的旋转是通过向请求大量数据来实现的/dev/urandom，这迫使驱动程序支持/dev/urandom花费大量的“系统” CPU周期。

编辑[07/21]：通过使用fork()代替大大缩短了multiprocessing.Process（/dev/urandom反正只能在* NIX系统上使用，因此不会降低可移植性）。但是请注意，该程序现在会产生后台任务。您可能killall Python（或类似）必须摆脱CPU占用者的困扰。

我忍不住再写几封信。我有16个字母，外加一些符号：

完整的字母是“ ACDFHILMNOPTUVWY”，带有符号“ ._〜/ \”。可能还有更多可以表示的字符。

多余字母的完全取消注释的代码：

from time import*
from multiprocessing import*

chars6 = {
'A': ('123456654321',
      '000123321000'),
'C': ('344556666666',
      '321110000000'),
'D': ('666666655443',
      '000000011123'),
'F': ('66666666666666',
      '00002222244444'),
'H': ('666664444466666',
      '000002222200000'),
'I': ('66666',
      '00000'),
'L': ('666662222222',
      '000000000000'),
'M': ('6665544334455666',
      '0004321001234000'),
'N': ('66665544336666',
      '00003322110000'),
'O': ('3445556666555443',
      '3221110000111223'),
'P': ('666666666555',
      '000003333444'),
'T': ('777776666677777',
      '444440000044444'),
'U': ('6666322236666',
      '4211000001124'),
'V': ('66654322345666',
      '33321000012333'),
'W': ('66542466424566',
      '43210133101234'),
'Y': ('66665433456666',
      '44333000033344'),
'_': ('1111111111',
      '0000000000'),
' ': ('000',
      '000'),
'.': ('12221',
      '10001'),
'~': ('44445544334444',
      '11223322112233'),
'/': ('2234566',
      '0012344'),
'\\': ('6654322',
       '4432100'),
}

s = 'ANCHOVY '
A = '000'.join(chars6[t][0] for t in s)
B = '000'.join(chars6[t][1] for t in s)

t=time()
f=open('/dev/urandom')
def F(n):
 while 1:T=int(time()-t)%len(A);[sleep,[].count,lambda x:f.read(4**9)][(n<int(A[T]))+(n<int(B[T]))](1)
for i in range(7):Process(target=F,args=(i,)).start()
F(7)

C（Intel Core Duo + OS X / Darwin），248个字节

#include <unistd.h>
#include <mach/mach_time.h>
#define M mach_absolute_time()
main(){char*s="JJJIHGFGHIJJJ@BDFHJJJHFDB@JJJJ@JJJJBBBBBBB";uint64_t i,t,y=1;for(;*s;s++){
for(i=40;i;i--){for(t=M+(*s&15)*9090909;t>M;)y*=7;usleep((11-(*s&15))*9091);}}}

此代码与Cheops大金字塔一样可移植。对于那个很抱歉。从中返回的值mach_absolute_time()取决于硬件，但是在我的机器上，该值大约每纳秒增加一次。

结果如下：

有两个图形，因为处理器具有两个核心。我将最大CPU负载设置为大约90％，因为每当我调用时，该进程就可以在内核之间进行切换usleep()。在负载为100％的情况下，该过程被链接到一个核心，并且结果难以辨认（例如，参见此内容）

Ruby，150个字符

a=(0..15).map{|i|[0.9-3*i*=0.02,i]}
[9,*a[0,11],*(z=a.reverse)[5,11],11,*z,*a,2,11,6,*[0.2]*9].map{|x,y|c=Time.now
1until Time.now-c>x/3
sleep y||x%3}

到目前为止，这还不算很短，但是我认为输出结果还不错，所以我想还是应该发布此内容。与大多数其他解决方案一样，您可能必须通过在Ruby前缀上将Ruby进程固定到某个核心taskset -c $core。

该代码是旋转/休眠一定时间的简单组合，这应该使其具有一定的可移植性。通过改变旋转/睡眠时间的比率可以创建平滑的渐变。

降低CPU采样频率会使边缘看起来更好一些：

通过在字母表中添加更多字母（AILMNUVW有些可以识别），我们还可以写一些其他单词：

这些图片是使用以下代码生成的：

def gradient num_samples, direction, base = 0.3, increment = 0.02, scale = 1
    range = [*0..num_samples]

    samples = case direction
        when :up then range.reverse
        when :down then range
        when :updown then range.reverse + range
        when :downup then range + range.reverse
    end

    samples.map{|i|
        i *= increment
        [base - scale * i, i]
    }
end

# letters are defined as a series of pairs of (spin-time, sleep-time)
# with the time in seconds
THIN_A = gradient(15, :updown, 0.2, 0.2/15)
A = gradient(15, :updown)
I = 2,0
L = 1.5,0, [[0.1,0.2]]*9
M = 2,0, gradient(9, :downup), 2,0
N = 1,0, gradient(9, :down), 2,0
U = 1,0, gradient(9, :downup, 0.1, 0.03, 0.1), 1,0
V = 0.5,0, gradient(12, :downup, 0.25, 0.02), 0.5,0
W = 0.5,0, [gradient(12, :downup, 0.25, 0.02)]*2, 0.5,0

[A,I,L,M,N,U,V,W].map{|i|
    # add 2 second pause after each letter
    i + [0,2]
}.flatten.each_slice(2){|x,y|
    # spin, then sleep
    c = Time.now
    1 until Time.now-c > x
    sleep y
}

可以用已实现的字母写的单词可以找到

grep -E '^[aijlmnuvw]+$' /usr/share/dict/words 

Python中，英特尔奔腾4 3.0GHz的，180个166 145 141 138字节

致电taskset -c 0 python cpu_graph_drawer.py。

taskset 需要将进程限制为仅使用一个CPU /内核（在我的情况下为超线程）。

from time import*;c=clock
a=[(3,.8),(3,5),(4,5),(1.3,5),(1.3,0)]
a.extend([(.1,.2)]*10)
for x,y in a:
    t=c()
    while c()-t<x:pass
    sleep(y)

结果不是那么好。

Java 8，482个字符

字符串中的每个字符表示将要利用的线程数。在Intel Core i3（2核/ 4线程）上拍摄的图像。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Mail{
public static void main(String[] args) throws InterruptedException{
Thread.sleep(15000);
for(char c:"123432234321000012343210000444000044441111111".toCharArray()){
ExecutorService executorService = Executors.newScheduledThreadPool(4);
for(int i=1;i<c-48;i++)executorService.execute(()->{while(!Thread.interrupted());});
Thread.sleep(1500);
executorService.shutdownNow();
}}}

编辑：更多高尔夫球版本（322个字符），相同的功能：

import java.util.concurrent.*;
class M{
public static void main(String[]a)throws Exception{
for(int c:"123432234321000012343210000444000044441111111".toCharArray()){
ExecutorService s=Executors.newFixedThreadPool(4);
while(c>48){c--;s.execute(()->{while(!Thread.interrupted());});}
Thread.sleep(1500);
s.shutdownNow();
}}}

C，78个字节

您从未说过我们不能接受用户输入，所以..

#include <unistd.h>
int main(){int x=0;for(;x<1<<26;++x);read(0,&x,1);main();}

该程序从标准读入，每次读取一个字符时，都会执行免费的CPU浪费循环，然后再次调用main。您可以通过以不同的速度向Enter键发送垃圾邮件来控制它使用的CPU时间。

我在Intel i3 4130T上运行了它，这是相当新的处理器。但是您的里程可能会有所不同，如果它使用的CPU时间比实际观察到的时间长或少，请尝试在延迟循环中使用移位量。

我的程序很棒，因为它：

• 主要是跨平台的，在任何* nix上都应该很少摆弄
• 击败问题
• 精彩的残局游戏

经过几次尝试，我生成了一个如下图所示的图形：