රටේ IPv6 ප්‍රස්ථාරය මත තම විශ්ව විද්‍යාලය ඇඳීම සඳහා සිසුන් ජාල ගමනාගමනය භාවිතා කළ ලිපියක් මට හමු විය . [රූප]

ඔබේ ඉලක්කය කීමට සරල නමුත් ක්‍රියාත්මක කිරීමට අපහසුය. CPU ප්‍රස්ථාරයේ MAIL (1D ප්‍රස්ථාරයක කියවිය හැකි වචන කිහිපයෙන් එකක් වන බැවින්) පෙළ අඳින්න .

එය මේ වගේ දෙයක් විය යුතුයි:

සුදුසුකම් ඇති දේ පිළිබඳව තව ටිකක් විස්තර කිරීම:

• කේතය හරස් වේදිකාවක් වීමට අවශ්‍ය නැත (එබැවින් ඔබට ගනුදෙනු කිරීමට නොදන්නා API අවශ්‍ය නොවේ).
• ඔබ සතුව ඇති ඕනෑම සාමාන්‍ය CPU භාවිත උපයෝගීතාවයකින් එය අල්ලා ගත හැකිය.
• ප්‍රස්ථාරය වෙනත් යන්ත්‍රයක තරමක් නරක ලෙස පෙනේ: මේ වතාවේ මම ඔබව විශ්වාස කරමි.
• මූලික CPU භාවිතය% අඛණ්ඩව පැවතිය යුතුය, එබැවින් ඔබ අහඹු තරංගයක් ජනනය කර MAIL යන වචනයට සමාන යමක් ඉස්මතු කරන්නේ නම්, එය පැහැදිලිවම වංචාවකි.
• ඔබට භාවිතා කිරීමට උපරිම බර තෝරා ගත හැකිය, නමුත් එය පැහැදිලිව දැකීමට ප්‍රමාණවත් විය යුතුය.
• ඔබ උදාහරණයේ රේඛීයභාවය අනුගමනය කළ යුතුය. .
• එය කියවිය නොහැකි නම්, ඡන්දදායකයින් සියල්ලට පසුව එය දකිනු ඇත.

සම්මත අඩුලුහුඩු අදාළ වේ. පින්තූර ද පළ කරන්න!

පයිතන්, 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 හි Python 2.7.6 භාවිතා කළේ Intel Core i7 සමඟයි, නමුත් එය වෙනත් පරිගණකවල සුළු වෙනස් කිරීම් සහිතව ක්‍රියා කළ යුතුය (සකස් කරන්න 0.001). පහත රූපරාමුව සැලකිය යුතු පසුබිම් ක්‍රියාකාරකම් සහිතව ගෙන ඇත.

යාවත්කාලීන කිරීම - වඩා පැහැදිලි ප්‍රස්ථාරයක් time()/10සහ අඩු යාවත්කාලීන සංඛ්‍යාතයක් නිපදවීමට මට හැකි විය :

අවසාන වශයෙන්, මෙන්න වඩා ගොල්ෆ් කළ අනුවාදයක් ( බයිට් 123 ) සහ එහි ප්‍රති result ලය :

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

පයිතන්, 358 281 268 221 194 බයිට්

ඊට හේතුවක් වේ එසේ පසුගිය වසරේ. වර්ණ CPU ප්‍රස්ථාර දෙකක් සාක්ෂාත් කර ගැනීම සඳහා මෙය බහු ක්‍රියාදාමයන් සහ 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):

මෙනුමීටර වලින් ප්‍රතිදානය:

සියලුම ප්‍රතිදානයන් 1s යාවත්කාලීන වේගයකින් ජනනය කරන ලදි. මෙම ප්‍රතිදානය ඕනෑම තනි නූල් සහිත CPU කාර්යයක් පහසුවෙන්ම පරාජය කළද සැලකිය යුතු පසුබිම් කාර්යයන් ක්‍රියාත්මක නොවීය.

මෙම කේතය ඔබට මධ්‍ය 8 ක් ඇතැයි උපකල්පනය කරයි. අඩු / වැඩි ගණනක් සඳහා වෙනස් කිරීම තරමක් පහසු විය යුතුය. එය ලිනක්ස් / යුනික්ස් පද්ධති වෙත අතේ ගෙන යා හැකි ය (එය OS X මත පමණක් අත්හදා බලා ඇතත්), සහ පද්ධති CPU වේලාවෙන් පරිශීලකයා වෙන්කර හඳුනාගත හැකි ඕනෑම CPU මොනිටරයක් ​​සඳහා එකම වර්ණ දෙකේ නිමැවුමක් නිපදවිය යුතුය.

