Nhiệm vụ của bạn là tạo ra một chương trình đo tốc độ bạn có thể gõ các chữ cái trong bảng chữ cái tiếng Anh.

• Chương trình này sẽ chỉ chấp nhận chữ thường ađể ztrong thứ tự chữ cái.
• Mỗi chữ cái được lặp lại khi gõ trên cùng một dòng (không có dòng mới hoặc bất kỳ dấu phân cách nào khác giữa các chữ cái).
• Nếu bạn nhập một ký tự không hợp lệ, chương trình sẽ xuất ra Fail một dòng mới và thoát.
• Nếu bạn nhập tất cả 26 chữ cái, chương trình sẽ, trên một dòng mới , xuất thời gian tính bằng mili giây từ chữ cái đầu tiên đến chữ cái cuối cùng và thoát.
• Bộ hẹn giờ bắt đầu khi bạn gõ chữ cái đầu tiên , a.

Kết quả ví dụ:

b
Fail

abcdefgg
Fail

abcdefghijklmnopqrstuvwxyz
6440

Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.

HTML (JavaScript (ES6)), 129 126 117 byte

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

Nhấp vào đầu vào và bắt đầu gõ! Ngoài ra, gõ của tôi hút; Tôi mất khoảng 5 giây ngay cả khi luyện tập. Chỉnh sửa: Đã lưu 2 byte nhờ @HermanLauenstein bằng cách chuyển ngôn ngữ. Đã lưu 3 byte nhờ @ qw3n. Đã lưu 9 byte nhờ @tsh.

Mã máy 6502 (C64 PAL), 189 165 byte

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

• -24 byte bằng cách đặt các hàm nội tuyến và không quan tâm đến các ngắt CIA2 khác

Bản demo trực tuyến (Cách sử dụngsys49152:)

Giải trình:

Đây sẽ là một chương trình nhỏ nếu không phải là vấn đề đo chính xác mili giây trên C64. Ngắt hệ thống xảy ra khoảng 60 lần mỗi giây, thậm chí không đóng. Vì vậy, chúng ta phải sử dụng một bộ đếm thời gian phần cứng ở đây để có dấu tick đầu vào từ đồng hồ hệ thống.

Trên máy PAL, đồng hồ hệ thống chính xác là 985248 Hz. Do đó, việc khởi tạo bộ đếm thời gian thành 985 mang lại một cái gì đó gần với mili giây, nhưng hơi nhanh, chúng ta phải đếm 986 chu kỳ cho mỗi tích tắc thứ tư hoặc giữ bộ hẹn giờ trong một chu kỳ. Điều này là không thể, nhưng chúng ta có thể giữ bộ hẹn giờ trong 6 chu kỳ với trình tự DEC $DD0E, INC $DD0E: $DD0Elà thanh ghi điều khiển hẹn giờ với bit 0 bật và tắt, và cả hai hướng dẫn đều thực hiện 6 chu kỳ, do đó, việc ghi chính xác dừng và bắt đầu Bộ hẹn giờ cách nhau chính xác 6 chu kỳ. Do đó, chúng ta phải thực hiện chuỗi này cứ sau 6 * 4 = 24 giây. Điều này vẫn không hoàn toànchính xác, bộ hẹn giờ sẽ bị trễ 1 mili giây sau 8 phút và 12 giây, nhưng có lẽ nó đủ tốt - bù lại rằng cái đó sẽ mất rất nhiều mã.

chỉnh sửa : Giá trị bắt đầu cho bộ định thời phải là 984, không phải 985, vì các bộ định thời này kích hoạt "dưới dòng", vì vậy giá trị 0 sẽ tính thêm một chu kỳ trước khi bắn. Mã cố định, số byte không đổi.

Dưới đây là danh sách tháo gỡ nhận xét:

         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 byte

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"

Phải được chạy trong một thiết bị đầu cuối.

Chạy thử nghiệm

$ 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 byte

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

Cảm ơn ovs và ElPedro đã sửa mã và lưu 57 byte.

SOGL V0.12 , 35 byte

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

Hãy thử nó ở đây! - bấm chạy, và nhập bảng chữ cái trong hộp nhập. Lưu ý rằng nó có thể hơi lag vì SOGL chỉ tạm dừng cho đầu vào cứ sau 100 mã thông báo được thực thi (và SOGL khá chậm). Nếu điều đó làm phiền bạn, hãy chạy sleepBI=truetrong bàn điều khiển.

lưu ý: không chạy cái này trong chế độ tương thích - nó sẽ chỉ lặp lại mãi mãi.

Giải trình:

"ζ¦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

