내가 일하는 것처럼 보이게


278

종종 스크립트 나 쿼리를 실행하는 데 상당한 시간이 걸립니다. 나는 그 대본을 열어두고 죄책감이없는 미루는 일을 즐길 수 있습니다.

이제 위의 스크립트 중 하나 인 것처럼 보이는 모든 스크립트를 스크립트를 작성할 수 있다면 어떨까요? 나는 화면에 올리고 즐길 수 고양이 실시간 스트리밍을 누군가가 화면의 모든 복잡한 데데 내 실제 작업을 함께 할 아무것도하지 않았다는 것을 깨달았다 전에.

당신의 도전은 나를 위해이 스크립트를 작성하는 것입니다 (예, 나는 게으르다).

좋은 대답한다 :

  • 스크립트가 작동하는 것처럼 화면에 무언가를 표시하십시오. "화면"은 터미널, 브라우저 등이 될 수 있습니다.
  • 상당히 독창적입니다 (예, 우리는 끝없는 진행률 표시 줄 프로그램을 보았습니다)
  • 기술인에 의한 생존자 검진

나쁜 대답한다 :

  • 날 해고 시켜줘
  • 우리 모두가 90 년대에 전달한 것을 다시 해시하십시오

대답 수도 :

  • 위의 나쁜 글 머리 기호 중 하나를 초월 ( 예를 들어 )
  • 생존 비판적 검사
  • * 헐떡 거림 * 실제로 어떻게 내 작품의 직무 태만에 유용하거나 보조 무언가를

수락은 실제 결과의 보너스와 함께 투표를 기반으로합니다. 실제로 감지를 결정하기 위해 화면이 표시 될 때 (미팅 등)이 스크립트 (Linux Mint 16)를 실제로 실행합니다. 누군가가 가짜임을 알게되면, 당신은 도망 칠 수 있습니다. 누군가 내가 얼마나 열심히 일하고 있는지에 대해 언급하면 ​​+5 보너스 공감 효과가 있습니다.

이 경우 "유용한"은 모든 코더에 적용 할 수 있지만 교사가 적용한 애플에서 그와 같은 빛을 원한다면 내 태그 에 따라 코드에서 작동하는 풀 스택 웹 개발자입니다 .

이것에 부분적으로 영감을 얻은 질문 .

결과

실망스럽게도, 나는이 항목에 대해 어떤 의견도 얻지 못했습니다. 그들은 모두 굉장합니다, 그래서 당신은 내 마음에 모든 승자입니다. 그러나 Loktar는 긴 투표로 가장 많은 표를 얻었으므로 수락에서 +15를 얻습니다. 축하합니다!


6
우승 기준은 무엇입니까, 인기 대회 ?
Kyle Kanos 2018 년

36
그렇다면 ... 답변을 테스트하면 실제로 해고되면 어떻게 되나요?

54
이것은 또 다른 코드 골프 질문에 대한 아이디어를 제공합니다. "내 질문을 보류하지 말아야 할 것"
twiz

9
이 프로그램 중 하나를 작성 하고 컴파일하십시오 !
ugoren

13
나는 다른 날 Github의 Tron 레거시 회의실을 정말 잘 리메이크했습니다. github.com/arscan/encom-boardroom
Paul Prestidge

답변:


291

자바 스크립트

그래서 나는 이것에 약간 미쳤다. Visual Basic을 사용하여 IP 작업을 추적하기 위해 GUI에서 작업하는 사이에 휴식을 취했습니다.

오늘 밤 내가 만든 매우 진지한 도메인으로 이동하면 Gui Hacker 와 포크를 어디에서나 바쁘게 볼 수 있으며 다음 소스에서 나만의 도메인을 만들 수 있습니다.

기본적으로, 당신이 이것을 실행한다면 그들은 당신이 심각한 일을하고 있다는 것을 알고 있기 때문에 아무도 당신을 귀찮게하지 않을 것입니다.

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>


47
그림 / 유지 보수 담당자는 내가 음악을 듣는 사람이 아니라 프로그래머라는 것을 깨달았습니다. 이것이 기술자에 의해 일부 시험에서 살아남을 수 있을지 궁금합니다. : P
sabithpocker

17
나는 나의 새로운 스크린 세이버로 그것을 원한다 !! 사실, 우분투에서 어떻게 할 것입니까?

33
나는이 공개와 함께 토론토 공공 도서관에 앉아 있었고 내 뒤에있는 사람들이 내 스크린을보고있는 것을 보았습니다. 이것은 비 기술적 인 사람에게는 꽤 '무서워 보인다'. guihacker.com에서 페이지 제목을 원하는대로 변경할 수 있고 녹색 텍스트로 표시 될 고유 한 행을 추가 할 수 있습니까? 'Toronto Public Library Internet Access'페이지의 제목을 만들고 녹색 줄에 'Toronto Public Library Security Database에 액세스하는 중 ...', '사용자 이름 및 암호에 액세스하는 중 ...', '접근이 허가되었습니다.' 문제가 생겼지 만 재미있을 것입니다.
user2719875

