您的任务是创建一个程序，该程序可以测量您键入英文字母的速度。

• 该程序只接受小写字母a到z字母顺序。
• 每个字母都按在同一行上键入的方式回显（没有换行或字母之间的任何其他分隔符）。
• 如果键入无效字符，程序将Fail 在新行输出并退出。
• 如果键入所有26个字母，程序将在新行上输出从第一个字母到最后一个字母所花费的时间（以毫秒为单位），然后退出。
• 当您输入第一个字母时，计时器开始计时a。

输出示例：

b
Fail

abcdefgg
Fail

abcdefghijklmnopqrstuvwxyz
6440

这是代码高尔夫球，因此最短答案以字节为单位。

HTML（JavaScript的（ES6）），129个 126 117字节

<input id=i onfocus=l=0,n=Date.now onkeypress=event.which-97-l?i.outerHTML='Fail':24<l?i.outerHTML=n()-t:t=l++?t:n()>

单击输入并开始输入！另外，我的打字很烂；即使练习，我也要花费约5秒钟的时间。编辑：通过切换语言，通过@HermanLauenstein节省了2个字节。@ qw3n节省了3个字节。@tsh节省了9个字节。

6502机器代码（C64 PAL），189165字节

00 C0 A9 17 8D 18 D0 A9 40 85 FE E6 FE 20 E4 FF F0 FB 20 D2 FF C5 FE 38 D0 38
C9 5A 18 F0 33 C9 41 D0 E8 A9 00 85 FC 85 FD A9 18 85 FB A9 7F 8D 0D DD A9 7F
8D 18 03 A9 C0 8D 19 03 A9 D8 8D 04 DD A9 03 8D 05 DD A9 01 8D 0E DD A9 81 8D
0D DD D0 B9 A9 7F 8D 0D DD A9 47 8D 18 03 A9 FE AD 19 03 CE 0E DD B0 14 A9 0D
20 D2 FF A4 FC A5 FD 20 91 B3 20 DD BD A9 01 A8 D0 04 A9 9D A0 C0 4C 1E AB 48
AD 0D DD 29 01 F0 14 E6 FC D0 02 E6 FD C6 FB D0 0A A9 18 85 FB CE 0E DD EE 0E
DD 68 40 0D C6 41 49 4C 00

• 通过内联函数而不是其他CIA2中断来处理-24个字节

在线演示（用法：sys49152）

说明：

如果不是因为C64上精确测量毫秒的问题，这将是一个微型程序。系统中断每秒大约发生60次，甚至还没有结束。因此，我们必须在此处使用硬件计时器，该计时器会从系统时钟获取输入滴答。

在PAL机器上，系统时钟精确为985248 Hz。因此，将计时器初始化为985会产生接近毫秒的滴答声，但是它有点太快了，我们必须每四个滴答声计数986个周期，或者将计时器保持一个周期。这是不可能的，但我们可以保持6个周期与序列的计时器DEC $DD0E，INC $DD0E：$DD0E是位0切换和关闭它的定时器控制寄存器和指令都需要6个周期，因此，其准确写道，停止和启动计时器正好相隔6个周期。因此，我们必须每6 * 4 = 24个刻度执行一次此序列。这仍然不是绝对的确切的说，计时器将在8分12秒后延迟1毫秒，但这可能已经足够了-补偿那将花费很多代码。

编辑：计时器的起始值必须为984，而不是985，因为这些计时器在“下溢时触发”，因此值0将在触发前再计数一个周期。代码固定，字节数不变。

这是评论后的反汇编清单：

         00 C0       .WORD $C000        ; load address