Pascal (FPC) , 176 byte

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.

Hãy thử trực tuyến!

Một số thủ thuật được sử dụng trong mã để chơi gôn:

• Sử dụng Realnhư là một thay thế ngắn hơn TDateTime, bởi vì như được định nghĩa ở đây , TDateTime= Double, là loại dấu phẩy động.
• Thay vì sử dụng MilliSecondsBetweenđể tính khoảng cách thời gian, mã này nhân số chênh lệch giữa hai giá trị dấu phẩy động bằng 864e5, hoạt động nhờ cách mã hóa Pascal miễn phí TDateTimeđược mô tả ở đây .

Ghi chú:

• ReadKeyChức năng không thực sự in khóa trên bàn điều khiển, vì vậy việc viết thủ công vào bàn điều khiển Write(c)là cần thiết.
• TIO có được một số điểm gần 0để gõ bảng chữ cái vì lý do rõ ràng.
• Chương trình in thời gian theo ký hiệu dấu phẩy động, tôi đoán điều đó được cho phép.

Java, 404 388 354 348 320 318 byte

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

Và ở đây tôi nghĩ Bảng điều khiển Java đã dài dòng ..
Vì Java không có cách nào để nghe thô cho các lần nhấn phím trong Bảng điều khiển afaik, tôi sử dụng GUI với java.awt.

-78 byte nhờ @ OlivierGrégoire .

Giải trình:

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

Ví dụ gif thành công: (Vâng, tôi gõ bảng chữ cái khá chậm ở đây ..)
Lưu ý: Đây là một gif cũ. Phiên bản hiện tại không còn in các phím bấm vào Bảng điều khiển. Và nó không còn in thời gian bằng chữ số sau dấu thập phân.

Ví dụ gif của fail:
Lưu ý: Đây là một gif cũ. Phiên bản hiện tại không còn in các phím bấm vào Bảng điều khiển.

C # (.NET Core), 245 + 13 183 + 41 177 + 41 byte

+41 byte cho using System;using static System.Console.

Chưa được kiểm tra vì tôi đang sử dụng điện thoại di động và điều này không chạy trên 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 ký tự

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

TIME là một biến MSX-BASIC nội bộ tăng thêm cứ sau 20 mili giây.

C # (.NET Core) , 184 + 13 = 197 173 + 13 = 186 byte

()=>{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");}

Hãy thử trực tuyến!

Thật không may, TIO không thể chạy cái này, nhưng nó rất tiện để lấy số byte.

+13 cho using System;

-1 bằng cách thay đổi i==123thành i>122. Tôi đã bị cám dỗ để làm điều này i>'z'.

Sự nhìn nhận

-10 byte nhờ @raznagul

Ung dung

()=>{
    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 byte

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)

EDIT: Đã lưu 27 byte nhờ Jordan

Phiên bản bị đánh cắp:

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 byte

Hoạt động trên các hệ thống * nix. Mã độc lập loại bỏ chế độ chính tắc của thiết bị đầu cuối hiện tại để cho phép đọc các ký tự mà không cần chờ dòng mới:

/! \ Chạy chương trình này sẽ làm cho thiết bị đầu cuối gần như không sử dụng được.

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

Ungolfed và bình luận:

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

Giải pháp thay thế (218 byte):

Nếu cấu hình thiết bị đầu cuối trước được cho phép, thì chúng ta có thể loại bỏ phần xử lý mã đó.

Đây là cùng một mã mà không cần thao tác đầu cuối:

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

Để làm cho nó hoạt động:

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

ví dụ thời gian chạy:

Hàng hóa BASIC v2 - 113 byte

Chữ in hoa phải được dịch chuyển.
Cảm ơn Felix Palmen đã chỉ ra một số lỗi chính tả, thông số kỹ thuật
thử nó

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 :: HiRes = time) byte

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

$|=1không đủ để đặt thiết bị đầu cuối ở chế độ thô, stty -icanonnên được chạy trước hoặc

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

để xem các ký tự trong terminal sau khi chạy lệnh: stty echohoặcstty echo icanon

Aceto , 70 byte

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

Tôi bắt đầu bằng cách đặt dấu bắt và phản chiếu theo chiều ngang ( @|), nếu giá trị trên ngăn xếp là trung thực. Đó không phải là ban đầu, và sau này sẽ luôn luôn như vậy. Chúng tôi sẽ quay lại đây sau nếu nhập sai khóa. Tiếp theo, chúng ta đẩy một a trên stack ( 'a), sau đó chúng ta nhân đôi nó và đọc một ký tự từ người dùng ( d,). Nếu hai ký tự không bằng nhau ( =!), chúng ta "gặp sự cố" ( $) và quay lại dấu bắt. Mặt khác, chúng ta đẩy một "a" khác và in nó, sau đó chúng ta đặt thời gian hiện tại ( 'apT).