37
동료 개발자가 내가 해킹하고있는 것을 묻기 전에 30 초 동안이 문제가 발생했습니다. 나는 이것이 성공으로 간주되므로 +1
MrTheWalrus

10
"TPS 보고서"... 훌륭합니다.
데니스

111

배쉬 / coreutils

최초의 컴파일 에뮬레이터를 소개합니다 . 이 프로그램을 사용하면 언제든지 코드를 작성하지 않고도 서사시 사무용 의자 검 전투를 할 수 있습니다!

#!/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

데이터 /usr/include를 사용하여 사실적인 컴파일 로그를 만듭니다. 나는 무작위 경고를 던지기에는 너무 게으르다. 그래서 -w깃발 만있다 .

무작위 표본:

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 libiptc. 그래서
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-공유 e2p / e2p.o -o e2p.so
gcc -w-파이프 -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-파이프 -O0 -msse -msse2 -m64 -c spice-client-gtk-2.0 / spice-grabsequence.c -o spice-client-gtk-2.0 / spice-grabsequence.o
gcc -w-파이프 -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-파이프 -O0 -msse -msse2 -m64 -c spice-client-gtk-2.0 / spice-widget.c -o spice-client-gtk-2.0 / spice-widget.o
gcc -w-파이프 -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-공유 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-파이프 -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 / scaledfont.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 / 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 / quartz_font.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_font.c -o cairomm-1.0 / cairomm / win32_font.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 / refptr.c -o cairomm-1.0 / cairomm / refptr.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 / cairomm.c -o cairomm-1.0 / cairomm / cairomm.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 / context.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.0 / cairomm / win32_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 / 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.0 / cairomm / quartz_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 / exception.c -o cairomm-1.0 / cairomm / exception.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 / xlib_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 / fontoptions.c -o cairomm-1.0 / cairomm / fontoptions.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 / 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 -shared cairomm-1.0 / cairomm / cairomm.o cairomm-1.0 / cairomm / context.o cairomm-1.0 /cairomm/device.o cairomm-1.0 / cairomm / enums.o cairomm-1.0 / cairomm / exception.o cairomm-1.0 / cairomm / fontface.o cairomm-1.0 / cairomm / fontoptions.o cairomm-1.0 / cairomm / matrix. 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

4
나쁘지 않아! 이것에 대해 뭔가 옳지 않은 느낌 (HD가 완전히 조용합니까?)을 모르는 시청자에게는 의심을 제기 할 가능성이 거의 없습니다. 비록 ... 뭐, 컴파일 중 libdrm입니까? 그리고 sys/wait.o?? 무엇…
카운터 시계를 돌리기 중지

27
@leftaroundabout SSD가 있다고 가정하십시오.
mniip

36
보다 정통하게하려면 gcc 라인 당 여러 번 가짜 컴파일러 경고를 출력해야합니다. :)
monocell

3
pkg-config를 사용하여보다 현실적인 가짜 gcc 플래그를 얻을 수 있습니다.
Brendan Long

3
@WChargin은 HD를 활성화하지 않습니다.
Thorbjørn Ravn Andersen

106

세게 때리다

원시 데이터에서 복잡한 검색을 수행하는 것처럼 느끼도록 임의의 16 진수 값을 무한대로 표시합니다.

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

여기에 이미지 설명을 입력하십시오


6
우, 이거 좋아 !
SomeKittens

4
(내가 bash를 처음 접했을 때)하지만이 줄을 실행하면 (mac osx, 터미널) 루프 에서이 출력을 얻습니다.od: illegal option -- w usage: od [-aBbcDdeFfHhIiLlOosvXx] [-A base] [-j skip] [-N length] [-t type] [[+]offset[.][Bb]] [file ...]
Sterling Archer

2
사용중인 버전이 옵션을 od지원하지 않는 것 같습니다 -w. 이 옵션을 삭제하면 더 많은 데이터 열을 표시하고 화면을 조금 더 채울 수 있습니다.
barjak

8
개인적으로으로 sleep 0.5변경하여 선호 합니다 sleep.$[$RANDOM % 10]. 그것은 조금 까다 롭고 실제 검색과 비슷합니다. 그래도 좋아합니다!
undergroundmonorail

4
"ca fe"에 대한 끝없는 검색을 상기 cat /dev/random | hexdump | grep "ca fe"
시킵니다

102

매우 긴 빌드 :

emerge openoffice

48
; _;
mniip

3
크롬보다 더 오래?
nyuszika7h

6
실제 프로젝트를 컴파일하는 데 문제가 발생하면 오류가 발생하면 중지됩니다. 아마도 우리는 이것을 무한 루프에 넣어야합니다.
야마모토 아키라

3
우리는 리눅스 민트에서 등장 합니까?
야마모토 아키라

3
우분투와 민트 같은 뎁 시스템에서 원하는 sudo apt-get build-dep libreoffice; apt-get source libreoffice; cd libreoffice*; while :; do nice dpkg-buildpackage -rfakeroot; done(. 당신은 실제 컴파일 이후 실행 만 필요 시작 전까지는 그 첫 번째 실행에 보모해야합니다 while루프.)
아담 카츠

