Często uruchamiam skrypt lub kwerendę, których uruchomienie zajmuje dużo czasu. Mogę zostawić ten skrypt otwarty i cieszyć się zwlekaniem bez poczucia winy.

A co, jeśli mógłbym napisać skrypt, który wydaje się być jednym z powyższych skryptów dla każdego obserwatora, ale tylko w wyglądzie? Mógłbym umieścić to na ekranie i cieszyć się dniami transmisji na żywo z kotkami, zanim ktokolwiek zda sobie sprawę, że cała ta skomplikowana gra na ekranie nie ma nic wspólnego z moją rzeczywistą pracą.

Twoim wyzwaniem jest napisanie dla mnie tego skryptu (tak, jestem taki leniwy).

Dobrą odpowiedź będzie:

• Spraw, aby na ekranie pojawiło się coś, co wygląda jak skrypt. „Ekran” może być terminalem, przeglądarką itp.
• Bądź dość oryginalny (tak, wszyscy widzieliśmy niekończące się programy paska postępu)
• Przeżyj pobieżne badanie przez osobę techniczną

Zła odpowiedź będzie:

• Zwolnij mnie
• Rehash coś, co wszyscy przekazaliśmy w latach 90-tych

Gwiezdny odpowiedź może:

• Przekrocz jeden ze złych punktów pocisku powyżej ( na przykład )
• Przetrwaj krytyczne badanie
• * sapnie * faktycznie robi coś, co jest przydatne lub pomaga w mojej marnej pracy

Akceptacja będzie oparta na głosach, z premią z rzeczywistych wyników. Właściwie uruchomię te skrypty (Linux Mint 16) w pracy, gdy mój ekran będzie widoczny (spotkania itp.), Aby określić wykrycie. Jeśli ktoś zauważy, że to fałszerstwo, nie masz szans. Jeśli ktoś komentuje, jak ciężko pracuję, +5 bonusów za ciebie.

„Przydatne” w tym przypadku może mieć zastosowanie do dowolnego kodera, ale jeśli szukasz dodatkowego blasku w swoim jabłku związanym z nauczycielem, jestem webdevem z pełnym stosem, który działa w kodzie w przybliżeniu zgodnie z moimi tagami .

Pytanie częściowo zainspirowane tym .

Wyniki

Rozczarowujące, nie dostałem żadnych komentarzy na temat tych wpisów. Wszystkie są niesamowite, więc jesteście zwycięzcami w moim sercu. Jednak Loktar ma najwięcej głosów z dystansu, więc otrzymuje +15 z akceptacji. Gratulacje!

JavaScript

Więc trochę zwariowałem z tym. Zrobiłem to między przerwami od pracy nad moim GUI do śledzenia adresów IP za pomocą Visual Basic.

Możesz uzyskać do niego dostęp, przechodząc do bardzo poważnej domeny, którą dla niego stworzyłem, abyś mógł wyglądać na zajętego w dowolnym miejscu Gui Hackera i rozwidlać się i tworzyć własne z następujących źródeł

• Skrzypce
• CodePen
• github

Zasadniczo, jeśli masz to uruchomione, nikt nie będzie ci przeszkadzał, ponieważ wiedzą, że robisz poważne rzeczy.

var canvas = document.querySelector(".hacker-3d-shiz"),
  ctx = canvas.getContext("2d"),
  canvasBars = document.querySelector(".bars-and-stuff"),
  ctxBars = canvasBars.getContext("2d"),
  outputConsole = document.querySelector(".output-console");

canvas.width = (window.innerWidth / 3) * 2;
canvas.height = window.innerHeight / 3;

canvasBars.width = window.innerWidth / 3;
canvasBars.height = canvas.height;

outputConsole.style.height = (window.innerHeight / 3) * 2 + 'px';
outputConsole.style.top = window.innerHeight / 3 + 'px'


/* Graphics stuff */
function Square(z) {
  this.width = canvas.width / 2;
  this.height = canvas.height;
  z = z || 0;

  this.points = [
    new Point({
      x: (canvas.width / 2) - this.width,
      y: (canvas.height / 2) - this.height,
      z: z
    }),
    new Point({
      x: (canvas.width / 2) + this.width,
      y: (canvas.height / 2) - this.height,
      z: z
    }),
    new Point({
      x: (canvas.width / 2) + this.width,
      y: (canvas.height / 2) + this.height,
      z: z
    }),
    new Point({
      x: (canvas.width / 2) - this.width,
      y: (canvas.height / 2) + this.height,
      z: z
    })
  ];
  this.dist = 0;
}

Square.prototype.update = function() {
  for (var p = 0; p < this.points.length; p++) {
    this.points[p].rotateZ(0.001);
    this.points[p].z -= 3;
    if (this.points[p].z < -300) {
      this.points[p].z = 2700;
    }
    this.points[p].map2D();
  }
}

Square.prototype.render = function() {
  ctx.beginPath();
  ctx.moveTo(this.points[0].xPos, this.points[0].yPos);
  for (var p = 1; p < this.points.length; p++) {
    if (this.points[p].z > -(focal - 50)) {
      ctx.lineTo(this.points[p].xPos, this.points[p].yPos);
    }
  }

  ctx.closePath();
  ctx.stroke();

  this.dist = this.points[this.points.length - 1].z;

};

function Point(pos) {
  this.x = pos.x - canvas.width / 2 || 0;
  this.y = pos.y - canvas.height / 2 || 0;
  this.z = pos.z || 0;

  this.cX = 0;
  this.cY = 0;
  this.cZ = 0;

  this.xPos = 0;
  this.yPos = 0;
  this.map2D();
}

Point.prototype.rotateZ = function(angleZ) {
  var cosZ = Math.cos(angleZ),
    sinZ = Math.sin(angleZ),
    x1 = this.x * cosZ - this.y * sinZ,
    y1 = this.y * cosZ + this.x * sinZ;

  this.x = x1;
  this.y = y1;
}

Point.prototype.map2D = function() {
  var scaleX = focal / (focal + this.z + this.cZ),
    scaleY = focal / (focal + this.z + this.cZ);

  this.xPos = vpx + (this.cX + this.x) * scaleX;
  this.yPos = vpy + (this.cY + this.y) * scaleY;
};

// Init graphics stuff
var squares = [],
  focal = canvas.width / 2,
  vpx = canvas.width / 2,
  vpy = canvas.height / 2,
  barVals = [],
  sineVal = 0;

for (var i = 0; i < 15; i++) {
  squares.push(new Square(-300 + (i * 200)));
}

//ctx.lineWidth = 2;
ctx.strokeStyle = ctxBars.strokeStyle = ctxBars.fillStyle = '#00FF00';

/* fake console stuff */
var commandStart = ['Performing DNS Lookups for',
    'Searching ',
    'Analyzing ',
    'Estimating Approximate Location of ',
    'Compressing ',
    'Requesting Authorization From : ',
    'wget -a -t ',
    'tar -xzf ',
    'Entering Location ',
    'Compilation Started of ',
    'Downloading '
  ],
  commandParts = ['Data Structure',
    'http://wwjd.com?au&2',
    'Texture',
    'TPS Reports',
    ' .... Searching ... ',
    'http://zanb.se/?23&88&far=2',
    'http://ab.ret45-33/?timing=1ww'
  ],
  commandResponses = ['Authorizing ',
    'Authorized...',
    'Access Granted..',
    'Going Deeper....',
    'Compression Complete.',
    'Compilation of Data Structures Complete..',
    'Entering Security Console...',
    'Encryption Unsuccesful Attempting Retry...',
    'Waiting for response...',
    '....Searching...',
    'Calculating Space Requirements '
  ],
  isProcessing = false,
  processTime = 0,
  lastProcess = 0;


function render() {
  ctx.clearRect(0, 0, canvas.width, canvas.height);

  squares.sort(function(a, b) {
    return b.dist - a.dist;
  });
  for (var i = 0, len = squares.length; i < len; i++) {
    squares[i].update();
    squares[i].render();
  }

  ctxBars.clearRect(0, 0, canvasBars.width, canvasBars.height);

  ctxBars.beginPath();
  var y = canvasBars.height / 6;
  ctxBars.moveTo(0, y);

  for (i = 0; i < canvasBars.width; i++) {
    var ran = (Math.random() * 20) - 10;
    if (Math.random() > 0.98) {
      ran = (Math.random() * 50) - 25
    }
    ctxBars.lineTo(i, y + ran);
  }

  ctxBars.stroke();

  for (i = 0; i < canvasBars.width; i += 20) {
    if (!barVals[i]) {
      barVals[i] = {
        val: Math.random() * (canvasBars.height / 2),
        freq: 0.1,
        sineVal: Math.random() * 100
      };
    }

    barVals[i].sineVal += barVals[i].freq;
    barVals[i].val += Math.sin(barVals[i].sineVal * Math.PI / 2) * 5;
    ctxBars.fillRect(i + 5, canvasBars.height, 15, -barVals[i].val);
  }

  requestAnimationFrame(render);
}

