당신의 임무는 영어 알파벳 글자를 얼마나 빨리 입력 할 수 있는지 측정하는 프로그램을 만드는 것입니다.

• 이 프로그램은 소문자 동의하여야 a을 z알파벳 순서로합니다.
• 각 문자는 같은 줄에 입력 된대로 에코됩니다 (새 줄이나 문자 사이에 다른 구분 기호가 없음).
• 유효하지 않은 문자를 입력하면 프로그램이 Fail 새로운 줄에 출력 되고 종료됩니다.
• 26 글자를 모두 입력하면 프로그램 은 새 줄 에 첫 글자에서 마지막 글자까지 걸린 시간을 밀리 초 단위로 출력하고 종료합니다.
• 첫 글자를 입력하면 타이머가 시작됩니다 a.

출력 예 :

b
Fail

abcdefgg
Fail

abcdefghijklmnopqrstuvwxyz
6440

이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.

HTML (자바 스크립트 (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 시스템에서 시스템 클럭은 정확히 985248Hz입니다. 따라서 타이머를 985로 초기화하면 밀리 초에 가까운 것이 발생하지만 너무 빠르므로 매 4 번째 틱마다 986 사이클을 계산하거나 단일 사이클 동안 타이머를 유지해야합니다. 이것이 가능하지 않은,하지만 우리는 순서에 6 개주기위한 타이머를 저장할 수 DEC $DD0E, INC $DD0E: $DD0E비트 0 및 해제를 전환과 타이머 제어 레지스터이고, 두 명령, 그래서 정확한 쓰기를 6주기를 취할 것을 중지하고 시작 타이머는 정확히 6주기 떨어져 있습니다. 따라서 6 * 4 = 24 번째 틱마다이 시퀀스를 실행해야합니다. 이것은 여전히 절대적으로 아니다정확히 말하면 타이머는 8 분 12 초 후에 1 밀리 초 뒤쳐 질 것이지만 아마도 충분할 것입니다.이를 보상하면 많은 코드가 필요합니다.

편집 : 타이머의 시작 값은 985가 아닌 984가되어야합니다.이 타이머는 "언더 플로우 (underflow)"에서 실행되므로 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

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

코드를 수정하고 57 바이트를 절약 한 ovs와 ElPedro에게 감사합니다.

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보다 짧은 대안으로 사용하십시오 .TDateTimeTDateTimeDouble
• MilliSecondsBetween시간 간격을 계산하는 데 사용 하는 대신 이 코드는 두 부동 소수점 값의 차이에을 곱합니다. 864e5이 방법 TDateTime은 여기에 설명 된 Free Pascal encode 방식으로 인해 작동 합니다 .

노트 :

• ReadKey 기능은 실제로 콘솔에서 키를 인쇄하지 않으므로 Write(c) 해야합니다.
• TIO 0는 명백한 이유로 알파벳을 입력 한 것에 대한 점수를 얻습니다 .
• 이 프로그램은 부동 소수점 표기법으로 시간을 인쇄합니다.

자바 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는 Console afaik에서 키 누르기를 들으려는 방법이 없기 때문에와 함께 GUI를 사용합니다 java.awt.

@ OlivierGrégoire 덕분에 -78 바이트 .

설명:

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 코어), 245 + 18383 + 41 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 20 밀리 초마다 1 씩 증가하는 내부 MSX-BASIC 변수입니다.

C # (. NET 코어) , 184 + 13 = 1971773 + 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;

-1 변화시킴으로써 i==123로 i>122. 나는 이것을 만들고 싶어했다 i>'z'.

감사의 말

@raznagul 덕분에 -10 바이트

언 골프

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

편집 : Jordan 덕분에 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);}

Ungolfed 및 댓글 :

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

런타임 예 :

코모도어 베이직 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"

펄 5, 79 93 +31 (-MTerm :: ReadKey -MTime :: HiRes = time) 바이트

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

아세토 , 70 바이트

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

@|스택의 값이 사실이라면 캐치 마크를 설정하고 가로로 미러링하여 시작합니다 ( ). 처음에는 아니며 나중에 항상 그렇습니다. 잘못된 키를 입력하면 나중에 다시 건너 뜁니다. 다음으로 스택에 a를 넣고 ( '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하는 A 가있는 EventHandler. 변수 x, s및 t보류 문자는 각각 지금까지 누른 시간, 시작 시간 및 종료 시간입니다. 와 x같다는 것을 알게 되 자마자 {"a"}시간을 시작합니다. 총 소요 시간 또는 지금까지 작성된 문자열을 표시하거나 "Fail"충족되는 조건에 따라 표시합니다.

아무도 1 초 이내에 알파벳을 입력 할만큼 빠르지 않다고 생각할 수 있다면 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, 윈도우, 98 바이트

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

첫 번째 키를 즉시 입력 할 필요가 없습니다.