55

루비

이것은 :

  1. 이 사이트 에서 임의의 코드를 얻으십시오 . 코드 검토 (더 읽기 쉽고 잘 작성된 코드)
  2. 이 코드를 입력하는 것처럼 보이게하십시오.
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

이 스크립트는 여기 에서 가져온 코드를 기반으로합니다 .

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

그 모습은 다음과 같습니다. 암호


11
그것이 얻는 코드가 Brainf ** k, Golfscript 또는 J라면 어떨까요?
user80551

39
마지막으로 지불 주위에 백도어를 추가하는 신중하게 배치 된 답변
PlasmaHH

1
아마도 stackoverflow가 더 좋을까요?
PyRulez 2016 년

3
sleep줄을 로 변경하여 속도를 무작위로 지정하고 더 빠르게 만들면 각 문자의 타이핑 속도가 더 사실적으로 보입니다 sleep rand(10).to_f / 30.
Rory O'Kane

3
Code Golf에서 코드 검토 코드를 사용하는 것이 완벽하다고 생각합니다. 나는 항상 Code Golf을 Code Review의 사악한 쌍둥이라고 생각했으며 두 가지 모두를 좋아합니다.
trichoplax

52

간단한 bash 스크립트를 사용하면 / var / log /에서 텍스트로 식별 된 모든 파일의 내용을 한 줄씩 인쇄하여 해커처럼 보이게 할 수 있습니다. 적중 된 파일에 따라 다소 흥미로운 결과를 제공 할 수 있습니다.

#/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

터미널 테마가 해커처럼 보이는지 확인하십시오. 다음은 몇 가지 나쁜 예입니다 (이것의 의미가 무엇인지 모르지만 해커처럼 보입니다).

영상 영상


3
잘 했어요 스크린 샷 예보기
SomeKittens

37
개인 키가이 스크린 샷에 있다는 것을 알고 있습니까?
Hubert OG

27
하하! ;-)
Hubert OG 2

4
(그러나 진지하게, 나는 그 스크린 샷을 읽지 않았으므로 실제로 무엇이 있는지 모릅니다.)
Hubert OG

3
@HubertOG 와우, 당신은 나에게 거의 심장 마비를 일으켰다 ...; PI는 어디서도 그것을 보지 못해서 내가 미쳤다고 생각했다 : O
Jwosty

49

배쉬 : 끝없는 자식 커밋

오늘날 컴퓨터의 문제점은 컴퓨터가 매우 빠르기 때문에 컴파일 작업도 결국 완료된다는 것입니다. 또한 오랫동안 실행되는 스크립트가 주어지면 스크립트가 실행되는 동안 실제로 다른 작업을 계속할 수 있다고 주장 할 수 있습니다.

이를 해결하기 위해 다음과 같은 프로그램이 있습니다. 가끔씩 'y'또는 'n'을 무작위로 입력하는 법을 배우십시오.

물론 새로운 내용이 담긴 git repo가 ​​필요하지만 때로는 문제가되지 않는 실제 작업을 가정한다고 가정합니다.

#!/bin/bash

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

12
이 CG 항목으로 인해 가장 심각하게 느끼고 있습니다. +1 또는 -1이지만 여전히 어느 것을 모릅니다!
vaxquis

37

세게 때리다

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

이것은 repos를 계속 업데이트합니다. 어떤 사람이 눈치 채면, 새로운 프로그램에 대해 새로운 저장소를 추가했고 다른 프로그램을 테스트하고 있다고 말하십시오. 스크립트를 가짜처럼 만드는 것이 아니라 명령입니다.

참고 : 나는 직장에서 비생산적 인 것을 용납하지 않지만 실험을 좋아합니다. 따라서 저는 이 앱 을 비밀리에 생산적으로 사용하는 것이 좋습니다 .


5
좋지만 재귀 함수를 조심하십시오.
디지털 외상

1
포크 폭탄처럼 보인다!!
Avinash R

2
@AvinashR 포크가 아닙니다.
PyRulez 2016 년

43
미러 호스트는 지금 당신을 싫어합니다.
Caleb

9
"정말, 포크가 없습니다." 폭탄 만? :-)
celtschk 2018 년

28

C ++ 신경망

편집하다

슬프게도이 코드를 최적화했습니다 : (2000x 빨라졌습니다 ... 레거시 코드는 여전히 시간 낭비에 완벽합니다!

기발한

나는 실제로 이것에 완벽한 컨볼 루션 신경 네트워크에서 프로젝트를 시작했습니다! 소스 코드와 문서는 github에 있습니다. 첫 번째 단계는 새로운 네트워크를 만드는 것입니다.

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>>());

이제 300 개의 뉴런과 1,250,000 개의 시냅스를 가진 네트워크가 생겼으므로 파일로 저장하여 네트워크의 진행 상황을 잃지 않도록하십시오.

neuralNetwork.SaveToFile("test2.cnn");

이것은 68MB의 텍스트 파일과 몇 시간 이상의 편안한 작업을 생성했습니다. 이제 재미있게 일을 해보자! 임의의 입력을 만들어 구별하기 시작합니다.

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);

