DouKaku?

require 'curses'
require 'timeout'

def inputChecker(n, str)
  Curses.init_screen
  Curses.setpos(0, 0)
  Curses.addstr("input(#{str}) => ")
  Curses.refresh

  result = nil

  begin
    input = ""
    c = Curses.getch.chr

    timeout(n){
      until c == "\n"
        input += c
        c = Curses.getch.chr
      end

      result = input == str ? "OK" : "NG"
    }
  rescue Timeout::Error
    result = "TIME OUT"
  end

  Curses.setpos(1, 0)
  Curses.addstr("result => #{result}")
  Curses.refresh
end

inputChecker(5, "ABCDEF")

| inputChecker |
inputChecker := [:timeLimitSec :expecStr |
	| char stream start resultMsg initPosition |
	stream := WriteStream with: 'input(', expecStr, ') => '.
	initPosition := stream position.
	start := nil.
	[   stream contents, ' ' displayAt: Sensor cursorPoint + 10 asPoint.
		[Sensor keyboardPressed] whileFalse.
		(char := Sensor keyboard) = Character cr
	] whileFalse: [
		start ifNil: [start := Time millisecondClockValue].
		char == Character backspace
			ifTrue: [stream position: (stream position - 1 max: initPosition)]
			ifFalse: [stream nextPut: char]].
	resultMsg := (Time millisecondClockValue - start) / 1.0e3 <= timeLimitSec
		ifFalse: ['TIME OUT']
		ifTrue: [(stream contents last: expecStr size) = expecStr
			ifTrue: ['OK'] ifFalse: ['NG']].
	#result -> resultMsg].

inputChecker value: 5 value: 'ABCDEF'

module Main (main) where

import System.Environment
import System.IO
import System.Timeout

main :: IO ()
main = do { prog <- getProgName
          ; args <- getArgs
          ; case args of
              t:str:_ -> loop 3 (inputChecker (read t) str)
              _       -> usage prog
          }

loop :: Int -> IO () -> IO ()
loop 0 _ = return ()
loop n f = f >> loop (n-1) f

usage :: String -> IO ()
usage prog = hPutStrLn stderr $ prog ++ " <timeout> <string>"

inputChecker :: Int -> String -> IO ()
inputChecker t s
 = do { hPutStr stderr $ "input(" ++ s ++ ") => "
      ; hSetBuffering stdin NoBuffering
      ; c <- hGetChar stdin
      ; ms <- timeout (t*1000000) (hGetLine stdin)
      ; case ms of
          Nothing -> hPutStrLn stdout "\n result => TIME OUT" >> hFlush stdout
          Just s' -> if s == (c:s') then hPutStrLn stdout " result => OK" >> hFlush stdout
                     else hPutStrLn stdout " result => NG" >> hFlush stdout
      }

{-
*Main> :main 5 ABCDEF
input(ABCDEF) => ABCDEF
 result => OK
input(ABCDEF) => A
 result => TIME OUT
input(ABCDEF) => PQR
 result => NG
*Main> _
-}

function InputChecker(timeout, s) {
  var start;
  var input = [];
  var prompt = "input("+ s + ")=>"
  var pre = document.createElement("pre");
  pre.innerHTML = prompt;
  document.body.appendChild(pre);
  
  function result() {
    var time = new Date().getTime() - start.getTime();
    if(time > timeout * 1000) return "TIMEOUT";
    else if(s == input) return "OK";
    else return "NG"
  }
  var f = function(e) {
    e = e || event;
    if(!start) start = new Date();
    if(e.keyCode == 13) { // Enter
      pre.innerHTML += "<br/>result=&gt;" + result() + "<br/>" + prompt;
      input = "";
      start = undefined;
    } else if(e.charCode == 0 && e.keyCode) { // for firefox. ignore BS, Del, .. etc.
    } else {
      var c = String.fromCharCode(e.keyCode || e.charCode);
      pre.innerHTML += c;
      input += c;
    }
  }
  if(document.attachEvent) document.attachEvent("onkeypress", f);
  else if(document.addEventListener) document.addEventListener("keypress", f, false);
  else document.onkeypress = f;
}
new InputChecker(5, "ABCDEF");

import termios, sys, tty, select

def InputChecker(N, S):
  sys.stdout.write('input(%s) => ' % S)
  sys.stdout.flush()
  fd = sys.stdin.fileno()
  poll = select.poll()
  poll.register(fd, select.POLLIN)
  attr = termios.tcgetattr(fd)
  tty.setcbreak(fd)
  s = ''
  flg = False
  try:
    while True:
      t = poll.poll(N * 1000)
      if not t:
        if not flg:
          continue
        print '\nresult => TIME OUT'
        break
      flg = True
      c = sys.stdin.read(1)
      sys.stdout.write(c)
      sys.stdout.flush()
      if c == '\n':
        if S == s:
          print 'result => OK'
        else:
          print 'result => NG'
        break
      s += c
  finally:
    termios.tcsetattr(fd, termios.TCSADRAIN, attr)
    poll.unregister(fd)