Sau đó, chúng tôi nhập "vòng lặp chính": Chúng tôi "tăng" ký tự hiện tại và "tăng" ký tự ( 'apToIc), sau đó chúng tôi nhân đôi nó, đọc một ký tự mới, so sánh nó và "sụp đổ" nếu các ký tự không giống nhau ( d,=!$). Nếu chúng tôi không gặp sự cố, chúng tôi so sánh ký tự hiện tại với "z" ( d'z=|), nếu nó không bằng nhau, chúng tôi sẽ in ký tự đó, sau đó chúng tôi đẩy 1 và nhảy "có điều kiện" (trong trường hợp này: luôn luôn) chỉ otrong mã (bắt đầu của vòng lặp chính của chúng tôi). Nếu nó bằng z, chúng ta nhân đôi theo chiều ngang với một số khoảng trống trên đầu. Chúng tôi in "z", sau đó đẩy thời gian hiện tại (trừ thời gian bắt đầu; t) rồi nhân số 1000 (nhận được bằng cách tăng 10 lên công suất thứ ba; 91+3F) với nó (vì chúng tôi nhận được giây, không phải mili giây). Sau đó, chúng tôi in một dòng mới, thời gian và thoát (pX).

Nếu chúng ta gặp sự cố (đầu vào xấu của người dùng), chúng ta sẽ nhảy từ đầu đến cuối. Vì bây giờ chúng ta sẽ có một số giá trị trung thực trên ngăn xếp, chúng ta sẽ phản chiếu theo chiều ngang lên trên u, đảo ngược hướng chúng ta đang di chuyển. In nmột ký tự dòng mới, sau đó chúng ta ấn "Fail"vào ngăn xếp, in nó và thoát ( pX).

Mathicala (biểu thức notebook), 248 byte

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[]}]]]

Làm thế nào nó hoạt động

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[]}]]]

A DynamicModulevới một EventHandlerphản ứng với phím nhấn chữ thường. Các biến x, svà tgiữ các chữ cái được nhấn cho đến nay, thời gian bắt đầu và thời gian kết thúc, tương ứng. Ngay khi chúng tôi nhận thấy xbằng nhau {"a"}, chúng tôi bắt đầu thời gian; chúng tôi hiển thị tổng thời gian sử dụng hoặc chuỗi được xây dựng cho đến nay hoặc "Fail"tùy thuộc vào điều kiện nào được đáp ứng.

Chúng ta có thể lưu một byte khác t<1thay vì t==0nếu chúng ta có thể cho rằng không ai đủ nhanh để gõ bảng chữ cái trong chưa đầy một giây :)

Nếu bạn đang thử điều này trong sổ ghi chép Mathicala, hãy nhớ rằng bạn phải nhấp vào bên trong khung trước khi nhấn phím sẽ được đăng ký. (Đây là lý do mà chúng ta cần bắt đầu với khung; nếu Framedkhông có thì toàn bộ đối tượng được chọn sẽ thay đổi khi nhấn phím, do đó, nó dừng được chọn và bạn phải bấm lại.)

C #, 154 152 + 13 = 165 byte

Đã lưu 2 byte nhờ nhận xét của Ayb4btu

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

Đoạn mã trên có khoảng trắng để làm cho nó phù hợp với SE mà không cần thanh cuộn. Khoảng trắng không phải là một phần của số byte

và 13 byte cho using System;

Nó tương tự như phiên bản của Ayb4btu nhưng có những điểm khác biệt sau:

• Lưu trữ thời gian dài, cho phép chúng tôi thực hiện cmột thời gian dài và cắt ngắn khai báo

• Vòng lặp không cần nghỉ riêng

• Nó không thực sự ngắn hơn để sử dụng $"interpreted strings"so với việc thêm một "\ n" cần thiết vào mili giây để biến nó thành một chuỗi cho nội tuyến nếu

• Sử dụng một forvòng lặp đôi khi cho phép chúng ta lưu các ký tự trong một thời gian, mặc dù tôi nghĩ rằng điều này sẽ không tiết kiệm tương đươngwhile

Từ Ayb4btu:

• s=s==0có thể trở thành s=s<1, và c==123có thể trở thànhc>122

Ung dung

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

Đang xử lý.org 133 142

mã đầu tiên không thoát

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 byte

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

Yêu cầu không có đầu vào ngay lập tức cho khóa đầu tiên