The Counting Gate Keeper

Question

Related as it requires you to measure the time between the first and last input. But here you're required to count how many inputs in a period of time.

I was assigned a task to stand by a gate and count how many students enter it. The problem is that my memory is not as good as it was when I first started this job. I need some kind of program to help me count how many students enter the gate until my shift is over.

Task

Given an integer t that represents the number of seconds until my shift is over. Tell me how many times I pressed the button during that time.

Rules

• The button press can be any convenient user input, such as pressing the Return key;
• You can assume that t will allways be in range [1; 60];
• You can assume that the number of students will be less than 2³¹;
• When the time is up, you must output within 1 second;
• Your program does not need to end, as long as the only output to stdout is at the end of the shift;
• If your input method (such as Enter-key) repeats if held, you can choose to count it just once, or several times. Either way, you must still be able to handle separate inputs.

Answer 1

TI-Basic, 22 bytes

Fairly simple. Sets a time Ans seconds in the future which we call T which is when the loop stops. While the loop is going, we check for if a key is pressed. It's been a while since I had the fgitw :)

startTmr+Ans->T
0
While T≠startTmr
Ans+not(not(getKey
End

Answer 2

Ruby, 38 42 bytes

Uses the global variable $., which counts how many times the standard input function gets has successfully been completed. As such, it will only give accurate results the first time it is called per program run.

Input via command-line argument, such as ruby gatekeeper.rb 40

Thread.new{loop{gets}}
sleep eval$*[0]
p$.

Answer 3

AHK, 110 bytes

1*=-1000
c=0
Loop,255
Hotkey,% Format("vk{:x}",A_Index),s,On
SetTimer,q,%1%
Return
s:
c++
Return
q:
MsgBox,%c%

This is not as short as other submissions, but it distinguishes itself by allowing you to use practically any key as a counter. This includes mouse clicks and control keys like Ctrl, Shift, etc. unless you use special keys that can never be blocked such Ctrl+Alt+Del on Windows.

Two important notes:

• The key presses and mouse clicks are blocked from other software
• The program does not terminate

If you actually run this program, it will count for 1 seconds (where the variable 1 is the first passed parameter), all the while counting how many key presses you made and blocking each one. When that time expires, it pops up a message box with the total. However, seeing as how all keyboard and mouse inputs are still blocked, it's rather difficult to dismiss that message. That sounds like a job for the next gatekeeper.

Answer 4

C++ 11, MSVC, 255 254 246 244 bytes, MSVC without /Za flag : 204 202 bytes

-1 byte thanks to Zacharý
-8 bytes thanks to Tas
-42 bytes for the second version thanks to Tas

Can be compiled with /Za flag ( disabled extensions ) :

#include<thread>
#include<conio.h>
#define S(t)std::this_thread::sleep_for(std::chrono::milliseconds(t))
int r=1;void k(int*a){while(r){if(_kbhit()&&_getch())++*a;S(1);}}int c(int n){int a=0;std::thread t(k,&a);S(n*1000);r=0;t.join();return a;}

Can't be compiled with /Za flag ( require enabled extensions ). For more details, see this answer

#include<thread>
#include<conio.h>
#include<Windows.h>
int r=1;void k(int*a){while(r){if(_kbhit()&&_getch())++*a;Sleep(1);}}int c(int n){int a=0;std::thread t(k,&a);Sleep(n*1000);r=0;t.join();return a;}

Ungolfed and explanations :

#include<thread> // For the thread standard library
// Console IO, C header used mostly by MS-DOS compilers. Not ISO C nor POSIX standard
#include<conio.h> // Used for _getch and _kbhit

//Macro that takes the number of milliseconds to make the current thread go to bed and sleep
#define S(t) std::this_thread::sleep_for(std::chrono::milliseconds(t))

//Global bool that will indicate the input thread if it continues to run or not
bool r=true;

/**
 * @brief: Function that increment a variable every time a key is pressed
 * @param a : a pointer to the memory location where to increment the counter
 * References are unfortunately forbidden
 */
void k(int* a) {
    while(r) {
        if(_kbhit() && _getch())
            ++*a;
        S(1);
    }
}

/** Function to call
 * @brief : Counts the number of time a key is pressed
 * @param : The number of seconds it have to capture the key presses
 * @return : the number of times a key was pressed
 */
int c(int n) {
    int a=0;
    std::thread t(k,&a);
    S(n*1000);
    r=false;
    t.join();
    return a;
}

Conio.h Wikipedia page

Answer 5

JavaScript (ES6), 50 bytes

t=>setTimeout("alert(i)",1e3*t,i=0,onclick=_=>i++)

Test Snippet

f=
t=>setTimeout("alert(i)",1e3*t,i=0,onclick=_=>i++)

;f(10)
document.write("click to count...")

*{user-select:none}

Answer 6

Bash + coreutils, 39 bytes

This is an ugly way that creates a file t in the current directory because I couldn't get process substitution to work.. You count by pressing the return key and it continues counting if it's held down.

Use it like this: $ f DURATION

---

f(){ timeout -s3 $1 cat>t;cat t|wc -l;}

Try it online!

Answer 7

C#, 132 122 bytes

namespace System.Threading.Tasks{n=>{int c=0;Task.Run(()=>{for(;;++c)Console.ReadKey();});Thread.Sleep(n*1000);return c;}}

Saved 10 bytes thanks to @DaveParsons.

Full/Formatted version:

namespace System.Threading.Tasks
{
    class P
    {
        static void Main()
        {
            Func<int, int> f = n =>
            {
                int c = 0;

                Task.Run(() =>
                {
                    for (; ; ++c)
                        Console.ReadKey();
                });

                Thread.Sleep(n * 1000);

                return c;
            };

            Console.WriteLine(f(10));

            Console.ReadLine();
        }
    }
}

Answer 8

Python 3, 116 110 Bytes

import time
def f(t):
 s,l=time.time(),[]
 while True:
  l.append(input())
  if time.time()-s>t:return len(l)

This is my first post, so not sure if this follows the format correctly. Thanks for another few bytes Step

Answer 9

C + gcc + Linux x86_64, 89 bytes

d[999];f(n){for(*d=0,d[1]=n;d[5]=1;*d+=read(0,d+5,4))if(!select(1,d+5,0,0,d+1))return*d;}

Pass the number of seconds in as the argument n. Press Enter to count a student (and don't press other keys before or during the function). Returns the number of students counted when time is up.

Extremely unportable, and easily the most evil code I've ever written. It makes assumptions about the size and layout of fd_set and struct timeval, and about the behavior of select.

Anyway, d[0] is the student counter, d[1] through d[4] is the struct timeval, and d[5] through d[260] is the fd_set. d[5] is also the unused scratch space passed to read, and then gets immediately reset to 1 for the next select call.

Answer 10

GameMaker Language, 49 45 bytes

Make sure you have default that uninitialized variables are treated as 0. Also, default fps is 30. We're looking for any key to be pressed and this does repeat if held down.

In step:

while s<argument0*30{a+=keyboard_check(1)++s}

Alternatively,

while(get_timer()<argument0*1000000)a+=keyboard_check(1)

Answer 11

JavaScript (Node.js), 112 111 bytes

t=>require('readline').createInterface(process.stdin).on('line',_=>k++,k=0,setTimeout(_=>console.log(k),t*1e3))

I don't think it can be golfed more because Node.js function names are pretty verbose.

Answer 12

Python 3, 88 bytes

Takes Enter as input and doesn't terminate.

from threading import*
l=[0]
Timer(int(input()),print,l).start()
while 1:input();l[0]+=1