.C:c000  A9 17       LDA #$17           ; mode for upper/lower text
.C:c002  8D 18 D0    STA $D018          ; set in graphics chip
.C:c005  A9 40       LDA #$40           ; initialize expected character
.C:c007  85 FE       STA $FE            ; to 'a' - 1
.C:c009   .mainloop:
.C:c009  E6 FE       INC $FE            ; increment expected character
.C:c00b   .getchar:
.C:c00b  20 E4 FF    JSR $FFE4          ; read character from keyboard
.C:c00e  F0 FB       BEQ .getchar       ; until actual character entered
.C:c010  20 D2 FF    JSR $FFD2          ; output this character
.C:c013  C5 FE       CMP $FE            ; compare with expected
.C:c015  38          SEC                ; set carry as marker for error
.C:c016  D0 38       BNE .result        ; wrong character -> output result
.C:c018  C9 5A       CMP #$5A           ; compare with 'z'
.C:c01a  18          CLC                ; clear carry (no error)
.C:c01b  F0 33       BEQ .result        ; if 'z' entered, output result
.C:c01d  C9 41       CMP #$41           ; compare with 'a'
.C:c01f  D0 E8       BNE .mainloop      ; if not equal repeat main loop
.C:c021  A9 00       LDA #$00           ; initialize timer ticks to 0
.C:c023  85 FC       STA $FC
.C:c025  85 FD       STA $FD
.C:c027  A9 18       LDA #$18           ; counter for adjusting the timer
.C:c029  85 FB       STA $FB
.C:c02b  A9 7F       LDA #$7F           ; disable all CIA2 interrupts
.C:c02d  8D 0D DD    STA $DD0D
.C:c030  A9 7F       LDA #<.timertick   ; set NMI interrupt vector ...
.C:c032  8D 18 03    STA $0318
.C:c035  A9 C0       LDA #>.timertick
.C:c037  8D 19 03    STA $0319          ; ... to our own timer tick routine
.C:c03a  A9 D9       LDA #$D8           ; load timer with ...
.C:c03c  8D 04 DD    STA $DD04
.C:c03f  A9 03       LDA #$03
.C:c041  8D 05 DD    STA $DD05          ; ... 985 (-1) ticks (see description)
.C:c044  A9 01       LDA #$01           ; enable timer
.C:c046  8D 0E DD    STA $DD0E
.C:c049  A9 81       LDA #$81           ; enable timer interrupt
.C:c04b  8D 0D DD    STA $DD0D
.C:c04e  D0 B9       BNE .mainloop      ; repeat main loop
.C:c050   .result:
.C:c050  A9 7F       LDA #$7F           ; disable all CIA2 interrupts
.C:c052  8D 0D DD    STA $DD0D
.C:c055  A9 47       LDA #$47           ; set NMI interrupt vector ...
.C:c057  8D 18 03    STA $0318
.C:c05a  A9 FE       LDA #$FE
.C:c05c  AD 19 03    LDA $0319          ; ... back to system default
.C:c05f  CE 0E DD    DEC $DD0E          ; disable timer
.C:c062  B0 14       BCS .fail          ; if carry set, output fail
.C:c064  A9 0D       LDA #$0D           ; load newline
.C:c066  20 D2 FF    JSR $FFD2          ; and output
.C:c069  A4 FC       LDY $FC            ; load timer value in
.C:c06b  A5 FD       LDA $FD            ; A and Y
.C:c06d  20 91 B3    JSR $B391          ; convert to float
.C:c070  20 DD BD    JSR $BDDD          ; convert float to string
.C:c073  A9 01       LDA #$01           ; load address of
.C:c075  A8          TAY                ; string buffer
.C:c076  D0 04       BNE .out           ; and to output
.C:c078   .fail:
.C:c078  A9 9D       LDA #<.failstr     ; load address of "Fail" string
.C:c07a  A0 C0       LDY #>.failstr     ; in A and Y
.C:c07c   .out:
.C:c07c  4C 1E AB    JMP $AB1E          ; done; OS routine for string output
.C:c07f   .timertick:
.C:c07f  48          PHA                ; save accu
.C:c080  AD 0D DD    LDA $DD0D          ; load interrupt control register
.C:c083  29 01       AND #$01           ; to know whether it was a timer NMI
.C:c085  F0 14       BEQ .tickdone      ; if not -> done
.C:c087  E6 FC       INC $FC            ; increment timer ticks ...
.C:c089  D0 02       BNE .adjusttick
.C:c08b  E6 FD       INC $FD            ; high byte only on overflow
.C:c08d   .adjusttick:
.C:c08d  C6 FB       DEC $FB            ; decrement counter for adjusting
.C:c08f  D0 0A       BNE .tickdone      ; not 0 yet -> nothing to do
.C:c091  A9 18       LDA #$18           ; restore counter for adjusting
.C:c093  85 FB       STA $FB
.C:c095  CE 0E DD    DEC $DD0E          ; halt timer for exactly
.C:c098  EE 0E DD    INC $DD0E          ; 6 cycles
.C:c09b   .tickdone:
.C:c09b  68          PLA                ; restore accu
.C:c09c  40          RTI
.C:c09d   .failstr:
.C:c09d  0D C6 41    .BYTE $0D,"Fa"
.C:c0a0  49 4C 00    .BYTE "il",$00