그것은 이미지에 대한 아주 작은 입력이지만, 우리는 네트워크가 무언가를 할 수 있음을 증명하고 있습니다. 다음 단계는 차별하는 것입니다!

Layer output = neuralNetwork.Discriminate();

이것은 아직 끝나지 않았으며 2 일 넘게 달렸습니다! 그런 다음 출력을 얻었 으면 재미를 위해 다시 거꾸로 실행 해 봅시다.

Layer generatedOutput = neuralNetwork.Generate(output);

이것은 API가 작동한다는 것을 증명하기위한 것이며 아직 계획이 없습니다. 이 단계는 아직 실행되지 않았으며 잠시 기다렸습니다. 2 일 이상은 불타 버렸는데, 현재 테스트에서 대략적인 수치입니다. 이것은 매우 복잡하며 하루나 이틀 동안 열심히 일하지만 그 후에는 다시는 일할 필요가 없습니다!

참고 : 다시 작업하고 싶지 않은 경우 네트워크 교육을 시도하십시오.

neuralNetwork.LearnCurrentInput();

나는 이것을 위해 낭비 할 시간조차 없다!

발생하는 모든 데이터를 표시하려면 함수에 일부 호출을 추가하여 발생하는 상황을 표시하십시오.

새로운 생성자

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);
}

새로운 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;
}
}

이제 콘솔에서 많은 출력을 얻을 수 있습니다.


4
실제 상황에서도 +1입니다. 재미있는 :)
George

1
Hahahaha 이니셜 철자 "CNN"
Nic Hartley

26

파이썬 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)

보다 사실적인 것처럼 보이기 위해 가짜 "로드"시간 (지연)과 함께 가짜 JS 및 HTML 라인을 출력합니다.

이것은 크게 확대 될 수 있습니다! (기본 프로그램이 있습니다; 지금 콘텐츠를 더 추가해야합니다)


다음은 생성 된 샘플 "페이지"입니다 (이것은 실제로 이전 버전의 코드에서 온 것입니다. 완료되면 새 코드로 업데이트합니다).

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>

3
굉장합니다. 추가 한 내용을 기다릴 수 없습니다!
SomeKittens

응 이건 꽤 킥 엉덩이 야 내 마음은 당신이 세대와 함께 할 수있는 멋진 일들로
열광합니다

python3뿐만 아니라 2.7도 괜찮습니다
Hannes Karppila

1
잘 했어. 꽤 사실적으로 보입니다.
qwr

24

Node.js + BDD

끝없는 BDD 스타일 테스트 스트림처럼 보입니다. 아무도 테스트를 실행한다고 당신을 비난 할 수 없습니다!

    "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()

최신 정보

모든 테스트가 통과되면 의심스러워 보일 수 있으므로 Given-When-Thens와 함께 일부 실패한 테스트를 포함하도록 업데이트했습니다.

그리고 네, 모든 실패가 같은 메시지를 가지고 있다는 것을 알고 있습니다. 로그 아웃 링크를 수정해야합니다!

여기에 이미지 설명을 입력하십시오


2
매우 영리하며 코드를 테스트 할 때 보너스 포인트를받습니다! 너무 조심하세요
SomeKittens 2016 년

23

C # (Windows)

나는 당신에게 새로운 Memtest86 Simulator 2014를 선물합니다 ! (Windows에서 Memtest86을 실행하는 것이 좋습니다.)

작업 진행률 표시 줄과 패턴 표시기로 완성하십시오!

이 코드는 콘솔 클래스를 광범위하게 사용하며, 아는 한 Windows에서만 사용할 수 있습니다. 또한 실제 프로세서 이름 / 빈도 및 사용 가능한 메모리를 표시하는 방법을 찾지 못해 하드 코드되었습니다.

스크린 샷 : 여기에 이미지 설명을 입력하십시오

편집하다

프로세서 정보를 검색하기 위해 Microsoft.Win32 네임 스페이스 및 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");
            }
        }

코드 (추악한 것입니다) :

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++;
        }
    }
}

7
왜 Memtest86을 실행하지 않습니까? "여기에 하드웨어에 문제가 있다고 생각합니다. 완료 될 때까지 중단해야한다고 생각합니다."
MadTux

20
@MadTux 'Cos 당신은 Memtest로 부팅해야합니다.
Schilcote 2016 년

1
System.Console은 Mono에서 작동합니다. 임의의 콘솔 창 크기에 맞게 코드를 조정하면됩니다.
NothingsImossible

8
VM에서 Memtest86을 실행할 수 없습니까?
Cole Johnson

3
나는 VM 아이디어에서 Memtest를 좋아합니다.
John


14

AHK

스크립트에서 JavaScript로 많은 접근 자와 뮤 테이터를 생성하는 동안 입력하는 것처럼 가장합니다. IDE (Notepad ++에서 이것을 테스트했습니다)가 활성 창인지 확인하십시오.

원하는 경우 변수 및 클래스 이름 목록을 지정하십시오. 방금 이미 있던 것을 사용했습니다 window.location.

esc를 눌러 종료하십시오.

