अपने CPU के साथ ड्रा करें

Question

मुझे एक लेख आया है जिसमें छात्रों ने देश के IPv6 ग्राफ पर अपने विश्वविद्यालय को आकर्षित करने के लिए नेटवर्क ट्रैफ़िक का उपयोग किया है । [छवि]

आपका लक्ष्य बताना आसान है, लेकिन लागू करना कठिन है। पाठ मेल (जैसा कि यह कुछ शब्दों में से एक है जिसे 1 डी ग्राफ पर पढ़ा जा सकता है) को सीपीयू ग्राफ पर ड्रा करें।

यह कुछ इस तरह दिखना चाहिए:

योग्य होने पर थोड़ा और विस्तृत:

• कोड को क्रॉस-प्लेटफ़ॉर्म होने की आवश्यकता नहीं है (ताकि आपको निपटने के लिए अज्ञात एपीआई की आवश्यकता नहीं होगी)।
• आप इसे किसी भी सामान्य सीपीयू उपयोग उपयोगिता में कैप्चर कर सकते हैं जो आपके पास है।
• एक अलग मशीन पर ग्राफ थोड़ा खराब लगता है: मुझे इस बार आप पर भरोसा है।
• आधार CPU उपयोग% निरंतर होना चाहिए, इसलिए यदि आप एक यादृच्छिक तरंग उत्पन्न करते हैं और कुछ ऐसा हाइलाइट करते हैं जो मेल शब्द की तरह दिखता है, तो यह स्पष्ट रूप से धोखा है।
• आप उपयोग करने के लिए अधिकतम भार चुन सकते हैं, लेकिन इसे स्पष्ट रूप से देखने के लिए पर्याप्त पर्याप्त होना चाहिए।
• आपको उदाहरण की रैखिकता का पालन करना चाहिए। (एम के लिए यह इस तरह दिखता है: बेस%, फिर अचानक अधिकतम तक बढ़ जाना, धीरे-धीरे कम% तक गिरना, अधिकतम तक वापस बढ़ना और फिर से बेस% तक अचानक गिरना।)
• यदि यह अपठनीय है, तो मतदाता सभी को नोटिस करेंगे।

मानक खामियां लागू होती हैं। चित्र भी पोस्ट करें!

Comments

मुझे अब बंद वोट का कोई कारण नहीं दिख रहा है। मैं व्यक्तिगत रूप से यह एक मजेदार चुनौती है, एक छोटे से सिस्टम विशिष्ट के बावजूद।

— seequ

कोड गोल्फ के साथ मुझे जो समस्या दिखाई दे रही है, वह यह निर्धारित करने के लिए है कि कैसे पठनीय पर्याप्त है। यदि आप उस उद्देश्य को निर्दिष्ट करने के तरीके के बारे में सोच सकते हैं, तो इससे चुनौती में सुधार होगा, लेकिन यह वास्तव में एक अच्छा विचार है!

— मार्टिन एंडर

यह वास्तव में आपकी तस्वीर के समान ही है, लेकिन मैं आपको गारंटी देता हूं कि यदि आप इसे शब्दों में नहीं रखते हैं, तो लोग बहुत ही उदारतापूर्वक "ड्रा मेल" की व्याख्या करेंगे।

— मार्टिन एंडर

+1, यह इतना बेतुका है कि मैंने लगभग खुद को मौत के मुंह में डाल लिया ... "यह पागलपन है ..." "पागलपन .. यह CODEGOLF है !!!"

— vaxquis

यह एक friggin है भयानक सवाल। काश मैं भाग लेने के लिए पर्याप्त स्मार्ट था। यह वास्तव में मायने नहीं रखता है, मैं अन्य लोगों द्वारा रचनात्मक समाधानों में रुचि रखता हूं: पी

— क्रिस क्रेफ़िस

Answer 1