අත්යවශ්යයෙන්ම, මෙය ක්රියාවලීන් හතක් අත්හැර දැමීමෙන් සිදු වේ, ඒ සෑම එකක්ම තත්පර 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)

සී (ඉන්ටෙල් කෝර් ඩුඕ + ඕඑස් එක්ස් / ඩාවින්), බයිට් 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()ලැබෙන අගයන් දෘඩාංග මත රඳා පවතී, නමුත් මගේ යන්ත්‍රයේ අගය නැනෝ තත්පරයකට එක් වරක් පමණ වැඩිවේ.

ප්‍රති result ලය මෙන්න:

ප්‍රොසෙසරයට හර දෙකක් ඇති බැවින් ප්‍රස්ථාර දෙකක් තිබේ. මම උපරිම CPU භාරය 90% ක් දක්වා සකසා ඇත්තේ මා අමතන සෑම විටම හරය අතර මාරු වීමට ක්‍රියාවලිය බැඳී ඇති බැවිනි usleep(). 100% ක බරක් සමඟ, ක්‍රියාවලිය එක් හරයකට බැඳ ඇති අතර ප්‍රති results ල අවිනිශ්චිතය ( මෙය බලන්න, උදාහරණයක් ලෙස )

රූබි, අක්ෂර 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.

මෙම කේතය වන යම් නිශ්චිත ප්රමාණයක් සඳහා භ්රමණය / නිදා සරල එකතුවකි යුතු එය තරමක් එහා මෙහා ගෙන යා හැකි බවට. සුමට ප්‍රමිතීන් නිර්මාණය වන්නේ භ්‍රමණය / නින්දේ වේලාව වෙනස් කිරීමෙනි.

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 

පයිතන්, ඉන්ටෙල් පෙන්ටියම් 4 3.0Ghz, 180 166 145 141 138 බයිට්

සමඟ අමතන්න taskset -c 0 python cpu_graph_drawer.py.

taskset එක් CPU / core එකක් පමණක් භාවිතා කිරීම සඳහා ක්‍රියාවලිය සීමා කිරීම සඳහා අවශ්‍ය වේ (මගේ නඩුවේ අධි තෙරපුම.)

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)

ප්‍රති ult ලය එතරම් විශිෂ්ට නොවේ.

ජාවා 8, අක්ෂර 482

සංගීතයේ සෑම අක්ෂරයකම අර්ථය වන්නේ නූල් ගණනකි, එය භාවිතා කරනු ඇත. ඉන්ටෙල් කෝර් අයි 3 (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();
}}}

සී, බයිට් 78 යි

පරිශීලක ආදානය අපට පිළිගත නොහැකි බව ඔබ කිසි විටෙකත් පවසා නැත.

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

මෙම වැඩසටහන සම්මතයෙන් කියවන අතර එය චරිතයක් කියවන සෑම අවස්ථාවකම එය ලූප සඳහා අනවශ්‍ය CPU නාස්තියක් සිදු කරයි, පසුව නැවත ප්‍රධාන ලෙස අමතයි. ඇතුල් කිරීමේ යතුර විවිධ වේගයකින් අයාචිත තැපැල් කිරීමෙන් ඔබ භාවිතා කරන CPU කාලය පාලනය කරයි.

මම මෙය ධාවනය කළේ ඉන්ටෙල් අයි 3 4130 ටී, එය නව ප්‍රොසෙසරයක්. නමුත් ඔබගේ සැතපුම් ගණන වෙනස් විය හැකිය, එය ඔබට නිරීක්ෂණය කිරීමට ප්‍රායෝගිකව වඩා වැඩි හෝ අඩු CPU කාලයක් භාවිතා කරන්නේ නම්, ප්‍රමාද පුඩුවේ මාරුවීමේ මුදල සමඟ සෙල්ලම් කිරීමට උත්සාහ කරන්න.

මගේ වැඩසටහන නියමයි:

• බොහෝ දුරට හරස් වේදිකාවක් වන අතර, එය ඕනෑම * නික්ස් එකක ඉතා සුළු විකාරයකින් ක්‍රියා කළ යුතුය
• ප්‍රශ්නය පරාජය කරයි
• නියම එන්ඩ් ගේම් සෙල්ලමක්

උත්සාහයන් කිහිපයකින් පසු මම මේ වගේ ප්‍රස්ථාරයක් නිෂ්පාදනය කළා: