私は、学生がネットワークトラフィックを使用して国のIPv6グラフに大学を描くという記事に出会いました。[画像]

あなたの目標は伝えるのは簡単ですが、実装するのは難しいです。描画 CPUグラフ上（これは1Dグラフ上で読み取ることができるいくつかの単語の一つであるように）テキストメールを。

次のようになります。

資格についてもう少し詳しく説明します。

• コードはクロスプラットフォームである必要はありません（そのため、未知の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（最大負荷）から~（非常に軽い負荷）までの1秒間のアクティビティに対応します。プログラムは時間同期ループで実行されるため、複数のインスタンスを実行してより良い結果を得ることができます。

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バイト

モノクロは昨年もそうです。これは、複数のプロセスとシステムコールを使用して、2つのカラー 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からの出力：

すべての出力は、1秒の更新速度で生成されました。重要なバックグラウンドタスクは実行されていませんでしたが、この出力はシングルスレッドのCPUタスクを簡単に打ち負かすことができました。

このコードは、8つのコアがあることを前提としています。変更の数を増やしたり減らしたりするのはかなり簡単です。それは、ポータブル（それが唯一のOS X上でテストされていますが）のLinux / UNIXシステムへ、およびシステムCPU時間からユーザーを区別することができます任意のCPUモニターのための同じ2つの色の出力を生成する必要があります。

基本的に、これは7つのプロセスを分岐することで機能し、各プロセスは1秒のスリープ、ユーザーモードでのスピン、またはカーネルのスピンを選択します。カーネルモードでのスピンは、からの大量のデータをリクエストすることで実現されます/dev/urandom。これにより、ドライバー/dev/urandomは多くの「システム」CPUサイクルを費やすことになります。

編集[07/21]：のfork()代わりに使用することにより大幅に短縮されましたmultiprocessing.Process（/dev/urandomとにかく* NIXシステムでのみ動作するため、移植性は低下しません）。ただし、プログラムはバックグラウンドタスクを生成するようになりました。killall PythonCPUイーターを取り除くために（または同様の）作業が必要になる場合があります。

私はさらにいくつかの手紙を実装することに抵抗することができませんでした。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);}}}

このコードは、クフ王の大ピラミッドとほぼ同じくらい移植性があります。ごめんなさい から返される値mach_absolute_time()はハードウェアに依存しますが、私のマシンでは、値はナノ秒ごとに約1回増加します。

結果は次のとおりです。

プロセッサには2つのコアがあるため、2つのグラフがあります。プロセスはを呼び出すたびにコアを切り替える傾向があるため、最大CPU負荷を約90％に設定しますusleep()。100％の負荷では、プロセスは1つのコアにチェーンされ、結果は判読できません（たとえば、これを参照）

ルビー、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プロセスの先頭にを付けて特定のコアに固定する必要がある場合があります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、Intel Pentium 4 3.0Ghz、180 166 145 141 138バイト

で呼び出しtaskset -c 0 python cpu_graph_drawer.pyます。

taskset 1つの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時間を制御します。

インテルi3 4130Tでこれを実行しましたが、これはかなり新しいプロセッサーです。ただし、実際に使用するよりも多いまたは少ないCPU時間を使用している場合は、走行距離が異なる場合があります。遅延ループでシフト量を試してみてください。

私のプログラムは素晴らしい：

• 主にクロスプラットフォームであり、* nixを少しいじるだけで動作するはずです。
• 質問を打ち負かす
• 素晴らしいエンドゲームプレイ

数回試した後、次のようなグラフを作成しました。