अजगर, 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(अधिकतम भार) से ~(बहुत हल्का भार) तक गतिविधि के एक सेकंड से मेल खाता है । कार्यक्रम एक समय-सिंक्रनाइज़ किए गए लूप पर चलता है, इसलिए आप अच्छे परिणामों के लिए कई उदाहरण चला सकते हैं।

मैंने OS X पर Intel Core i7 के साथ 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

Answer 2

पायथन, 358 281 268 221 194 बाइट्स

मोनोक्रोम तो पिछले साल है। यह दो रंग सीपीयू रेखांकन प्राप्त करने के लिए कई प्रक्रियाओं और syscalls का उपयोग करता है !

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 कोर हैं। कम / अधिक के लिए संशोधित करना बहुत आसान होना चाहिए। यह लिनक्स / यूनिक्स प्रणालियों के लिए पोर्टेबल है (हालांकि यह केवल ओएस एक्स पर परीक्षण किया गया है), और किसी भी सीपीयू मॉनिटर के लिए एक ही दो-रंग का उत्पादन करना चाहिए जो उपयोगकर्ता को सिस्टम सीपीयू समय से अलग कर सकता है।

अनिवार्य रूप से, यह सात प्रक्रियाओं को बंद करके काम करता है, जिनमें से प्रत्येक 1 सेकंड की नींद, खरपतवार में कताई, या कर्नेल को कताई करना चुनता है। कर्नेल मोड में कताई से डेटा के बड़े ग्लोब का अनुरोध करके प्राप्त किया जाता है /dev/urandom, जो ड्राइवर /dev/urandomको "सिस्टम" सीपीयू चक्रों का एक बहुत खर्च करने के लिए मजबूर करता है।

EDITED [07/21]: के fork()बजाय का उपयोग करके काफी कम multiprocessing.Process( /dev/urandomकेवल * NIX सिस्टम पर काम करता है, इसलिए यह पोर्टेबिलिटी कम नहीं करता है)। हालांकि ध्यान दें कि कार्यक्रम अब पृष्ठभूमि कार्यों को जन्म देता है; killall Pythonसीपीयू खाने वालों से छुटकारा पाने के लिए आपको (या समान) हो सकता है।

---

मैं कुछ और अक्षरों को लागू करने का विरोध नहीं कर सका। मुझे 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)

Comments

+1 को 2 रंगों का उपयोग करके अक्षरों को अधिक परिभाषा देने के लिए

— DustinDavis

और टेबल-संचालित पत्र निर्माण के लिए +1

— ग्रीनएजजेड

ए वास्तव में 4 थ्रेड्स के साथ ठीक से (एक छेद के साथ) प्रदान किया जा सकता है। हालांकि संयोग करने के लिए कुछ सीपीयू मॉनिटर रंगों को सेट करना होगा।

— रसलान

@Ruslan: आप किस सीपीयू मॉनिटर के बारे में सोच रहे हैं? मेरा मॉनिटर प्रत्येक बिंदु पर 0 <= सिस्टम <= उपयोगकर्ता <= 100 के साथ केवल एक समग्र ग्राफ दिखाता है (जो "छेद" असंभव AFAIK करता है)।

— nnonneo

@nneonneo मेरा मतलब है कि आप के समान मॉनिटर हैं। देखिये ये तस्वीर । यहां अगर हम नीले को हरे और लाल और बैंगनी से सफेद में बदलते हैं, तो हमें छेद के साथ एक अच्छा "ए" मिलेगा।

— रुस्लान

Answer 3

सी (इंटेल कोर डुओ + ओएस एक्स / डार्विन), 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()हार्डवेयर-निर्भर होते हैं, लेकिन मेरी मशीन पर नैनोसेकंड के बारे में एक बार मूल्य वृद्धि होती है।

यहाँ परिणाम है:

दो ग्राफ़ हैं क्योंकि प्रोसेसर में दो कोर हैं। मैंने अधिकतम CPU लोड को लगभग 90% पर सेट किया है क्योंकि जब भी मैं कॉल करता हूं तो प्रक्रिया कोर के बीच स्विच करने के लिए उत्तरदायी होती है usleep()। 100% लोड के साथ, प्रक्रिया को एक कोर तक जंजीर किया जाता है और परिणाम गैरकानूनी होते हैं ( उदाहरण के लिए देखें )

Comments

बहुत बढ़िया! यह बहुत दिलचस्प लग रहा है। क्या आप कृपया कोड की थोड़ी व्याख्या कर सकते हैं? :)

— डूसिए

मैं ब्रेसिज़ देखता हूँ। छोरों के लिए ब्रेसिज़ क्यों हैं? आप लूप के आखिरी ब्लॉक के लिए दूसरे में usleep रख सकते हैं। मुझे लगता है कि आप थोड़ा और आसानी से नीचे गोल्फ कर सकते हैं।

— बेबे

क्या आप uint64_tनिम्नलिखित forलूप के हेडर में वेरिएबल्स की घोषणा और प्रारंभिककरण को नहीं डाल सकते हैं ?

— जॉय

+1: "यह कोड चेप्स के महान पिरामिड के रूप में पोर्टेबल है"

— Uwe Keim

@ नहीं, किसी ब्लॉक की शुरुआत में सी चर घोषित किया जाना चाहिए। इसे के प्रांरभिक ब्लॉक में डालने से त्रुटि आएगी। बेशक यह केवल <C99

— bebe

Answer 4

रूबी, 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}

यह सब अब तक छोटा नहीं है, लेकिन मेरी राय में आउटपुट अच्छा है, इसलिए मुझे लगा कि मैं इसे वैसे भी पोस्ट करूंगा। अधिकांश अन्य समाधानों की तरह, आपको रूबी प्रक्रिया को एक निश्चित कोर में पिन करना पड़ सकता है, जिसके साथ इसे उपसर्ग कर सकते हैं taskset -c $core।

कोड एक निश्चित समय के लिए कताई / नींद का एक सरल संयोजन है, जो इसे कुछ हद तक पोर्टेबल बनाना चाहिए । स्पिन / स्लीप टाइम के अनुपात को अलग करके स्मूथ ग्रेडिएंट बनाए जाते हैं।

सीपीयू नमूना आवृत्ति को कम करने से किनारों को थोड़ा बेहतर दिखता है:

वर्णमाला में कुछ और अक्षर जोड़कर ( 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 

Comments

अधिक शब्दों में विस्तार के लिए +1!

— बजे क्रिस क्रेफ़िस

आप "एल्यूमीनियम" शब्द बना सकते थे।

— ओलिवर डॉटरटी-लॉन्ग

@ ऑलिवरडॉगर्टी-लॉन्ग एल्युमिनियम *

— टक्सक्राफ्टिंग

@ T @xCräftîñg एल्युमिनियम एक वैरिएंट स्पेलिंग है जिसमें एक अतिरिक्त अक्षर होता है, और सबसे लंबा शब्द है जो मैं उस काम के बारे में सोच सकता हूं।

— ओलिवर डॉटरटी-लॉन्ग

Answer 5

पायथन, इंटेल पेंटियम 4 3.0Ghz पर, 180 166 145 141 138 बाइट्स

के साथ बुलाओ taskset -c 0 python cpu_graph_drawer.py।

taskset केवल एक सीपीयू / कोर (मेरे मामले में हाइपरथ्रेडिंग) का उपयोग करने के लिए प्रक्रिया को प्रतिबंधित करने की आवश्यकता है।

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)

परिणाम इतना बढ़िया नहीं है।

Comments

मैं एक सीपीयू की निगरानी के साथ यह देखने के लिए कि घटता smoothen नहीं है हमें खुशी होगी ...

— स्ज़बोल्क्स

मुझे भी, लेकिन मुझे ऐसा महसूस नहीं हो रहा है कि मैं एक कॉंकी सीपीयू-उपयोग ग्राफ लिख gnome-system-monitorरहा हूं और केवल एक चीज है जिसे मैं जानता हूं। कोई विकल्प मिला जो LMDE दालचीनी पर चलेगा?

— user80551

"स्टैक्ड एरिया चार्ट के रूप में सीपीयू ड्रा करें" को सक्षम करें, और सभी रंगों को काले रंग में सेट करें।

— तेजस काले

@TejasKale अभी भी लाइनें घुमावदार होंगी।

— user80551

FYI करें: आप a=[...]+[(.1,.2)]*10इसके बजाय का उपयोग करके आकर्षण का एक गुच्छा गोल्फ कर सकते हैं .extend।

— nnonneo 18

Answer 6

जावा 8, 482 अक्षर

स्ट्रिंग में प्रत्येक वर्ण का अर्थ है थ्रेड्स की संख्या, जिसका उपयोग किया जाएगा। इंटेल कोर 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();
}}}

Comments

वहाँ कम से कम वहाँ साइन है कि HTML के रूप में व्याख्या की और स्वरूपण गड़बड़ कर दी है।

— डेविड कॉनराड

@ValekHalfHeart अगली दो पंक्तियों को इसे समझाना चाहिए। निष्पादक एक थ्रेड (एसिंक्रोनस टास्क मैनेजर) है जो कार्य को अंजाम देता है। इसे बनाने के बाद, मुख्य धागा 1.5 के लिए प्रतीक्षा करता है और फिर सभी कार्यों को बाधित करता है।

— पीटी राइटर

केवल ग्रहण को खोलकर, मेरे सीपीयू ग्राफ ने "सिंपल मेल ट्रांसफर प्रोटोकॉल" लिखा।

— लोल्सक

Answer 7

सी, 78 बाइट्स

आपने कभी नहीं कहा कि हम उपयोगकर्ता इनपुट को स्वीकार नहीं कर सकते, sooo ..

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

यह कार्यक्रम मानक से पढ़ता है और हर बार जब यह एक चरित्र को पढ़ता है तो यह लूप के लिए बर्बाद होने वाले सीपीयू को निष्पादित करता है, फिर उसे फिर से कॉल करता है। आप विभिन्न गति पर दर्ज कुंजी को स्पैम करके सीपीयू के समय का उपयोग करते हैं।

मैंने इसे इंटेल i3 4130T पर चलाया, जो एक नया प्रोसेसर है। लेकिन आपका माइलेज अलग-अलग हो सकता है, यदि आपके द्वारा अवलोकन करने के लिए अधिक या कम सीपीयू समय का उपयोग करना व्यावहारिक है, तो विलंब लूप में शिफ्ट राशि के साथ खेलने का प्रयास करें।

मेरा कार्यक्रम बहुत बढ़िया है क्योंकि यह:

• ज्यादातर क्रॉस प्लेटफॉर्म है, इसे किसी भी * निक्स पर बहुत कम फ़िडलिंग के साथ काम करना चाहिए
• प्रश्न को हरा देता है
• महान एंडगेम खेल

कुछ कोशिशों के बाद मैंने एक ग्राफ तैयार किया जो इस तरह दिखता है:

Comments

यह कार्यस्थल के साथ एक सीपीयू कोर तक सीमित रखने में मदद करता है, a.la. taskset -c 1 [file]

— जुग

मुझे समस्या आवश्यकताओं में कुछ भी दिखाई नहीं देता है, जो कहता है कि हमारे सबमिशन को इस तरह लागू किया जाएगाyes | [program]

— जुग

मानक खामियां ... भी meta.codegolf.stackexchange.com/a/1085/6699 के अंतर्गत आती है ।

— nnonneo

"महान एंडगेम प्ले" ने मुझे योग्य बना दिया। +1

— क्रिस्टोफ़

यह जवाब बहुत अच्छा है, हालांकि, कमियां एक्सडी को धिक्कार है!

— मैजिक ऑक्टोपस Urn