누군가 대화를 시도 할 때 일시 중지하려면 숫자 키패드에서 0을 누르십시오.

ctrl + w (w는 작업을 나타냄)를 눌러 시작하십시오.

^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

14

세게 때리다

임의의 물리적 메모리 블록을 덤프하고 내용을 확인합니다. 이를 위해서는 근본이되어야합니다. 만 메모리의 첫 번째 1메가바이트은 기본적으로 사용할 수 있습니다. dd기본 블록 크기는 512 바이트이며 옵션을 사용하여 변경할 수 ibs=bytes있지만 skip=$offset블록을 임의로 선택하는 다른 옵션 을 명심하십시오 . 비 ASCII 문자를 제거하기 위해 출력 dd이 전송됩니다 tr. 2 자 이상의 고유 결과 만 평가됩니다.

찾은 각 문자열은 사전과 비교됩니다. 일치하는 것이 없으면 base64로 디코딩을 시도합니다. 마지막으로 평가 된 모든 문자열이 반환됩니다.

사전 파일 (/ usr / share / dict / words)의 위치, 휴면이 부동 소수점 입력을 허용하는지 여부 및 사용 가능한지 여부와 같이 알아야 할 다른 플랫폼 종속 옵션이 몇 가지 base64있습니다.

또한 dd/ dev / null로 파이프 된 stderr에 수행 된 작업에 대한 통계 를 출력합니다. 무언가 잘못 되었다면 (/ dev / mem에 액세스하고 있습니다) stderr 출력이 보이지 않습니다.

전반적으로 유용하지는 않지만 리눅스 메모리에 대해 조금 배웠고이 스크립트를 작성하는 것이 재미있었습니다.

#!/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

때로는 흥미로운 결과가 없습니다 (모두 0). 때로는 몇 개의 문자열 만 있습니다 :

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

때로는 실제로 메모리에 사람이 읽을 수있는 무언가가 있습니다 (블록 오프셋을 로깅하기 전에).

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

그리고 잘못된 grep 입력, 사전 적중 및 성공적인 base64 디코드를 보여주는 마지막 샘플 실행 (블록 오프셋을 다시 로깅하기 전에) :

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

이것을 어떻게 운영합니까? 나는 그것을 버리고 script.sh, chmod +x그것을했지만, 그냥 종료됩니다. sudo도움이되지 않습니다.
Octavia Togami

mem=회선이 아무것도 반환하지 않는 것처럼 들립니다. 파이프 간 명령의 각 부분이 실제로 무언가를 반환하는지 확인하고 확인해야합니다.

알겠습니다.
Octavia Togami 2018 년

이것은 처음 5 초 정도만 실행되었고 12 줄처럼 인쇄 된 다음 출력 할 때마다 매번 0.1 초처럼 인쇄되었습니다.
Mike

13

윈도우 배치

@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%
)

이것은 90 년대 해커 영화에서 보이는 것처럼 보이기 위해 몇 년 동안 저와 함께했던 농담 스크립트입니다. 나는 보통 사람들을 놀라게하기 위해 컴퓨터에 원격으로 연결되어있는 동안 사용합니다.


2
그는 전체 시스템에 바이러스를 다운로드하고 있습니다!
qwr

12

세게 때리다

끝없는 카페 검색.

나는 오래 전에 웹에서 이것을 발견했다.

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

대신 urandom을 사용하십시오.
Alice Ryhl

아 ... 난 맥에 그것을 테스트, 그리고 맥은 모두 가지고 randomurandom.
daviewales

5
/dev/random존재하지만 /dev/urandom엔트로피가있는 경우에만 숫자를 생성하는 것보다 더 안전 합니다. 다 떨어지면 중지됩니다. /dev/urandom그렇게하지 않으며 출력을 멈추지 않습니다.
undergroundmonorail

왜 끝나지 않습니까? 오늘 두 번째로 바보 같아요
Daniel W.

1
/dev/urandom난수를 지속적으로 공급하는 '파일'입니다 cat. cat다음에 파이프 hexdump등 을 연결합니다 .
daviewales

11

파이썬 2.7

끝없는 테스트 스위트

디렉토리 트리의 모든 파일에서 "단위 테스트"세트를 "실행"합니다. 모든 서브 디렉토리를 순회합니다. 끝날 때 다시 시작합니다.

실행 상태를 인쇄합니다.

============================= 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 ===========================

...

필요 이상으로 복잡하고 더 현실적으로 만드는 기능 :

  • 테스트 횟수와 테스트 시간은 파일 크기에 비례합니다.
  • 비 소스 코드 파일 확장자를 알려진 확장자로 변환합니다. CodeExtensions알려진 유형을 더 추가하도록 수정 하십시오.
    • 실제 언어 파일의 빈도에 따라 새 확장명을 선택하므로 하드 드라이브에 Ruby가 가득 차면 Python 코드를 테스트하는 것을 볼 수 없습니다.
  • . "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)

1
대부분의 Python 설치와 함께 제공되는 Python 회귀 테스트를 실행할 수도 있습니다.
nneonneo 2016 년

그러나 결국은 끝납니다.
AShelly