InputChecker(5, 'ABCDEF')

(use c-wrapper)
(c-load "curses.h" :libs "-lcurses")

(initscr)

(define (input-checker n str)
  (cbreak)
  (printw "input(%s) => " str)
  (refresh)
  (receive (t input) (let* ((c0 (integer->char (getch)))
                            (st (sys-time)))
                       (do ((c c0 (integer->char (getch)))
                            (lst '() (cons c lst)))
                           ((memq c '(#\lf #\cr))
                            (values (- (sys-time) st) (list->string (reverse lst))))))
    (printw "result => %s\n" (cond
                              ((< n t) "TIME OUT")
                              ((equal? str input) "OK")
                              (else "NG")))
    (refresh)))

(input-checker 5 "ABCDEF")

(defun input-checker (n s)
  (interactive "nTime(second): \nsString: ")
  (let ((c (read-char (concat "input(" s ")=>"))))
    (push c unread-command-events))
  (with-timeout (n (message "TIME OUT"))
    (let ((input (read-string (concat "input(" s ")=>"))))
      (message (if (string= input s) "OK" "NG")))))

using System;
using System.Threading;
class Program {
    static void InputCheck(int n, string s) {
        Console.Write("input({0}) => ", s);
        while (!Console.KeyAvailable) Thread.Sleep(100);
        DateTime timeout = DateTime.Now.AddSeconds(n); 
        string match = s.Equals(Console.ReadLine()) ? "OK" : "NG";
        Console.WriteLine("result => {0}", DateTime.Now < timeout ? match : "TIME OUT");
    }
    static void Main(string[] args) {
        InputCheck(5, "ABCDEFG");
        InputCheck(4, "HIJKLMN");
        InputCheck(3, "OPQRSTUVWXYZ");
    }
}

#include <windows.h>
#include <stdexcept>
#include <string>

char GetChar(HANDLE h)
{
    char c;

    DWORD read;

    while (true)
    {
        if (! ::ReadFile(h, &c, 1, &read, NULL))
        {
            throw std::runtime_error("::ReadFile() failed");
        }

        if (read == 1 && c != '\r') // skip CR
        {
            break;
        }
    }

    return c;
}

void WriteString(HANDLE h, const std::string& s)
{
    const char* p = s.c_str();

    DWORD size = s.size();

    while (size)
    {
        DWORD written;

        if (! ::WriteFile(h, p, size, &written, NULL))
        {
            throw std::runtime_error("::WriteFile() failed");
        }

        p += written;

        size -= written;
    }

    ::FlushFileBuffers(h);
}

void InputChecker(DWORD timeout, const std::string& expected)
{
    HANDLE hStdIn = ::GetStdHandle(STD_INPUT_HANDLE);

    HANDLE hStdOut = ::GetStdHandle(STD_OUTPUT_HANDLE);

    if (hStdIn == INVALID_HANDLE_VALUE || hStdOut == INVALID_HANDLE_VALUE)
    {
        throw std::runtime_error("cannot get console handle");
    }

    WriteString(hStdOut, "input(" + expected + ") => ");

    ::WaitForSingleObject(hStdIn, INFINITE);

    const DWORD beg = ::GetTickCount();

    std::string s;

    char c;

    while ((c = GetChar(hStdIn)) != '\n')
    {
        s.append(1, c);
    }

    const DWORD end = ::GetTickCount();

    std::string result;

    if (end - beg >= timeout * 1000)
    {
        result = "TIME OUT";
    }
    else if (s == expected)
    {
        result = "OK";
    }
    else
    {
        result = "NG";
    }

    WriteString(hStdOut, "   result => " + result + "\r\n");
}

int main()
{
    try
    {
        while (true)
        {
            InputChecker(5, "ABCDEF");
        }
    }
    catch (std::exception& e)
    {
        WriteString(::GetStdHandle(STD_ERROR_HANDLE), std::string("error: ") + e.what() + "\r\n");
    }
}

#include <stdio.h>
#include <string.h>
#include <time.h>
#include <sys/syslimits.h>
#include <unistd.h>
#include <termios.h>

int InputChecker(time_t sec, const char *str)
{
    size_t length = strlen(str);    // オリジナルの文字数
    char in[ LINE_MAX+1 ];          // 入力文字列
    size_t len;                     // 入力文字数
    time_t t;                       // 入力時間
    struct termios tos, tos_org;

    tcgetattr( 0, &tos ); tos_org = tos;

    memset(in, '\0', sizeof(in));
    printf("input:[%s] => 入力待ち\r", str); fflush(stdout);
    printf("input:[%s] => ", str);