Bash + coreutils，103 99 98字节

for((;c==p%26;r=`date +%s%3N`-(s=s?s:r),c=62#$c-9,p++))
{
read -N1 c
}
((c==p))||r=Fail
echo "
$r"

必须在终端中运行。

测试运行

$ bash type.sh
abcdefghijklmnopqrstuvwxyz
3479
$ bash type.sh
abcz
Fail
$ bash type.sh 2>&- # typing '@' would print to STDERR
ab@
Fail
$ bash type.sh
A
Fail

Python 2 + getch，116字节

import time,getch
t=[i+97-ord(getch.getche())and exit("Fail")or time.time()for i in range(26)]
print(t[-1]-t[0])*1e3

感谢ovs和ElPedro修复了代码并节省了57个字节。

SOGL V0.12，35 个字节

"ζ¦F‘→I
]I!}Su[I:lzm≠?■Fail←z=?Suκ←

在这里尝试！-单击运行，然后在输入框中输入字母。请注意，这可能有点滞后，因为SOGL仅在每执行100个令牌时才暂停输入（并且SOGL相当慢）。如果那困扰您，请sleepBI=true在控制台中运行。

注意：请勿在兼容模式下运行它-它将永远循环。

说明：

"ζ¦F‘    push "inputs.value" (yes, that is a word in SOGLs english dictionary)
     →   execute as JS, pushing the inputs contents
      I  named function I


]  }                do while POP is truthy
 I                    execute I
  !                   negate it - check if it's empty
    Su              push the current milliseconds since start