2
그런 다음 루프에서 실행할 수 있습니다!
nneonneo 2016 년

1
또한 파이썬 소스를 테스트하는 것보다 프로젝트와 관련된 이름으로 파일을 테스트하는 것이 덜 의심 스럽다고 생각합니다. 나는 우리 대부분이 전문적으로 파이썬을 유지하지 않는다고 생각합니다.
AShelly

11

Java + Guava 16 (구아바는 그다지 필요하지는 않지만 작성하기가 다소 성가신 것입니다).

알았어, 일하는거야? 실제로 실제 Java 코드를 작성하고 실제로 컴파일하는 프로그램은 어떻습니까?

애니메이션을 시연하기는 어렵지만이 프로그램은 기본 사전 (250 개의 일반 영어 단어) 또는 줄 바꿈으로 구분 된 파일 (명령 줄 인수로 사용)을 사용하여 Java 프로그램을 작성하고 한 번에 한 문자 씩 콘솔 에 입력합니다. 인간처럼 보이는 속도로 . 이 게시물은 정의가 없으므로 직접 실행해야합니다. 완료되면 1 분 정도 기다린 다음 많은 빈 줄을 콘솔에 인쇄하고 다시 시작합니다. 다양한 매개 변수를 합리적으로 조정할 수 있도록 작성하려고했습니다.

또한 일반적 으로이 파일을 둘 이상의 파일에 넣었지만 실행하기 쉽도록 모든 클래스를 함께 밀었습니다.

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;
        }
    }
}

샘플 프로그램 출력 (단 하나의 프로그램)

public class GetGroup {
    private final double thoughRight;
    private final double socialYear;
    private final double manOne;
    private final int appear;

    private double man;
    private double comeHis;
    private double certain;

    public GetGroup(double thoughRight, double socialYear, double manOne, int appear) {
        this.thoughRight = thoughRight;
        this.socialYear = socialYear;
        this.manOne = manOne;
        this.appear = appear;
    }

    public double getThoughRight() {
        return thoughRight;
    }

    public double getSocialYear() {
        return socialYear;
    }

    public double getManOne() {
        return manOne;
    }

    public int getAppear() {
        return appear;
    }

    public double getMan() {
        return man;
    }

    public double getComeHis() {
        return comeHis;
    }

    public double getCertain() {
        return certain;
    }

    public void setMan(double man) {
        this.man = man;
    }

    public void setComeHis(double comeHis) {
        this.comeHis = comeHis;
    }

    public void setCertain(double certain) {
        this.certain = certain;
    }
}

다른 샘플 출력 :

public class TryControl {
    private final int over;
    private final double thatState;
    private final long jobInto;
    private final long canPut;

    private int policy;
    private int neverWhile;

    public TryControl(int over, double thatState, long jobInto, long canPut) {
        this.over = over;
        this.thatState = thatState;
        this.jobInto = jobInto;
        this.canPut = canPut;
    }

    public int getOver() {
        return over;
    }

    public double getThatState() {
        return thatState;
    }

    public long getJobInto() {
        return jobInto;
    }

    public long getCanPut() {
        return canPut;
    }

    public int getPolicy() {
        return policy;
    }

    public int getNeverWhile() {
        return neverWhile;
    }

    public void setPolicy(int policy) {
        this.policy = policy;
    }

    public void setNeverWhile(int neverWhile) {
        this.neverWhile = neverWhile;
    }
}

9
코드 라인으로 여전히 지불하는 사람을 위해 완전 자동 돈 인쇄기를 만들었습니다.
Philipp

9

세게 때리다

임의의 간격으로 임의의 소스 파일에서 일부 주석을 출력 한 다음 무작위로 생성 된 수행 없음 진행 표시 줄을 출력하십시오.

#!/bin/bash

# The directory to extract source comments from
srcdir=~/src/php-src/

# Generate a status bar that lasts a random amount of time.
# The actual amount of time is somewhere between 1.5 and 30
# seconds... I think. I fudged this around so much it's hard to tell.
function randstatus() {
    bsize=4096
    r_rate=$(echo "$RANDOM/32767 * $bsize * 1.5 + $bsize / 4" | bc -l | sed 's/\..*$//')
    r_min=3
    r_max=15
    r_val=$(($r_min + $RANDOM % $(($r_max - $r_min)) ))
    i=0
    dd if=/dev/urandom bs=$bsize count=$r_val 2> /dev/null | pv -L $bsize -s $(($r_val * bsize)) > /dev/null
}

# Picks a random .c file from the given directory, parses
# out one-line comments, and outputs them one by one with a
# random delay between each line.
function randout() {
    r_file=$(find $1 -name '*.c' | sort -R | head -n 1)
    echo "# $r_file"
    grep '^\s*/\*.*\*/\s*$' $r_file | sed 's:[/\*]::g' | sed -e 's:^\s\+::' -e 's:\s\+$::' | sed -e 's:^\W\+::' | grep -v '^$' | while read line; do
        echo $line
        sleep $(printf "%0.2f" $(echo "$((($RANDOM%4)+1))/4" | bc -l))
    done
}