function consoleOutput() {
  var textEl = document.createElement('p');

  if (isProcessing) {
    textEl = document.createElement('span');
    textEl.textContent += Math.random() + " ";
    if (Date.now() > lastProcess + processTime) {
      isProcessing = false;
    }
  } else {
    var commandType = ~~(Math.random() * 4);
    switch (commandType) {
      case 0:
        textEl.textContent = commandStart[~~(Math.random() * commandStart.length)] + commandParts[~~(Math.random() * commandParts.length)];
        break;
      case 3:
        isProcessing = true;
        processTime = ~~(Math.random() * 5000);
        lastProcess = Date.now();
      default:
        textEl.textContent = commandResponses[~~(Math.random() * commandResponses.length)];
        break;
    }
  }

  outputConsole.scrollTop = outputConsole.scrollHeight;
  outputConsole.appendChild(textEl);

  if (outputConsole.scrollHeight > window.innerHeight) {
    var removeNodes = outputConsole.querySelectorAll('*');
    for (var n = 0; n < ~~(removeNodes.length / 3); n++) {
      outputConsole.removeChild(removeNodes[n]);
    }
  }

  setTimeout(consoleOutput, ~~(Math.random() * 200));
}

render();
consoleOutput();

window.addEventListener('resize', function() {
  canvas.width = (window.innerWidth / 3) * 2;
  canvas.height = window.innerHeight / 3;

  canvasBars.width = window.innerWidth / 3;
  canvasBars.height = canvas.height;

  outputConsole.style.height = (window.innerHeight / 3) * 2 + 'px';
  outputConsole.style.top = window.innerHeight / 3 + 'px';

  focal = canvas.width / 2;
  vpx = canvas.width / 2;
  vpy = canvas.height / 2;
  ctx.strokeStyle = ctxBars.strokeStyle = ctxBars.fillStyle = '#00FF00';
});

@font-face {
  font-family: 'Source Code Pro';
  font-style: normal;
  font-weight: 400;
  src: local('Source Code Pro'), local('SourceCodePro-Regular'), url(http://themes.googleusercontent.com/static/fonts/sourcecodepro/v4/mrl8jkM18OlOQN8JLgasDxM0YzuT7MdOe03otPbuUS0.woff) format('woff');
}
body {
  font-family: 'Source Code Pro';
  background: #000;
  color: #00FF00;
  margin: 0;
  font-size: 13px;
}
canvas {
  position: absolute;
  top: 0;
  left: 0;
}
.bars-and-stuff {
  left: 66.6%;
}
.output-console {
  position: fixed;
  overflow: hidden;
}
p {
  margin: 0
}

<canvas class='hacker-3d-shiz'></canvas>
<canvas class='bars-and-stuff'></canvas>
<div class="output-console"></div>

Bash / coreutils

Przedstawiamy pierwszy w historii ... emulator kompilacji . Dzięki temu programowi możesz prowadzić epickie bitwy na miecze z krzesłami biurowymi w dowolnym momencie, nawet bez pisania kodu!

#!/bin/bash
collect()
{
    while read line;do
        if [ -d "$line" ];then
            (for i in "$line"/*;do echo $i;done)|sort -R|collect
            echo $line
        elif [[ "$line" == *".h" ]];then
            echo $line
        fi
    done
}

sse="$(awk '/flags/{print;exit}' </proc/cpuinfo|grep -o 'sse\S*'|sed 's/^/-m/'|xargs)"

flags=""
pd="\\"

while true;do
    collect <<< /usr/include|cut -d/ -f4-|
    (
        while read line;do
            if [ "$(dirname "$line")" != "$pd" ];then
                x=$((RANDOM%8-3))
                if [[ "$x" != "-"* ]];then
                    ssef="$(sed 's/\( *\S\S*\)\{'"$x,$x"'\}$//' <<< "$sse")"
                fi
                pd="$(dirname "$line")"
                opt="-O$((RANDOM%4))"
                if [[ "$((RANDOM%2))" == 0 ]];then
                    pipe=-pipe
                fi
                case $((RANDOM%4)) in
                    0) arch=-m32;;
                    1) arch="";;
                    *) arch=-m64;;
                esac
                if [[ "$((RANDOM%3))" == 0 ]];then
                    gnu="-D_GNU_SOURCE=1 -D_REENTRANT -D_POSIX_C_SOURCE=200112L "
                fi
                flags="gcc -w $(xargs -n1 <<< "opt pipe gnu ssef arch"|sort -R|(while read line;do eval echo \$$line;done))"
            fi
            if [ -d "/usr/include/$line" ];then
                echo $flags -shared $(for i in /usr/include/$line/*.h;do cut -d/ -f4- <<< "$i"|sed 's/h$/o/';done) -o "$line"".so"
                sleep $((RANDOM%2+1))
            else
                line=$(sed 's/h$//' <<< "$line")
                echo $flags -c $line"c" -o $line"o"
                sleep 0.$((RANDOM%4))
            fi
        done
    )
done

Wykorzystuje dane z, /usr/includeaby stworzyć realistycznie wyglądający dziennik kompilacji. Byłem zbyt leniwy, by rzucać losowymi ostrzeżeniami, więc jest tylko -wflaga.

Losowa próbka:

gcc -w -m64 -pipe-msse -msse2 -msse3 -O1 -c libiptc / xtcshared.c -o libiptc / xtcshared.o
gcc -w -m64 -pipe-msse-msse2-msse3 -O1 -c libiptc / libip6tc.c -o libiptc / libip6tc.o
gcc -w -m64 -pipe-msse-msse2 -msse3 -O1 -c libiptc / libxtc.c -o libiptc / libxtc.o
gcc -w -m64 -pipe -msse -msse2 -msse3 -O1 -c libiptc / ipt_kernel_headers.c -o libiptc / ipt_kernel_headers.o
gcc -w -m64 -pipe -msse -msse2 -msse3 -O1 -c libiptc / libiptc.c -o libiptc / libiptc.o
gcc -w -O2 -m64 -pipe -msse -msse2 -msse3 -msse4_1 -msse4_2 -shared libiptc / ipt_kernel_headers.o libiptc / libip6tc.o libiptc / libiptc.o libiptc / libxtc.o libiptc / xtcshared.o -o. więc
gcc -w -m64 -pipe -O0-msse-msse2-msse3-msse4_1 -c e2p / e2p.c -o e2p / e2p.o
gcc -w-msse-msse2-msse3-msse4_1 -m64 -pipe -O1 -shared e2p / e2p.o -o e2p.so
gcc -w -pipe -O0-msse-msse2 -m64 -c spice-client-gtk-2.0 / spice-widget-enums.c -o spice-client-gtk-2.0 / spice-widget-enums.o
gcc -w -pipe -O0-msse-msse2 -m64 -c spice-client-gtk-2.0 / spice-grabsequence.c -o spice-client-gtk-2.0 / spice-grabsequence.o
gcc -w -pipe -O0-msse-msse2 -m64 -c spice-client-gtk-2.0 / spice-gtk-session.c -o spice-client-gtk-2.0 / spice-gtk-session.o
gcc -w -pipe -O0-msse-msse2 -m64 -c spice-client-gtk-2.0 / spice-widget.c -o spice-client-gtk-2.0 / spice-widget.o
gcc -w -pipe -O0-msse-msse2 -m64 -c spice-client-gtk-2.0 / usb-device-widget.c -o spice-client-gtk-2.0 / usb-device-widget.o
gcc -w -pipe -m64-msse-msse2 -O1 -shared spice-client-gtk-2.0 / spice-grabsequence.o spice-client-gtk-2.0 / spice-gtk-session.o spice-client-gtk-2.0 /spice-widget-enums.o spice-client-gtk-2.0 / spice-widget.o spice-client-gtk-2.0 / usb-device-widget.o -o spice-client-gtk-2.0.so
gcc -w -pipe -m64 -msse-msse2 -O1 -c search.c -o search.o
gcc -w -O0 -pipe -m64-msse-msse2-msse3-msse4_1 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -c cairomm-1.0 / cairomm / path.c -o cairomm-1.0 / cairomm / path.o
gcc -w -O0 -pipe -m64-msse-msse2-msse3-msse4_1 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -c cairomm-1.0 / cairomm / scaledfont.c -o cairomm-1.0 / cairomm / scairfaled
gcc -w -O0 -pipe -m64-msse -msse2 -msse3-msse4_1 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -c cairomm-1.0 / cairomm / fontface.c -o cairomm-1.0 / cairomm / fontface.o
gcc -w -O0 -pipe -m64-msse-msse2-msse3-msse4_1 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -c cairomm-1.0 / cairomm / quartz_font.c -o cairomm-1.0 / cairomm / quair.
gcc -w -O0 -pipe -m64-msse -msse2-msse3-msse4_1 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -c cairomm-1.0 / cairomm / win32_font.c -o cairomm-1.0 / cairomm / win32
gcc -w -O0 -pipe -m64-msse-msse2-msse3-msse4_1 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -c cairomm-1.0 / cairomm / refptr.c -o cairomm-1.0 / cairomm / refptr.
gcc -w -O0 -pipe -m64-msse-msse2 -msse3-msse4_1 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -c cairomm-1.0 / cairomm / cairomm.c -o cairomm-1.0 / cairomm / cairomm.
gcc -w -O0 -pipe -m64-msse -msse2-msse3-msse4_1 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -c cairomm-1.0 / cairomm /ext.c -o cairomm-1.0 / cairomm / context.o
gcc -w -O0 -pipe -m64-msse-msse2-msse3-msse4_1 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -c cairomm-1.0 / cairomm / enums.c -o cairomm-1.0 / cairomm / enums.o
gcc -w -O0 -pipe -m64-msse-msse2-msse3-msse4_1 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -c cairomm-1.0 / cairomm / win32_surface.c -o cairomm-1.0o_sair
gcc -w -O0 -pipe -m64-msse-msse2-msse3-msse4_1 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -c cairomm-1.0 / cairomm / pattern.c -o cairomm-1.0 / cairomm / pattern.o
gcc -w -O0 -pipe -m64-msse-msse2-msse3-msse4_1 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -c cairomm-1.0 / cairomm / types.c -o cairomm-1.0 / cairomm / types.o
gcc -w -O0 -pipe -m64-msse-msse2-msse3-msse4_1 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -c cairomm-1.0 / cairomm / matrix.c -o cairomm-1.0 / cairomm / matrix.o
gcc -w -O0 -pipe -m64-msse-msse2-msse3-msse4_1 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -c cairomm-1.0 / cairomm / quartz_surface.c -o cairomm-1.0o
gcc -w -O0 -pipe -m64-msse -msse2 -msse3-msse4_1 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -c cairomm-1.0 / cairomm / wyj.c -o cairomm-1.0 / cairomm / wyjatek.o
gcc -w -O0 -pipe -m64-msse-msse2-msse3-msse4_1 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -c cairomm-1.0 / cairomm / device.c -o cairomm-1.0 / cairomm / device.o
gcc -w -O0 -pipe -m64-msse-msse2-msse3-msse4_1 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -c cairomm-1.0 / cairomm / surface.c -o cairomm-1.0 / cairomm / surface.o
gcc -w -O0 -pipe -m64-msse-msse2-msse3 -msse4_1 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -c cairomm-1.0 / cairomm / xlib_surface.c -o cairomm-1.0 / cairomm-1.0 / caircom
gcc -w -O0 -pipe -m64-msse-msse2-msse3-msse4_1 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -c cairomm-1.0 / cairomm / fontoptions.c -o cairomm-1.0 / cairomm / fontoptions.
gcc -w -O0 -pipe -m64-msse-msse2-msse3-msse4_1 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -c cairomm-1.0 / cairomm / region.c -o cairomm-1.0 / cairomm / region.o
gcc -w -O0 -pipe -m64 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L-msse -msse2 -msse3 -msse4_1 -udostępniony cairomm-1.0 / cairomm / cairomm.o cairomm-1.0 / cairomm / context.o /cairomm/device.o cairomm-1.0 / cairomm / enums.o cairomm-1.0 / cairomm /ception.o cairomm-1.0 / cairomm / fontface.o cairomm-1.0 / cairomm / fontoptions.o cairomm-1.0 / cairomm / matrix o cairomm-1.0 / cairomm / path.o cairomm-1.0 / cairomm / pattern.o cairomm-1.0 / cairomm / quartz_font.o cairomm-1.0 / cairomm / quartz_surface.o cairomm-1.0 / cairomm / refptr.o cairomm-1.0 / cairomm / region.o cairomm-1.0 / cairomm / scaledfont.o cairomm-1.0 / cairomm / surface.o cairomm-1.0 / cairomm / types.o cairomm-1.0 / cairomm / win32_font.o cairomm-1.0 / cairomm / win32_surface.o cairomm-1.0 / cairomm / xlib_surface.o -o cairomm-1.0 / cairomm.so
gcc -w -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -m64 -msse -O1 -pipe -shared cairomm-1.0 / *. o -o cairomm-1.0.so
gcc -w -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -m64 -msse -O1 -pipe -c ulockmgr.c -o ulockmgr.o
gcc -w -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -m64 -msse -O1 -pipe -c gshadow.c -o gshadow.o
gcc -w -O2 -msse-msse2 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -m64 -pipe -c dpkg / string.c -o dpkg / string.o
gcc -w -O2 -msse-msse2 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -m64 -pipe -c dpkg / fdio.c -o dpkg / fdio.o
gcc -w -O2 -msse -msse2 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -m64 -pipe -c dpkg / namevalue.c -o dpkg / namevalue.o
gcc -w -O2 -msse-msse2 -D_GNU_SOURCE = 1 -D_REENTRANT -D_POSIX_C_SOURCE = 200112L -m64 -pipe -c dpkg / macros.c -o dpkg / macros.o

Grzmotnąć

Nieskończenie wyświetla losowe wartości szesnastkowe, a niektóre z nich są podświetlone, aby sprawiać wrażenie, jakbyś przeprowadzał skomplikowane wyszukiwanie w surowych danych.

while true; do head -c200 /dev/urandom | od -An -w50 -x | grep -E --color "([[:alpha:]][[:digit:]]){2}"; sleep 0.5; done

Bardzo długa wersja:

emerge openoffice

Rubin

Ten będzie:

1. Uzyskaj losowy kod z tej strony. przegląd kodu (dla bardziej czytelnego, dobrze napisanego kodu)
2. Niech wygląda na to, że wpisujesz ten kod.

require 'open-uri'
require 'nokogiri'
site = "http://codereview.stackexchange.com/"
system 'cls'
system("color 0a")
5.times do
    begin
        id = rand(1..6000)
        url = "#{site}/a/#{id}"
        page = Nokogiri::HTML(open(url))
        code = page.css('code')[0].text
    end until code

    code.each_char  do |char|
        print char
        sleep rand(10) / 30.0
    end
end

Oto ten skrypt oparty na pobranym stąd kodzie :

require 'open-uri'
code = open("http://hackertyper.com/code.txt")
system 'cls'
system("color 0a")

code.each_char  do |char|
    print char
    sleep rand(10) / 30.0
 end

Oto jak to wygląda:

Przejdźmy do prostego skryptu bash, który sprawia, że ​​wyglądasz hackersko, drukując zawartość każdego pliku oznaczonego jako tekst w / var / log / linia po linii, z losowymi opóźnieniami, aby wyglądało na to, że dzieje się coś intensywnego. W zależności od trafionych plików może dać dość interesujące wyniki.

#/bin/bash
# this script helps you do hackerish stuff

if [ "$EUID" -ne 0 ]
then
  echo "Please run as root to be hackerish."
  exit
fi

# turn off globbing
set -f
# split on newlines only for for loops
IFS='
'
for log in $(find /var/log -type f); do
  # only use the log if it's a text file; we _will_ encounter some archived logs
  if [ `file $log | grep -e text | wc -l` -ne 0 ]
  then
    echo $log
    for line in $(cat $log); do
      echo $line
      # sleep for a random duration between 0 and 1/4 seconds to indicate hard hackerish work
      bc -l <<< $(bc <<< "$RANDOM % 10")" / 40" | xargs sleep
    done
  fi
done

Upewnij się, że motyw terminalu wygląda hackersko. Oto kilka złych przykładów (nie mam pojęcia, co to wszystko oznacza, ale wygląda na hackerskich):

Bash: Niekończące się git commit

Problem z dzisiejszymi komputerami polega na tym, że są one dość szybkie, więc nawet zadania kompilacji ostatecznie się kończą. Ponadto, biorąc pod uwagę skrypt, który działa przez długi czas, możesz argumentować, że w rzeczywistości możliwe jest kontynuowanie pracy nad czymś innym podczas działania skryptu.

Aby rozwiązać ten problem, mamy następujący program. Naucz się od czasu do czasu losowo wpisywać „y” lub „n”.

Oczywiście potrzebujesz repozytorium git z nowymi treściami, ale zakładając, że od czasu do czasu wykonujesz rzeczywistą pracę, która nie powinna stanowić problemu.

#!/bin/bash

while [ 1 ]; do
  git add -p
  git reset
done

Grzmotnąć

#!/bin/bash
function lazy {
    sudo apt-get update
    lazy
    }
lazy

Spowoduje to tylko aktualizację repozytoriów. Jeśli ktoś zauważy, po prostu powiedz, że dodałeś nowe repozytorium dla nowego programu i testujesz różne. To nie jest tak naprawdę udawanie skryptu, ale polecenie.

UWAGA: Nie akceptuję nieproduktywności w pracy, ale lubię eksperymenty. Dlatego polecam tę aplikację, aby była tajnie produktywna.

Sieć neuronowa C ++

EDYTOWAĆ

Niestety zoptymalizowałem ten kod :( przyspieszyłem 2000x ... Stary kod jest jednak nadal idealny do marnowania czasu!

Oryginał

Właściwie zacząłem projekt w splotowych sieciach neuronowych idealny do tego! Kod źródłowy i dokumentacja znajdują się na github . Pierwszym krokiem jest utworzenie nowej sieci.

std::vector<int> numNeurons = { 500, 500, 2000, 10 };
std::vector<int> numMaps = { 1, 1, 1, 1 };

ConvolutionalNeuralNetwork neuralNetwork(numNeurons, numMaps, numNeurons, 
    std::vector<std::vector<int>>(), std::vector<std::vector<int>>());

Teraz, gdy mamy sieć z 300 neuronami i 1 250 000 synaps, zapiszmy ją w pliku, aby mieć pewność, że nie stracimy żadnego postępu w sieci.

neuralNetwork.SaveToFile("test2.cnn");

Wygenerowano plik tekstowy o wielkości 68 MB i ponad kilka godzin spokojnej pracy. A teraz zabawmy się! Stworzę losowe dane wejściowe i zacznę je dyskryminować.

std::vector<std::vector<float>> input;
for (int i = 0; i < 2; ++i)
    input.push_back(std::vector<float>{});

for (int i = 0; i < 2; ++i)
    for (int j = 0; j < 3; ++j)
        input[i].push_back(rand() % 100);
neuralNetwork.SetInput(input);

To był dość mały wkład do obrazu, ale udowadniamy tylko, że sieć może coś zrobić. Następnym krokiem jest dyskryminacja!

Layer output = neuralNetwork.Discriminate();

Dla mnie to jeszcze się nie skończyło i działa od ponad 2 dni! Potem, gdy otrzymamy ten wynik, przeprowadźmy go ponownie w odwrotnej kolejności dla zabawy.

Layer generatedOutput = neuralNetwork.Generate(output);

Wszystko po to, aby udowodnić, że interfejs API działa, nie ma jeszcze żadnych planów. Ten krok nie został jeszcze dla mnie wykonany i czekałem trochę czasu. Spłonęły dobre 2 dni, a to przybliżone oszacowanie na podstawie moich bieżących testów. Jest to dość skomplikowane i będziesz ciężko pracował przez jeden lub dwa dni, ale potem już nigdy nie będziesz musiał pracować!

Uwaga: jeśli już nigdy nie będziesz chciał pracować, spróbuj przeszkolić sieć

neuralNetwork.LearnCurrentInput();

Nawet nie mam czasu na to!

Jeśli chcesz pochwalić się wszystkimi danymi, które się dzieją, dodaj kilka funkcji do funkcji, aby wyświetlić, co się dzieje

Nowy konstruktor

ConvolutionalNeuralNetwork::ConvolutionalNeuralNetwork(std::vector<int> neuronCountPerLayer, std::vector<int> featureMapsPerLayer, std::vector<int> featureMapDimensions, std::vector<std::vector<int>> featureMapConnections, std::vector<std::vector<int>> featureMapStartIndex)
{
std::map<SimpleNeuron, std::vector<Synapse>> childrenOf;
for (unsigned int i = 0; i < neuronCountPerLayer.size() - 1; ++i)
{
    Layer currentLayer;

    for (int j = 0; j < neuronCountPerLayer[i]; ++j)
    {
        std::vector<Synapse> parentOf;

        if (featureMapsPerLayer[i] == 1)
        {
            for (int n = 0; n < neuronCountPerLayer[i + 1]; ++n)
            {
                std::cout << "Adding new synapse, data: " << std::endl;

                SimpleNeuron current = SimpleNeuron(i + 1, j + 1);
                SimpleNeuron destination = SimpleNeuron(i + 2, n + 1);

                std::cout << "Origin: " << i + 1 << ", " << j + 1 << "; Destination: " << i + 2 << ", " << n + 1 << std::endl;

                Synapse currentParentSynapse = Synapse(current, current);
                Synapse currentChildSynapse = Synapse(destination, destination);

                currentChildSynapse.SetWeightDiscriminate(currentParentSynapse.GetWeightDiscriminate());
                currentChildSynapse.SetWeightGenerative(currentParentSynapse.GetWeightGenerative());

                std::cout << "Weights: Discriminative: " << currentChildSynapse.GetWeightDiscriminate() << "; Generative: " << currentChildSynapse.GetWeightGenerative() << std::endl;

                parentOf.push_back(currentParentSynapse);

                if (childrenOf.find(destination) != childrenOf.end())
                    childrenOf.at(destination).push_back(currentChildSynapse);
                else
                    childrenOf.insert(std::pair<SimpleNeuron, std::vector<Synapse>>(destination,
                    std::vector<Synapse>{ currentChildSynapse }));
            }
        }

        else
        {
            int featureMapsUp = featureMapsPerLayer[i + 1];
            int inFeatureMap = featureMapsPerLayer[i] / j;
            int connections = featureMapConnections[i][inFeatureMap];
            int startIndex = (neuronCountPerLayer[i + 1] / featureMapsUp) * featureMapStartIndex[i][inFeatureMap];
            int destinationIndex = startIndex + (neuronCountPerLayer[i + 1] / featureMapsUp) * connections;

            for (int n = startIndex; n < destinationIndex; ++n)
            {
                SimpleNeuron current = SimpleNeuron(i + 1, j + 1);
                SimpleNeuron destination = SimpleNeuron(i + 2, n + 1);

                std::cout << "Origin: " << i + 1 << ", " << j + 1 << "; Destination: " << i + 2 << ", " << n + 1 << std::endl;

                Synapse currentParentSynapse = Synapse(current, current);
                Synapse currentChildSynapse = Synapse(destination, destination);

                currentChildSynapse.SetWeightDiscriminate(currentParentSynapse.GetWeightDiscriminate());
                currentChildSynapse.SetWeightGenerative(currentParentSynapse.GetWeightGenerative());

                std::cout << "Weights: Discriminative: " << currentChildSynapse.GetWeightDiscriminate() << "; Generative: " << currentChildSynapse.GetWeightGenerative() << std::endl;

                parentOf.push_back(currentParentSynapse);

                if (childrenOf.find(destination) != childrenOf.end())
                    childrenOf.at(destination).push_back(currentChildSynapse);
                else
                    childrenOf.insert(std::pair<SimpleNeuron, std::vector<Synapse>>(destination,
                    std::vector<Synapse>{ currentChildSynapse }));
            }
        }

        std::cout << "Adding neuron" << std::endl << std::endl;

        if (childrenOf.find(SimpleNeuron(i + 1, j + 1)) != childrenOf.end())
            currentLayer.AddNeuron(Neuron(parentOf, childrenOf.at(SimpleNeuron(i + 1, j + 1))));
        else
            currentLayer.AddNeuron(Neuron(parentOf, std::vector<Synapse>{}));
    }

    std::cout << "Adding layer" << std::endl << std::endl << std::endl;

    AddLayer(currentLayer);
}

Layer output;

std::cout << "Adding final layer" << std::endl;

for (int i = 0; i < neuronCountPerLayer[neuronCountPerLayer.size() - 1]; ++i)
    output.AddNeuron(Neuron(std::vector<Synapse>(), childrenOf.at(SimpleNeuron(neuronCountPerLayer.size(), i + 1))));
AddLayer(output);
}

Nowy FireSynapse

float Neuron::FireSynapse()
{
float sum = 0.0f;

std::cout << "Firing Synapse!" << std::endl;

for (std::vector<Synapse>::iterator it = m_ChildOfSynapses.begin(); it != m_ChildOfSynapses.end(); ++it)
    sum += ((*it).GetWeightDiscriminate() * (*it).GetParent().GetValue());

std::cout << "Total sum: " << sum << std::endl;

float probability = (1 / (1 + pow(e, -sum)));

std::cout << "Probably of firing: " << probability << std::endl;

if (probability > 0.9f)
    return 1.0f;

else if (probability < 0.1f)
    return 0.0f;

else
{
    std::cout << "Using stochastic processing to determine firing" << std::endl;
    float random = ((rand() % 100) / 100);
    if (random <= probability)
        return 1.0f;
    else
        return 0.0f;
}
}

Otrzymasz teraz dużą moc na konsoli.

Python 3

#!/usr/bin/python3

import random
import time

first_level_dirs = ['main', 'home', 'usr', 'root', 'html', 'assets', 'files']
title_descs = ['page', 'script', 'interface', 'popup']
id_names = ['container', 'main', 'textbox', 'popup']
tag_names = ['div', 'textarea', 'span', 'strong', 'article', 'summary', 'blockquote', 'b']
autoclosing_tags = ['br', 'input']

def random_js_line():
    return random.choice([
        '      $("#%s").html("<b>" + $("#%s").text() + "</b>");' % (random.choice(id_names), random.choice(id_names)),
        '      $.get("t_%i.txt", function(resp) {\n        callback(resp);\n      });' % (int(random.random() * 50)),
        '      $("%s>%s").css({width: %i + "px", height: %i + "px"});' % (random.choice(tag_names), random.choice(tag_names), int(random.random() * 75), int(random.random() * 75)),
        '      for (var i = 0; i < count; i++) {\n        $("<div>").appendTo("#%s");\n      }' % (random.choice(id_names))
    ])

def random_js_lines():
    lines = [random_js_line() for _ in range(int(random.random() * 14) + 1)]
    return '\n'.join(lines)

def random_html_line():
    tag_name = random.choice(tag_names)
    return random.choice([
        '    <%s>id: %i</%s>' % (tag_name, int(random.random() * 1000), tag_name),
        '    <%s class="%s">\n      <%s/>\n    </%s>' % (tag_name, random.choice(first_level_dirs), random.choice(autoclosing_tags), tag_name),
        '    <div id="%s"></div>' % (random.choice(first_level_dirs))
    ])

def random_html_lines():
    lines = [random_html_line() for _ in range(int(random.random() * 9) + 1)]
    return '\n'.join(lines)

while True:
    print('creating /%s/%i.html' % (random.choice(first_level_dirs), int(random.random() * 1000)))
    time.sleep(random.random())
    lines = [
        '<!DOCTYPE html>',
        '<html lang="en">',
        '  <head>',
        '    <title>%s #%i</title>' % (random.choice(title_descs), int(random.random() * 100)),
        '    <script type="text/javascript" src="/js/assets/jquery.min.js"></script>',
        '    <script type="text/javascript">',
        random_js_lines(),
        '    </script>',
        '  </head>',
        '  <body>',
        random_html_lines(),
        '  </body>',
        '</html>'
    ]
    lines = [single_line for linegroup in lines for single_line in linegroup.split('\n')]
    for line in lines:
        print(line)
        time.sleep(random.random() / 10)
    print()
    time.sleep(random.random() / 2)

Wyprowadza wiele wierszy fałszywego JS i HTML, z fałszywymi czasami „ładowania” (opóźnień), aby wyglądało to bardziej realistycznie.

To może i będzie znacznie rozszerzone! (podstawowy program już istnieje; muszę teraz tylko dodać więcej treści)

Oto przykładowa „strona”, którą generuje (tak naprawdę pochodzi ze starej wersji kodu; zaktualizuję go nowym kodem, gdy skończę):

creating /assets/809.html
<!DOCTYPE html>
<html lang="en">
  <head>
    <title>script #32</title>
    <script type="text/javascript" src="/js/assets/jquery.min.js"></script>
    <script type="text/javascript">
      $("#main").html("<b>" + $("#main").text() + "</b>");
      $("#textbox").html("<b>" + $("#container").text() + "</b>");
      $("#popup").html("<b>" + $("#textbox").text() + "</b>");
      $("#container").html("<b>" + $("#textbox").text() + "</b>");
      $.get("t_11.txt", function(resp) {
        callback(resp);
      });
      $("#main").html("<b>" + $("#textbox").text() + "</b>");
      $.get("t_14.txt", function(resp) {
        callback(resp);
      });
      $.get("t_1.txt", function(resp) {
        callback(resp);
      });
      $.get("t_34.txt", function(resp) {
        callback(resp);
      });
    </script>
  </head>
  <body>
    <span>id: 462</span>
    <textarea>id: 117</textarea>
  </body>
</html>

Node.js + BDD

Wygląda na niekończący się strumień testów w stylu BDD. Nikt nie może cię winić za przeprowadzenie testów!

    "use strict"
var colors = require("colors"),
    features = ["User", "Request", "Response", "Cache", "Preference", "Token", "Profile", "Application", "Security"],
    patterns = ["Factory", "Observer", "Manager", "Repository", "Impl", "Dao", "Service", "Delegate", "Activity"],
    requirements = ["return HTTP 403 to unauthorized users",
                    "accept UTF-8 input",
                    "return HTTP 400 for invalid input",
                    "correctly escape SQL",
                    "validate redirects",
                    "provide online documentation",
                    "select internationalized strings, based on locale",
                    "support localized date formats",
                    "work in IE6",
                    "pass W3C validation",
                    "produce valid JSON",
                    "work with screen readers",
                    "use HTML5 canvas where available",
                    "blink"],
    minTimeout = 100,
    maxTimeout = 1000,
    minRequirements = 2,
    maxRequirements = 6,
    skipThreshold = 0.1,
    failThreshold = 0.2


function randBetween(l, u) {
  return Math.floor(Math.random() * (u - l) + l) 
}

function choose(l) {
  return l[randBetween(0, l.length)]
}

function timeout() {
  return randBetween(minTimeout, maxTimeout)
}

function printFeature() {
  console.log("")
  var feature = choose(features) + choose(patterns)
  var article = /^[AEIOU]/.test(feature) ? "An " : "A "
  console.log(article + feature + " should")
  setTimeout(function() {
    var reqs = randBetween(minRequirements, maxRequirements)
    printRequirements(reqs)
  }, timeout())
}

function printRequirements(i) {
  if (i > 0) {
    var skipFailOrPass = Math.random()
    if (skipFailOrPass < skipThreshold) {
      console.log(("- " + choose(requirements) + " (SKIPPED)").cyan)
    } else if (skipFailOrPass < failThreshold) {
      console.log(("x " + choose(requirements) + " (FAILED)").red)
      console.log(("  - Given I am on the " + choose(features) + " page").green)
      console.log(("  - When I click on the " + choose(features) + " link").green)
      console.log(("  x Then the Log Out link should be visible in the top right hand corner").red)
    } else {
      console.log(("+ " + choose(requirements)).green)
    }
    setTimeout(function() {printRequirements(i - 1)}, timeout())
  } else {
    printFeature()
  }
}

printFeature()

Aktualizacja

Przyszło mi do głowy, że wyglądałoby podejrzanie, jeśli wszystkie twoje testy przeszły pomyślnie, więc zaktualizowałem go, aby zawierał niektóre testy zakończone niepowodzeniem - wraz z Given-When-Thens.

I tak, wiem, że wszystkie niepowodzenia mają tę samą wiadomość. Naprawdę musisz naprawić link do wylogowania!

C # (Windows)

Przedstawiam wam zupełnie nowy Memtest86 Simulator 2014 ! (Ponieważ uruchomienie Memtest86 w systemie Windows ma sens)

W komplecie z działającymi paskami postępu i wskaźnikiem wzoru!

Ten kod intensywnie korzysta z klasy Console, która, o ile mi wiadomo, jest dostępna tylko w systemie Windows. Ponadto nie mogłem znaleźć sposobu na pokazanie prawdziwej nazwy / częstotliwości procesora i dostępnej pamięci, więc są one zakodowane na stałe.

Zrzut ekranu:

EDYTOWAĆ

Aby pobrać informacje o procesorze, możesz użyć przestrzeni nazw Microsoft.Win32 i klasy RegistryKey.

 // Processor information, add 'using Microsoft.Win32';
string processor = "";
RegistryKey processor_name = Registry.LocalMachine.OpenSubKey(@"Hardware\Description\System\CentralProcessor\0", RegistryKeyPermissionCheck.ReadSubTree);
        if (processor_name != null)
        {
            if (processor_name.GetValue("ProcessorNameString") != null)
            {
                processor = (string)processor_name.GetValue("ProcessorNameString");
            }
        }

Kod (brzydki, wiem):

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;

class MemTestSim
{
    static void Main(string[] args)
    {
        Random r = new Random();
        int seconds = 0;
        int pass = 0;
        int test = 0;
        int testNumber = 0;

        string[] testNames = { "Address test, own Adress", "Moving inversions, ones & zeros", "Moving inversions, 8 bit pattern" };
        string[] pattern = { "80808080", "7f7f7f7f", "40404040", "bfbfbfbf", "20202020", "dfdfdfdf", "10101010", "efefefef", "08080808", "f7f7f7f7", "8f8f8f8f" };

        // Trick to stop the console from scrolling
        Console.SetWindowSize(80, 40);

        Console.Title = "Memtest86+ v2.11";
        Console.CursorVisible = false;

        // Dark Blue Background Color
        Console.BackgroundColor = ConsoleColor.DarkBlue;
        Console.Clear();

        // Green Title Text
        Console.BackgroundColor = ConsoleColor.DarkGreen;
        Console.ForegroundColor = ConsoleColor.Black;
        Console.Write("      Memtest86+ v2.11     ");

        // Gray on Blue Text and main window structure
        Console.BackgroundColor = ConsoleColor.DarkBlue;
        Console.ForegroundColor = ConsoleColor.Gray;
        Console.Write("| Pass " + pass + "%\n");
        Console.WriteLine("Intel Core i5 2290 MHz     | Test ");
        Console.WriteLine("L1 Cache:  128K   1058MB/s | Test #" + testNumber + "  [" + testNames[0] + "]");
        Console.WriteLine("L2 Cache:  512K   1112MB/s | Testing:  132K - 8192M  8192M");
        Console.WriteLine("L3 Cache: 3072K   1034MB/s | Pattern: ");
        Console.WriteLine("Memory  : 8192M            |---------------------------------------------------");
        Console.WriteLine("Chipset :  Intel i440FX");
        Console.WriteLine();
        Console.WriteLine();
        Console.WriteLine(" WallTime   Cached  RsvdMem   MemMap   Cache  ECC  Test  Pass  Errors  ECC Errs");
        Console.WriteLine(" ---------  ------  -------  --------  -----  ---  ----  ----  ------  --------");
        Console.WriteLine("   0:00:26   8192M      64K  e820-Std    on   off   Std     0       0");

        // Bottom Bar
        Console.SetCursorPosition(0, 24);
        Console.BackgroundColor = ConsoleColor.Gray;
        Console.ForegroundColor = ConsoleColor.DarkBlue;
        Console.WriteLine("(ESC)Reboot  (c)configuration  (SP)scroll_lock  (CR)scroll_unlock               ");


        Console.SetWindowSize(80, 25);

        // Reset text color
        Console.BackgroundColor = ConsoleColor.DarkBlue;
        Console.ForegroundColor = ConsoleColor.Gray;

        // FOREVER
        while (true)
        {
            TimeSpan time = TimeSpan.FromSeconds(seconds);

            // Running Time (WallTime)
            Console.SetCursorPosition(3, 11);
            string min = (time.Minutes < 10 ? "0" + time.Minutes : "" + time.Minutes);
            string sec = (time.Seconds < 10 ? "0" + time.Seconds : "" + time.Seconds);
            Console.Write(time.Hours + ":" + min + ":" + sec);

            // Test percentage
            Console.SetCursorPosition(34, 1);
            Console.Write((int)test + "%");

            // Test Progress Bar
            Console.SetCursorPosition(38, 1);
            for (int i = 0; i < test / 3; i++)
                Console.Write("#");

            Console.SetCursorPosition(38, 0);
            for (int i = 0; i < pass / 3; i++)
                Console.Write("#");

            // Test Number
            Console.SetCursorPosition(35, 2);
            Console.Write(testNumber + "  [" + testNames[testNumber] + "]        ");

            if (testNumber != 0)
            {
                Console.SetCursorPosition(38, 4);
                Console.Write(pattern[test / 10]);
            }
            else
            {
                Console.SetCursorPosition(38, 4);
                Console.Write("         ");
            }

            if (test >= 100)
            {
                test = 0;

                Console.SetCursorPosition(34, 0);
                Console.Write(pass + "%");

                Console.SetCursorPosition(34, 1);
                Console.Write("                                      ");
                testNumber++;
                pass += 2;

                if (testNumber == 2)
                    testNumber = 0;
            }

            Thread.Sleep(1000);
            test += r.Next(0, 3);
            seconds++;
        }
    }
}

Python, 36 znaków

print("Opening Internet Explorer...")

Python, 21 znaków

print("Opening IE...")

Staram się być zabawny. : P

AHK

Udajesz, że piszesz, podczas gdy skrypt generuje wiele akcesoriów i mutatorów w JavaScript. Upewnij się, że IDE (przetestowałem to na Notepad ++) jest aktywnym oknem.

Jeśli chcesz, podaj listę zmiennych i nazwę klasy. Właśnie wykorzystałem to, co już było window.location.

Naciśnij klawisz esc, aby wyjść.

Naciśnij 0 na klawiaturze numerycznej, aby wstrzymać, gdy ktoś spróbuje z tobą porozmawiać.

Naciśnij ctrl + w (w oznacza pracę), aby rozpocząć

^w::
    loop{
        variable_names  :=  "hash|host|hostname|href|origin|pathname|port|protocol|search"
        class_name  :=  "location"

        StringSplit, variable_names_array, variable_names, "|"

        loop, %variable_names_array0%{
            Random, delay, 80, 120
            SetKeyDelay, %delay%
            current :=  variable_names_array%a_index%
            Send, %class_name%.prototype.
            Random, r, 800, 1300
            Sleep, %r%
            Send, get_
            Random, r, 800, 1300
            Sleep, %r%
            Send, %current%
            Random, r, 800, 1300
            Sleep, %r%
            Send, {space}={space}
            Random, r, 800, 1300
            Sleep, %r%
            Send, function(){{}{enter}
            Random, r, 800, 1300
            Sleep, %r%
            Send, {tab}
            Random, r, 800, 1300
            Sleep, %r%
            Send, return this.
            Random, r, 800, 1300
            Sleep, %r%
            Send, %current%;{enter}
            Random, r, 800, 1300
            Sleep, %r%
            Send, {BackSpace}{}}
            Random, r, 800, 1300
            Sleep, %r%
            Send, {enter}{enter}
            Random, r, 800, 1300
            Sleep, %r%

            Send, %class_name%.prototype.
            Random, r, 800, 1300
            Sleep, %r%
            Send, set_
            Random, r, 800, 1300
            Sleep, %r%
            Send, %current%
            Random, r, 800, 1300
            Sleep, %r%
            Send, {space}={space}
            Random, r, 800, 1300
            Sleep, %r%
            Send, function(%current%){{}{enter}
            Random, r, 800, 1300
            Sleep, %r%
            Send, {tab}
            Random, r, 800, 1300
            Sleep, %r%
            Send, this.
            Random, r, 800, 1300
            Sleep, %r%
            Send, %current% ={space}
            Random, r, 800, 1300
            Sleep, %r%
            Send, %current%;{enter}
            Random, r, 800, 1300
            Sleep, %r%
            Send, return this;{enter}
            Random, r, 800, 1300
            Sleep, %r%
            Send, {BackSpace}{}}
            Random, r, 800, 1300
            Sleep, %r%
            Send, {enter}{enter}
            Random, r, 800, 1300
            Sleep, %r%
        }
    }
return

esc::
    ExitApp
    return

numpad0::
    Pause, toggle
    return

Grzmotnąć

Zrzuca losowy blok pamięci fizycznej i przegląda zawartość. Będę musiał być do tego rootem. Domyślnie dostępny jest tylko pierwszy 1 MB pamięci . dddomyślny rozmiar bloku to 512 bajtów, które można zmienić za pomocą opcji, ibs=bytesale należy pamiętać o drugiej opcji, skip=$offsetktóra wybiera blok losowo. Dane wyjściowe ddsą wysyłane w trcelu usunięcia znaków innych niż ASCII; oceniane są tylko unikalne wyniki 2 lub więcej znaków.

Każdy znaleziony ciąg jest porównywany ze słownikiem. Jeśli nie zostaną znalezione żadne dopasowania, nastąpi próba dekodowania jako base64. Na koniec zwracane są wszystkie oceniane łańcuchy.

Jest kilka innych opcji zależnych od platformy, o których należy pamiętać, takich jak lokalizacja pliku słownika (/ usr / share / dict / words), czy sen akceptuje zmiennoprzecinkowe dane wejściowe i jeśli base64jest dostępny.

Należy także pamiętać, że ddstatystyki wyjściowe dotyczące operacji wykonywanej na stderr, który jest przesyłany do / dev / null. Jeśli coś pójdzie strasznie źle (masz dostęp do / dev / mem ...), wyjście stderr nie będzie widoczne.

Ogólnie rzecz biorąc, niezbyt przydatne, ale nauczyłem się trochę o pamięci linux i pisanie tego skryptu okazało się zabawne.

#!/bin/bash

offset=`expr $RANDOM % 512`
mem=`dd if=/dev/mem skip=$offset count=1 2>/dev/null| tr '[\000-\040]' '\n' | tr '[\177-\377'] '\n' | sort -u | grep '.\{2,\}'`

results=""

for line in $mem
do
    echo "Evaluating $line"
    greps=`grep "^$line" /usr/share/dict/words | head`

    if [ -n "$greps" ]
    then
        echo "Found matches."
        echo $greps
    else
        #echo "No matches in dictionary. Attempting to decode."
        decode=`echo "$line" | base64 -d 2>/dev/null`
        if [ $? -ne 1 ]
        then
            echo "Decode is good: $decode"
        #else
            #echo "Not a valid base64 encoded string."
        fi
    fi

    results+=" $line"

    # make it look like this takes a while to process
    sleep 0.5

done 

if (( ${#results} > 1 ))
then
    echo "Done processing input at block $offset: $results"
fi

Czasami nie ma ciekawych wyników (wszystkie zera). Czasami jest tylko kilka ciągów:

codegolf/work# ./s 
Evaluating @~
Evaluating 0~
Evaluating ne
Found matches.
ne nea neal neallotype neanic neanthropic neap neaped nearable nearabout
Done processing input at block 319:  @~ 0~ ne

Czasami w pamięci jest coś czytelnego dla człowieka (zanim zarejestrowałem przesunięcie bloku):

codegolf/work# ./s 
Evaluating grub_memset
Evaluating grub_millisleep
Evaluating grub_mm_base
Evaluating grub_modbase
Evaluating grub_named_list_find
Evaluating grub_net_open
Evaluating grub_net_poll_cards_idle
Evaluating grub_parser_cmdline_state
Evaluating grub_parser_split_cmdline
Evaluating grub_partition_get_name
Evaluating grub_partition_iterate
Evaluating grub_partition_map_list
Evaluating grub_partition_probe
Evaluating grub_pc_net_config
Evaluating grub_pit_wait
Evaluating grub_print_error
Evaluating grub_printf
Evaluating grub_printf_
Evaluating grub_puts_
Evaluating grub_pxe_call
Evaluating grub_real_dprintf
Evaluating grub_realidt
Evaluating grub_realloc
Evaluating grub_refresh
Evaluating grub_register_command_prio
Evaluating grub_register_variable_hook
Evaluating grub_snprintf
Evaluating grub_st
Evaluating grub_strchr
Evaluating _memmove
Done processing input:  grub_memset grub_millisleep grub_mm_base 
    grub_modbase grub_named_list_find grub_net_open grub_net_poll_cards_idle
    grub_parser_cmdline_state grub_parser_split_cmdline 
    grub_partition_get_name grub_partition_iterate grub_partition_map_list 
    grub_partition_probe grub_pc_net_config grub_pit_wait grub_print_error 
    grub_printf grub_printf_ grub_puts_ grub_pxe_call grub_real_dprintf 
    grub_realidt grub_realloc grub_refresh grub_register_command_prio 
    grub_register_variable_hook grub_snprintf grub_st grub_strchr _memmove

I ostatni przykładowy przebieg pokazujący zniekształcone dane grep, trafienia w słowniku i udane dekodowanie base64 (przed ponownym zarejestrowaniem przesunięcia bloku):

codegolf/work# ./s 
Evaluating <!
Evaluating !(
Evaluating @)
Evaluating @@
Evaluating $;
Evaluating '0@
Evaluating `1
Evaluating 1P$#4
Evaluating )$2
Evaluating -3
Evaluating 3HA
Evaluating 3N
Evaluating @@9
Evaluating 9@
Evaluating 9Jh
Evaluating \9UK
grep: Invalid back reference
Evaluating a#
Evaluating CX
Evaluating ?F
Evaluating !H(
Evaluating +%I
Evaluating Io
Found matches.
Io Iodamoeba Ione Ioni Ionian Ionic Ionicism Ionicization Ionicize Ionidium
Evaluating Kj
Found matches.
Kjeldahl
Evaluating l#
Evaluating L6qh
Decode is good: /��
Evaluating O%
Evaluating OX
Evaluating PR
Evaluating .Q
Evaluating Q4!
Evaluating qQ
Evaluating )u
Evaluating Ua
Found matches.
Uaraycu Uarekena Uaupe
Evaluating $v
Evaluating )V
Evaluating V8
Evaluating V,B~
Evaluating wIH
Evaluating xU
Evaluating y@
Evaluating @z
Evaluating Z0
Evaluating zI
Evaluating Z@!QK
Done processing input:  <! !( @) @@ $; '0@ `1 1P$#4 )$2 -3 3HA 3N
    @@9 9@ 9Jh \9UK a# CX ?F !H( +%I Io Kj l# L6qh O% OX PR .Q Q4!
    qQ )u Ua $v )V V8 V,B~ wIH xU y@ @z Z0 zI Z@!QK

Pakiet Windows

@echo off

set /p hax="How much haxx0rz: " %=%
set /p haxx="How quick haxx0rz (seconds): " %=%

FOR /L %%I IN (1, 1, %hax%) DO (
START cmd /k "COLOR A&&tree C:\"
timeout %haxx%
)

To jest żart, który trzymam przy sobie przez lata, aby wyglądał jak coś z filmu hakerskiego z lat 90. Zwykle używam go podczas zdalnego połączenia z komputerem, aby wystraszyć ludzi.

Grzmotnąć

Niekończące się poszukiwania kawiarni.

Znalazłem to w Internecie dawno temu:

cat /dev/urandom | hexdump | grep "ca fe"

Python 2.7

Kompletny zestaw testów

„Uruchamia” zestaw „Testów jednostkowych” na wszystkich plikach w drzewie katalogów. Przechodzi przez wszystkie podkatalogi. Zaczyna się od nowa, kiedy dojdzie do końca.

Wyświetla status działania:

============================= entering . =============================
------------------------ test_line_numbers.py ------------------------
Ran 18 tests in 3.23707662572 seconds, 0 errors
---------------------------- test_main.c ----------------------------
Ran 26 tests in 1.3365194929 seconds, 0 errors
--------------------------- test_parser.c ---------------------------
Ran 8 tests in 1.61633904378 seconds, 0 errors
--------------------------- test_README.c ---------------------------
Ran 12 tests in 2.27466813182 seconds, 0 errors
4 modules OK (0 failed)
=========================== entering ./lib ===========================

...

Funkcje, które sprawiają, że jest bardziej złożony niż potrzebny i, miejmy nadzieję, bardziej realistyczny:

• Liczba testów i czas testu są proporcjonalne do rozmiaru pliku.
• Zamienia rozszerzenia plików kodu źródłowego na znane. Zmodyfikuj, CodeExtensionsaby dodać bardziej znane typy.
  • Wybiera nowe rozszerzenie w oparciu o częstotliwość rzeczywistych plików językowych, więc nie zobaczysz testowania kodu Python, jeśli twój dysk twardy jest pełen Ruby.
• Pomija pliki z wiodącymi . prezentami typu „test_.bashrc.js”

import os,random,time,collections

CodeExtensions = ('.py', '.c','.cpp','.rb','.js','.pl','.cs','.el')
last_exts = collections.deque(CodeExtensions[:1],100)
maxlen=0

def maketestname(filename):
    root,ext = os.path.splitext(filename)
    if ext in CodeExtensions:
        last_exts.append(ext)
    else:
        ext = random.choice(last_exts)
    return 'test_'+root+ext

def banner(char,text,width=70):
    bar = char*((width-len(text)-2)/2)
    return "{} {} {}".format(bar,text,bar)

def scaledrand(scale,offset):
    return random.random()*scale+random.randrange(offset)

while True:
    for dirname, subdirs, files in os.walk('.'):
        print banner('=',"entering {}".format(dirname))
        skipped = 0
        for filename in files:
            if filename[0] is not '.':
                testfilename = maketestname(filename)
                print banner('-',testfilename)
                filelen = os.path.getsize(os.path.join(dirname,filename))
                maxlen = max(maxlen,filelen)
                ntests = int(scaledrand(20*filelen/maxlen,10))
            testtime = scaledrand(ntests/5.0,2)
            time.sleep(testtime)                
            else:
                skipped+=1
                continue

            print "Ran {} tests in {} seconds, {} errors".format(ntests,testtime,0)
        print "{} modules OK ({} failed)\n".format(len(files)-skipped,0)

Java + Guava 16 (Guava nie jest zbyt potrzebny, ale pisanie sprawiło, że niektóre rzeczy były mniej denerwujące).

W porządku, powinieneś pracować? Co powiesz na program, który faktycznie pisze prawdziwy kod Java, który faktycznie się kompiluje (choć niewiele robi).

Trudno jest zademonstrować animację, ale program ten zapisuje program Java przy użyciu domyślnego słownika (250 popularnych angielskich słów) lub pliku rozdzielanego znakiem nowej linii (traktowanego jako argument wiersza poleceń) i wpisuje go do konsoli po jednym znaku na raz z pozornie ludzkimi prędkościami . Upewnij się, że uruchomisz go sam, ponieważ ten post nie jest sprawiedliwy. Po zakończeniu odczekuje 1 minutę, a następnie wydrukuje wiele pustych linii do konsoli i rozpocznie od nowa. Próbowałem to napisać, aby różne parametry można było dostroić.

Poza tym zwykle umieszczałbym to w więcej niż jednym pliku, ale aby ułatwić uruchamianie, zmiażdżyłem wszystkie klasy razem.

package org.stackoverflow.ppcg;

import java.io.*;
import java.util.*;

import com.google.common.base.CaseFormat;
import com.google.common.base.Converter;
import com.google.common.collect.Lists;

public class CodeGenerator {
    public static final Converter<String, String> TOUPPER =
            CaseFormat.LOWER_CAMEL.converterTo(CaseFormat.UPPER_CAMEL);
    public static final Converter<String, String> TOLOWER =
            CaseFormat.UPPER_CAMEL.converterTo(CaseFormat.LOWER_CAMEL);

    public static final String[] TYPES = new String[]{
        "int", "long", "double", "String"
    };

    public static final List<String> DEFAULT_LIST = Arrays.asList(new String[]{
            "the", "and", "for", "you", "say", "but", "his", "not", "she", "can",
            "who", "get", "her", "all", "one", "out", "see", "him", "now", "how",
            "its", "our", "two", "way", "new", "day", "use", "man", "one", "her",
            "any", "may", "try", "ask", "too", "own", "out", "put", "old", "why",
            "let", "big", "few", "run", "off", "all", "lot", "eye", "job", "far",
            "have", "that", "with", "this", "they", "from", "that", "what", "make", "know",
            "will", "time", "year", "when", "them", "some", "take", "into", "just", "your",
            "come", "than", "like", "then", "more", "want", "look", "also", "more", "find",
            "here", "give", "many", "well", "only", "tell", "very", "even", "back", "good",
            "life", "work", "down", "call", "over", "last", "need", "feel", "when", "high",
            "their", "would", "about", "there", "think", "which", "could", "other", "these", "first",
            "thing", "those", "woman", "child", "there", "after", "world", "still", "three", "state",
            "never", "leave", "while", "great", "group", "begin", "where", "every", "start", "might",
            "about", "place", "again", "where", "right", "small", "night", "point", "today", "bring",
            "large", "under", "water", "write", "money", "story", "young", "month", "right", "study",
            "people", "should", "school", "become", "really", "family", "system", "during", "number", "always",
            "happen", "before", "mother", "though", "little", "around", "friend", "father", "member", "almost",
            "change", "minute", "social", "follow", "around", "parent", "create", "others", "office", "health",
            "person", "within", "result", "change", "reason", "before", "moment", "enough", "across", "second",
            "toward", "policy", "appear", "market", "expect", "nation", "course", "behind", "remain", "effect",
            "because", "through", "between", "another", "student", "country", "problem", "against", "company", "program",
            "believe", "without", "million", "provide", "service", "however", "include", "several", "nothing", "whether",
            "already", "history", "morning", "himself", "teacher", "process", "college", "someone", "suggest", "control",
            "perhaps", "require", "finally", "explain", "develop", "federal", "receive", "society", "because", "special",
            "support", "project", "produce", "picture", "product", "patient", "certain", "support", "century", "culture"
    });

    private static final int CLASS_NAME_LENGTH = 2;

    private final WordList wordList;
    private final Appendable out;
    private final Random r = new Random();

    private CodeGenerator(WordList wordList, Appendable out) {
        this.wordList = wordList;
        this.out = out;
    }

    public static void main(String... args) throws Exception {
        List<?> wordSource = getWords(args);
        WordList list = new WordList(wordSource);
        SleepingAppendable out = new SleepingAppendable(System.out);
        CodeGenerator generator = new CodeGenerator(list, out);
        while(!Thread.interrupted()) {
            generator.generate();
            try {
                Thread.sleep(60000);
            } catch (InterruptedException e) {
                break;
            }
            out.setSleeping(false);
            for(int i = 0; i < 100; i++) {
                out.append(System.lineSeparator());
            }
            out.setSleeping(true);
        }
    }

    private static List<?> getWords(String[] args) {
        if(args.length > 0) {
            try {
                return getListFromFile(args[0]);
            } catch(IOException e) { }
        }
        return DEFAULT_LIST;
    }

    private static List<Object> getListFromFile(String string) throws IOException {
        List<Object> newList = Lists.newArrayList();

        File f = new File(string);
        Scanner s = new Scanner(f);

        while(s.hasNext()) {
            newList.add(s.nextLine());
        }

        return newList;
    }

    private void generate() throws IOException {
        String className = beginClass();
        List<Field> finalFields = generateFields(true);
        printFields(finalFields);
        out.append(System.lineSeparator());
        List<Field> mutableFields = generateFields(false);
        printFields(mutableFields);
        out.append(System.lineSeparator());
        printConstructor(className, finalFields);
        printGetters(finalFields);
        printGetters(mutableFields);
        printSetters(mutableFields);
        endClass();
    }

    private void printGetters(List<Field> fields) throws IOException {
        for(Field f : fields) {
            out.append(System.lineSeparator());
            f.printGetter(out);
        }
    }

    private void printSetters(List<Field> fields) throws IOException {
        for(Field f : fields) {
            out.append(System.lineSeparator());
            f.printSetter(out);
        }
    }

    private void printConstructor(String className, List<Field> finalFields) throws IOException {
        out.append("\tpublic ").append(className).append('(');
        printArgs(finalFields);
        out.append(") {").append(System.lineSeparator());
        for(Field f : finalFields) {
            f.printAssignment(out);
        }
        out.append("\t}").append(System.lineSeparator());
    }

    private void printArgs(List<Field> finalFields) throws IOException {
        if(finalFields.size() == 0) return;

        Iterator<Field> iter = finalFields.iterator();

        while(true) {
            Field next = iter.next();
            next.printTypeAndName(out);
            if(!iter.hasNext()) break;
            out.append(", ");
        }
    }

    private List<Field> generateFields(boolean isfinal) {
        int numFields = r.nextInt(3) + 2;
        List<Field> newFields = Lists.newArrayListWithCapacity(numFields);
        for(int i = 0; i < numFields; i++) {
            String type = TYPES[r.nextInt(4)];
            newFields.add(new Field(type, wordList.makeLower(r.nextInt(2) + 1), isfinal));
        }
        return newFields;
    }

    private void printFields(List<Field> finalFields) throws IOException {
        for(Field f : finalFields) {
            f.printFieldDeclaration(out);
        }
    }

    private String beginClass() throws IOException {
        out.append("public class ");
        String className = wordList.nextClassName(CLASS_NAME_LENGTH);
        out.append(className).append(" {").append(System.lineSeparator());

        return className;
    }

    private void endClass() throws IOException {
        out.append("}");
    }

    private static class WordList {
        private final Random r = new Random();

        private final List<?> source;

        private WordList(List<?> source) {
            this.source = source;
        }

        private String makeUpper(int length) {
            StringBuilder sb = new StringBuilder();
            for(int i = 0; i < length; i++) {
                sb.append(randomWord());
            }
            return sb.toString();
        }

        private String makeLower(int length) {
            return TOLOWER.convert(makeUpper(length));
        }

        private String randomWord() {
            int sourceIndex = r.nextInt(source.size());
            return TOUPPER.convert(source.get(sourceIndex).toString().toLowerCase());
        }

        public String nextClassName(int length) {
            return makeUpper(length);
        }
    }

    private static class Field {
        private final String type;
        private final String fieldName;
        private final boolean isfinal;

        Field(String type, String fieldName, boolean isfinal) {
            this.type = type;
            this.fieldName = fieldName;
            this.isfinal = isfinal;
        }

        void printFieldDeclaration(Appendable appendable) throws IOException {
            appendable.append("\tprivate ");
            if(isfinal) appendable.append("final ");
            printTypeAndName(appendable);
            appendable.append(';').append(System.lineSeparator());
        }

        void printTypeAndName(Appendable appendable) throws IOException {
            appendable.append(type).append(' ').append(fieldName);
        }

        void printGetter(Appendable appendable) throws IOException {
            appendable.append("\tpublic ");
            appendable.append(type).append(" get").append(TOUPPER.convert(fieldName));
            appendable.append("() {").append(System.lineSeparator());
            appendable.append("\t\treturn ").append(fieldName).append(';');
            appendable.append(System.lineSeparator()).append("\t}").append(System.lineSeparator());
        }

        void printSetter(Appendable appendable) throws IOException {
            appendable.append("\tpublic void set");
            appendable.append(TOUPPER.convert(fieldName));
            appendable.append("(").append(type).append(' ').append(fieldName);
            appendable.append(") {").append(System.lineSeparator());
            printAssignment(appendable);
            appendable.append("\t}").append(System.lineSeparator());            
        }

        void printAssignment(Appendable appendable) throws IOException {
            appendable.append("\t\tthis.").append(fieldName).append(" = ").append(fieldName);
            appendable.append(';').append(System.lineSeparator());
        }
    }

    private static class SleepingAppendable implements Appendable {
        private Random r = new Random();
        private Appendable backing;

        private boolean sleeping = true;

        public SleepingAppendable(Appendable backing) {
            this.backing = backing;
        }

        @Override
        public Appendable append(CharSequence csq) throws IOException {
            return append(csq, 0, csq.length());
        }

        @Override
        public Appendable append(CharSequence csq, int start, int end)
                throws IOException {
            for(int i = start; i < end; i++) {
                append(csq.charAt(i));
            }

            sleep(100, 300);

            return this;
        }

        @Override
        public Appendable append(char c) throws IOException {
            sleep(170, 80);

            backing.append(c);

            return this;
        }


        private void sleep(int base, int variation) {
            if(!sleeping) return;
            try {
                Thread.sleep((long) (r.nextInt(80) + 70));
            } catch (InterruptedException e) {
            }
        }

        public boolean isSleeping() {
            return sleeping;
        }

        public void setSleeping(boolean sleeping) {
            this.sleeping = sleeping;
        }
    }
}