[                   loop
 I                    execute I
  :                   duplicate the result
   l                  let its length
    zm                mold the alphabet to that size
      ≠?              if that isn't equal to one of the result copies
        ■Fail           push "Fail"
             ←          and exit, implicitly outputting that
              z=?     if the other copy is equal to the alphabet
                 Su     push the milliseconds since start
                   κ    subtract the starting milliseconds from that
                    ←   and exit, implicitly outputting the result

帕斯卡（FPC），176字节

Uses CRT,SysUtils;Var c:char;a:Real;Begin
for c:='a'to'z'do
if c=ReadKey then
begin Write(c);if c='a'then a:=Now;end
else
begin
Write('Fail');Halt;end;Write((Now-a)*864e5)
End.

在线尝试！

高尔夫代码中使用的一些技巧：

• 使用Real作为短替代TDateTime，因为所定义这里，TDateTime= Double，这是浮点型。
• MilliSecondsBetween该代码没有用于计算时间间隔，而是将两个浮点值之间的差乘以864e5，这是由于此处TDateTime描述的Free Pascal编码方式起作用的。

注意：

• ReadKey函数实际上不会在控制台上打印键，因此必须使用手动向控制台写入Write(c)。
• 0由于明显的原因，TIO在输入字母时得分接近。
• 该程序以浮点数表示法打印时间，我想这是允许的。

Java，404 388 354 348 320 318字节

import java.awt.*;import java.awt.event.*;interface M{static void main(String[]a){new Frame(){{add(new TextArea(){{addKeyListener(new KeyAdapter(){long t,i=64;public void keyPressed(KeyEvent e){t=t>0?t:e.getWhen();if(e.getKeyChar()!=++i|i>89){System.out.print(i>89?e.getWhen()-t:"Fail");dispose();}}});}});show();}};}}

在这里，我认为Java控制台已经很冗长了。
由于Java无法原始监听控制台afaik中的按键，因此我将GUI与一起使用java.awt。

-78字节，感谢@OlivierGrégoire。

说明：

import java.awt.*;                 // Required import for Frame and TextField
import java.awt.event.*;           // Required import for KeyAdapter and KeyEvent
interface M{                       // Class
  static void main(String[]a){     //  Mandatory main-method
    new Frame(){                   //   Create the GUI-Frame
      {                            //    With an initialization-block
        add(new TextArea(){        //     Add an input-field
          {                        //      With it's own initialization-block
            addKeyListener(new KeyAdapter(){
                                   //       Add a KeyAdapter to the input-field
              long t,              //        Long to save the time
                   i=64;           //        Previous character, starting at code of 'a' -1
              public void keyPressed(KeyEvent e){ 
                                   //        Override the keyPressed-method:
                t=t>0?             //         If `t` is already set:
                   t               //          Leave it the same
                  :                //         Else:
                   e.getWhen();    //          Save the current time (== start the timer)
                if(e.getKeyCode()!=++i
                                   //         As soon as an incorrect character is pressed,
                   |i>89){         //         or we've reached 'z':
                  System.out.print(i>89?
                                   //          If we're at 'z':
                    e.getWhen()-t  //           Print the end-time in ms to the Console
                   :               //          Else (an incorrect character was pressed)
                    "Fail");       //           Print "Fail" to the Console
                  dispose();}      //          And exit the application
              }                    //        End of keyPressed-method
            });                    //       End of KeyAdapter
          }                        //      End of input-field initialization-block
        });                        //     End of input-field
        show();                    //     Initially show the Frame
      }                            //    End of Frame initialization-block
    };                             //   End of Frame 
  }                                //  End of main-method
}                                  // End of class

成功的gif示例：（是的，我在这里输入字母的速度非常慢。。）
注意：这是旧的gif。当前版本不再将按键打印到控制台。并且它不再用小数点后的数字打印时间。

失败的gif示例：
注意：这是旧的gif。当前版本不再将按键打印到控制台。

C＃（.NET Core），245 + 13183 + 41177 + 41字节

的+41个字节using System;using static System.Console。

未经测试，因为我在移动设备上，并且无法在TIO上运行。

n=>{int c=ReadKey().KeyChar,x=0;try{if(c!=97)x/=x;var s=DateTime.Now;while(c<149)if(ReadKey().KeyChar!=c++)x/=x;Write((DateTime.Now-s).TotalMilliseconds);}catch{Write("Fail");}}

MSX-BASIC，126个字符

1C=97:GOSUB3:TIME=0
2IFASC(C$)<>CTHEN?"Fail":ENDELSEIFC=122THEN?TIME*20:ENDELSEC=C+1:GOSUB3:GOTO2
3C$=INKEY$:IFC$=""GOTO3
4RETURN

TIME 是内部MSX-BASIC变量，每20毫秒增加1。

C＃（.NET Core），184 + 13 = 197 173 + 13 = 186字节

()=>{var s=DateTime.Now;var i=97;while(i<123&&Console.ReadKey().KeyChar==i)if(i++<98)s=DateTime.Now;Console.Write(i>122?$"\n{(DateTime.Now-s).TotalMilliseconds}":"\nFail");}

在线尝试！

不幸的是，TIO无法运行此命令，但是它对于获取字节数非常方便。

+13 using System;

更改i==123为-1 i>122。我很想这么做i>'z'。

致谢

-10个字节，感谢@raznagul

不打高尔夫球

()=>{
    var s=DateTime.Now;
    var i=97;

    while(i<123&&Console.ReadKey().KeyChar==i)
        if(i++<98)
            s=DateTime.Now;

    Console.Write(i>122?
        $"\n{(DateTime.Now-s).TotalMilliseconds}":
        "\nFail"
    );
} 

Node.js的，240个 213字节

require('readline',{stdin:i,stdout:o,exit:e}=process).emitKeypressEvents(i)
w=s=>o.write(s)
n=0
i.on('keypress',c=>w(c)&&c.charCodeAt()-97-n?e(w(`
Fail`)):!n++?s=d():n>25&&e(w(`
`+(d()-s)))).setRawMode(d=Date.now)

编辑：由于乔丹节省了27个字节

非高尔夫版本：

const readline = require('readline')

let index = 0
let start

readline.emitKeypressEvents(process.stdin)
process.stdin.setRawMode(true)

process.stdin.on('keypress', character => {
  process.stdout.write(character )

  // Lookup character in ASCII table
  if (character !== String.fromCharCode(97 + index) {
    process.stdout.write('\nFail')
    process.exit()
  }

  index++

  if (index === 1) {
    start = Date.now()
  }

  if (index === 26) {
    process.stdout.write('\n' + (Date.now() - start))
    process.exit()
  }
})

C（gcc），303字节

适用于* nix系统。独立代码删除当前终端的规范模式，以允许阅读字符而无需等待换行符：

/！\运行此程序将使终端几乎不可用。

#import <stdlib.h>
#import <termios.h>
#define x gettimeofday(&t,0)
#define r t.tv_sec*1000+t.tv_usec/1000
c,i=97;main(){long s=0;struct termios n;struct timeval t;cfmakeraw(&n);n.c_lflag|=ECHO;tcsetattr(0,0,&n);for(;i<'d';){c=getchar();if(c!=i++)puts("\nFail"),exit(0);x;s=s?:r;}x;printf("\n%ld",r-s);}

取消评论并评论：

// needed in order to make gcc aware of struct termios
// and struct timeval sizes
#import <stdlib.h>
#import <termios.h>

// gets the time in a timeval structure, containing
// the number of seconds since the epoch, and the number
// of µsecs elapsed in that second
// (shorter than clock_gettime)
#define x gettimeofday(&t,0)
// convert a timeval structure to Epoch-millis
#define r t.tv_sec*1000+t.tv_usec/1000

// both integers
// c will contain the chars read on stdin
// 97 is 'a' in ASCII
c,i=97;

main(){
  long s=0; // will contain the timestamp of the 1st char entered
  struct timeval t; // will contain the timestamp read from gettimeofday

  // setting up the terminal
  struct termios n;
  cfmakeraw(&n);//create a raw terminal configuration
  n.c_lflag|=ECHO;//makes the terminal echo each character typed
  tcsetattr(0,0,&n);//applies the new settings

  // from 'a' to 'z'...
  for(;i<'{';){
    // read 1 char on stdin
    c=getchar();

    // if int value of the input char != expected one => fail&exit
    if(c!=i++)puts("\nFail"),exit(0);

    // macro x: get current timestamp
    x;

    // if not already set: set starting timestamp
    s=s?:r;
  }

  // get end of sequence timestamp
  x;

  // prints the end-start timestamps difference
  printf("\n%ld",r-s);
}

替代解决方案（218字节）：

如果允许预先配置终端，那么我们可以省去处理那部分代码的那一部分。

这是没有终端操作的相同代码：

#import <stdlib.h>
#define x gettimeofday(&t,0)
#define r t.tv_sec*1000+t.tv_usec/1000
c,i=97;main(){long s=0;struct timeval t;for(;i<'{';){c=getchar();if(c!=i++)puts("\nFail"),exit(0);x;s=s?:r;}x;printf("\n%ld",r-s);}

要使其起作用：

$ gcc golf.c
$ stty -icanon
$ a.out

运行时示例：

Commodore BASIC v2-113字节

大写字母必须转移。
感谢Felix Palmen指出了一些错别字，规格请
尝试一下

0d=64
1on-(f=26)gO5:gEa$:ifa$=""tH1
2iff=0tHt=ti
3f=f+1:ifa$<>cH(d+f)tH6
4?cH(14)a$;:gO1
5?:?(ti-t)/60*1000:eN
6?"Fail"

Perl 5中，79 93 31（-MTerm :: ReadKey -mtime ::高分辨率=时间）的字节

$|=1;map{ReadKey eq$_||exit print"
Fail";$s||=time}a..z;print$/,0|1e3*(time-$s)

$|=1不足以将终端设置为原始模式，stty -icanon应在运行之前或

ReadMode 3;map{ReadKey eq$_||exit print"
Fail";print;$s||=time}a..z;print$/,0|1e3*(time-$s)

在运行命令后查看终端中的字符：stty echo或stty echo icanon

Aceto，70个字节

d'|d 't9
$z=p zp1
!=   >#v
d,   1 +
cTpaXpn3
Io$'p"*F
|'!=ilnu
@ad,aF"

@|如果堆栈上的值是真实的，我首先设置一个捕获标记并水平镜像（）。最初不是，以后总是如此。如果输入了错误的密钥，我们稍后将跳回到此处。接下来，我们推栈（上一个'a），那么我们复制它和从用户读取单个字符（d,）。如果两个字符不相等（=!），我们将“崩溃”（$）并跳回到捕捉标记。否则，我们按下另一个“ a”并打印它，然后设置当前时间（'apT）。

然后我们进入“主循环”：我们“增加”当前字符，“增加”字符（'apToIc），然后复制它，读取一个新字符，进行比较，如果字符不同则“崩溃”。 （d,=!$）。如果没有崩溃，我们将当前字符与“ z”（d'z=|）进行比较，如果不相等，则打印该字符，然后按下1并“有条件地”跳转（在这种情况下：始终）到仅o在代码中（我们主循环的开始）。如果等于z，我们将水平镜像到顶部的一些空白区域。我们打印“ z”，然后按当前时间（减去开始时间；t），然后将数字乘以1000（将10升至三次方得到91+3F）；（因为我们得到秒，而不是毫秒）。然后我们打印换行符，时间并退出（pX）。

如果我们崩溃了（用户输入错误），我们将一直跳到开头。由于现在堆栈上会有一些真实值，因此我们将水平镜像到上u，这将反转我们移入的方向。n打印换行符，然后压入"Fail"堆栈，打印并退出（pX）。

Mathematica（笔记本表达式），248个字节

DynamicModule[{x={},s=0,t=0},EventHandler[Framed@Dynamic[If[x=={"a"}&&s<1,s=SessionTime[]];Which[x==a,If[t==0,t=SessionTime[]-s];1000t,x==a~Take~Length@x,""<>x,1>0,"Fail"]],Table[{"KeyDown",c}:>x~AppendTo~CurrentValue@"EventKey",{c,a=Alphabet[]}]]]

这个怎么运作

DynamicModule[{x={},s=0,t=0},
  EventHandler[
    Framed@Dynamic[
      If[x=={"a"} && s<1,s=SessionTime[]];
      Which[
        x==a,If[t==0,t=SessionTime[]-s];1000t,
        x==a~Take~Length@x,""<>x,
        1>0,"Fail"]],
    Table[{"KeyDown",c}:>x~AppendTo~CurrentValue@"EventKey",
      {c,a=Alphabet[]}]]]

一个DynamicModule与EventHandler该响应小写字母按键。变量x，s和分别t保持到目前为止按下的字母，开始时间和结束时间。一旦发现x等于{"a"}，我们就开始计时。我们将显示花费的总时间，或显示到目前为止构建的字符串，或显示"Fail"是否满足条件。

我们可以节省一个字节，t<1而不是t==0假设没有人能在不到一秒钟的时间内输入字母：)

如果要在Mathematica笔记本中进行尝试，请记住，必须先在框架内单击，然后才能注册按键。（这就是我们需要框架开始的原因；如果Framed不存在该框架，那么当按下一个键时，所选的整个对象都会更改，因此它将停止被选择，而您必须再次单击。）

C＃，154152 + 13 = 165字节

感谢Ayb4btu的评论，节省了2个字节

x=>{
  long t=0,c=97;
  for(;Console.ReadKey().KeyChar==c++&&c<123;t=t<1?DateTime.Now.Ticks:t);
  Console.Write(c>122?"\n"+(DateTime.Now.Ticks-t)/1e4:"\nFail");
}

上面的代码具有空格，使其适合没有滚动条的SE。空格不是字节数的一部分

和13个字节用于 using System;

它与Ayb4btu的版本相似，但有以下区别：

• 将日期时间存储为长时，还可以使c长时和声明的快捷方式

• 循环不需要单独的中断

• $"interpreted strings"与在毫秒数上添加所需的“ \ n”以使其成为内联字符串相比，使用它实际上并不短

• for有时使用循环可以使我们节省一段时间的字符，尽管我认为这不会节省等效的字符while

从Ayb4btu：

• s=s==0可以成为s=s<1并且c==123可以成为c>122

不打高尔夫球

long t=0,c=97;

for (;                                         //no loop vars declared
  Console.ReadKey().KeyChar == c++ && c < 123; //loop test
  t = t < 1 ? DateTime.Now.Ticks : t          //post-loop assigns
) ;                                            //empty loop body!

//now just need to turn ticks into millis, 10,000 ticks per millis
Console.Write(c>122?"\n"+(DateTime.Now.Ticks-t)/1e4:"\nFail");

Processing.org 133 142

第一个代码没有退出

char k=97;int m;void draw(){if(key==k){m=m<1?millis():m;print(key=k++,k>122?"\n"+(millis()-m):"");}if(m>0&&key!=k-1){print("\nFail");exit();}}

GCC，Windows，98字节

t;main(i){for(;i++<27;t=t?:clock())if(95+i-getche())return puts("\nFail");printf("\n%d",clock()-t);}

不需要立即输入第一把钥匙