while true; do
    randout $srcdir
    randstatus
    # sleep here to make it easier to break out of the 'while read' loop
    sleep 2
done

산출:

# /home/jerkface/src/php-src/sapi/fpm/fpm/fpm_shm.c
Id: fpm_shm.c,v 1.3 20080524 17:38:47 anight Exp $
c) 2007,2008 Andrei Nigmatulin, Jerome Loyet
MAP_ANON is deprecated, but not in macosx
  32kB 0:00:08 [3.97kB/s] [====================================================================>] 100%
# /home/jerkface/src/php-src/ext/mbstring/mb_gpc.c
Id$
includes
mbfl_no_encoding _php_mb_encoding_handler_ex()
split and decode the query
initialize converter
auto detect
convert encoding
we need val to be emalloc()ed
add variable to symbol table
SAPI_POST_HANDLER_FUNC(php_mb_post_handler)
  12kB 0:00:03 [4.02kB/s] [===============>                                                      ] 24% ETA 0:00:09

1
영리한! 더 많은 관심을 받기에는 조금 늦었지만 저에게 하이 파이브를 받으십시오.
SomeKittens

이 스크립트의 진정한 천재는 노력하는도 보이는 것입니다 @SomeKittens 실제 작업처럼. ; D
Sammitch

7

재 동기화 양식 BASH

 rsync -n -avrIc --verbose  ~ ~ | sed s/"(DRY RUN)"/""/g    
# Note the space at the beginning of the above line,

rsync- 빠르고 다재다능한 원격 (및 로컬) 파일 복사 도구입니다 . -n을 사용 하여 드라이 런을 수행하고 수행 만하고 실제로 수행하지 않으며 수행되는 작업 만 표시합니다.
이 경우 홈 디렉토리 (및 하위 폴더 )의 모든 파일을 업데이트할지 확인하십시오.
물론 루트 액세스 권한이 있으면 파일 시스템의 더 큰 부분에서 실행할 수 있습니다.

노트:

  1. 만약 HISTCONTROL=ignoreboth또는 적어도 HISTCONTROL=ignorespace당신의 bash는 세션 당신의 bash는 역사 이전에 공백을 작성하는 경우 해당 명령을 기억하지 않습니다. ( 히스토리 로그 또는 화면에서 푸시 업하여 볼 수 없습니다 .)
  2. | sed s/"(DRY RUN)"/""/grsync 출력의 끝에서 텍스트를 sed지우는 출력을 통해 파이프합니다 (DRY RUN). 전문가가 확인하면 테스트뿐만 아니라 실제로 그렇게한다고 말할 수 있습니다.
  3. -avrIc당신은 그 옵션을 변경하고, 체크 할 수 man rsync있지만, 절대로 제거하지 않을 수 있습니다-n . 그렇지 않으면 루트로 실행하면 더 심각한 문제가 발생합니다 ... 8-O!

6

강타 아래 메이븐

Maven은 이런 종류의 작업에 완벽합니다. ;-)

while true;
do mvn -X archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-app -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false;
done

6

코브라

그러면 다양한 가짜 개체와 여러 가지 항목을 반복하여 패스가 증가하고 각 패스가 진행되는 콘솔 창이 열립니다. 실제 계산 지연을 시뮬레이션하기 위해 각 증분마다 작은 임의 시간을 기다립니다.

class Does_Nothing_Useful
    var _rng as Random = Random()
    var _hash
    var _pass
    var _names as String[] = @['Vector', 'Object', 'File', 'Index', 'Report', 'Library', 'Entry', 'Log', 'Resource', 'Directory']
    def main
        while true
            .refresh
            name as String = _names[_rng.next(_names.length)] + ' ' + _hash.toString
            for i in _pass
                progress as decimal = 0
                while progress < 100000
                    progress += _rng.next(1000)
                    print name + '; pass', i, ' : ', progress/1000
                    wait as int = 0
                    for n in _rng.next(50), wait += _rng.next(1,100)
                    System.Threading.Thread.sleep(wait)
                print name + '; pass', i, '--FINISHED--'
                print ''
                System.Threading.Thread.sleep(_rng.next(1000,17500))
            print name, '--EVAL COMPLETE--'
            print ''
            System.Threading.Thread.sleep(_rng.next(12500,30000))
    def refresh
        _hash = _rng.next.getHashCode
        _pass = _rng.next(256)
        print '--LOADING NEXT TARGET--'
        print ''
        System.Threading.Thread.sleep(_rng.next(12500,30000))

1
주말 내내이 문제를 해결하기 위해 시간을 내십시오.
SomeKittens

1
이 코브라 언어는 무엇입니까, 그것은 파이썬과 C #의 나쁜 자식처럼 보입니다. haha ​​(이것은 흥미로운 기능을 가지고있는 것 같습니다), +1
Thomas

1
@Thomas 대부분의 경우 Python과 같은 구문을 사용하는 C # (현재 LINQ 없음)입니다. 그리고 내가 사용해 본 가장 유용한 기본 컴파일러 중 하나입니다.
OUurous

이 코드를 완성한 적이 있습니까?
rayryeng

4

나는 이것을 한 번 바보 같은 파이썬 스크립트를 썼다. "ProgramAboutNothing"이라고 불렀습니다. 설득력이 있는지 확실하지 않지만 약 10 분 밖에 걸리지 않았습니다. 그것은 아마도 그것이하고있는 일을 설명하는 임의의 문장을 출력합니다 ... 아마도 더 설득력있는 것처럼 보일 수있는 더 나은 단어를 선택할 수 있었지만 실제로는 제대로 사용하지 못했습니다. 누군가가 그것을 사용하고 싶다면 그것을 편집하고 목록에 자신의 단어를 추가 할 수 있다고 생각합니다 ... Sim City의 팬들은 익숙한 것을 알 수 있습니다. :피

from random import randrange
from time import sleep

nouns = ["bridge", "interface", "artifact", "spline"]
verbs = ["building", "articulating", "reticulating", "compiling", "analyzing"]
adjectives = ["mix", "abstract", "essential"]

while True:
    one = randrange(0,5)
    two = randrange(0,4)
    print "%s %s" % (verbs[one], nouns[two]),
    sleep(randrange(0,500)/100)
    print ".",
    sleep(randrange(0,500)/100)
    print ".",
    sleep(randrange(0,500)/100)
    print ".\n",
    loop = randrange(0,50)
    one = randrange(0,5)
    for i in range(loop):
        two = randrange(0,4)
        three = randrange(0,3)
        print "%s %s %s" % (verbs[one], nouns[two], adjectives[three]),
        sleep(randrange(0,250)/100)
        print ".",
        sleep(randrange(0,250)/100)
        print ".",
        sleep(randrange(0,250)/100)
        print ".\n",

1
아마도 파이썬 3을 사용하고 있습니까? 다음과 같이 인쇄 문 주위에 괄호를 추가하십시오 print( ... ).
daviewales

1
@daviewales ninja'd : P
누가

1
@Luke Python 3.4.1Windows에 방금 설치 했습니다. 나는 파이썬으로 프로그래밍 할 수 없지만 당신의 작은 프로그램에 관심이 있습니다 ...
Mathlight

1
@Mathlight는 당황 할 준비를합니다. : P
누가

1
@luke, 지금 작동합니다. ^ _ ^
Mathlight

4

이건 어때? 1 초마다 codegolf HTML 데이터를 다운로드합니다. 따라서 새로운 질문이 들어 오면 데이터는 계속 변경됩니다. 동시에 웹 사이트에서 중요한 데이터를 다운로드하는 것처럼 나타납니다.

while true; do     
sleep 1;     
curl "codegolf.stackexchange.com" -s |  w3m -dump -T text/html; 
done

3

세게 때리다

재귀 디렉토리 목록 :

ll -R /

2

이것은 C ++ 컴파일러 시뮬레이션 (C #으로 작성)입니다.

using System;
using System.Collections.Generic;
using System.Management;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.IO;
using System.Reflection;

class FakeCompiler {
    static void DoPrint(string txt) {
        Console.WriteLine("Compiling " + txt);
        Thread.Sleep(1000);
    }
    static string Extract(string TypeName) {
        string rt = TypeName.Split(new Char[] {'.'})[ TypeName.Split(new Char[] {'.'}).Length - 1 ];
        if (rt.Contains("+")) {
            rt = rt.Split(new char[] { '+' })[1];
        }
        if (rt.Contains("[")) {
            rt = rt.Split(new char[] { '[' })[0];
        }
        return rt;
    }
    static void DoCompileSingleFile(string _Type_Name) {
        string print = Extract(_Type_Name);
        DoPrint(print + ".h");
        DoPrint(print + ".cpp");
    }
    static Type[] DoFakeCompile_Assembly(string _AssemblyFileName) {
        System.Reflection.Assembly _asm = System.Reflection.Assembly.Load(_AssemblyFileName);
        Type[] _ts = _asm.GetTypes();
        for (int h = 0; h < 15; ++h) {
            DoCompileSingleFile(_ts[h].ToString());
        }
        return _ts;
    }
    static void DoFakeLinkErrors(Type[] t) {
        Console.WriteLine("linking..");
        Thread.Sleep(2000);
        MethodInfo[] mi;
        for (int i = 0; i < t.Length; ++i) {
            mi = t[i].GetMethods();
            for (int j = 0; j < mi.Length; ++j) {
                Console.WriteLine("Link Error: The object {@!" + mi[j].ToString().Split(new char[] {' '})[0] + "#$? is already defined in " + Extract(t[i].ToString()) + ".obj");
                Thread.Sleep(200);
            }
        }
    }
    static void Main(string[] args) {
        Console.WriteLine("Fictional C/C++ Optimizing Command-line Compiler Version 103.33.0");
        DoFakeLinkErrors(DoFakeCompile_Assembly("mscorlib.dll"));
    }
}


2

일괄

파일이 많은 폴더에 넣습니다. 충분히 빠르게 스크롤되면 아무도 의심하지 않습니다.

:l
dir/s
echo %RANDOM%
echo %RANDOM%
echo %RANDOM% 
goto l

당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.