Keyboard input/Obtain a Y or N response: Difference between revisions

The response should be obtained as soon as   '''Y'''   or   '''N'''   are pressed, and there should be no need to press an   enter   key.

<br><br>

 

=={{header|8th}}==

\ get a yes or no response from the keyboard

: yes-no

"Yes or no? " con:print yes-no no?

cr bye

 

=={{header|Ada}}==

 

Answer : Character;

begin

end case;

end loop;

 

=={{header|AutoHotkey}}==

Input, Key, L1

if (Key = "n" || Key = "y")

}

MsgBox, % "The response was """ Key """."

 

=={{header|AWK}}==

# syntax: GAWK -f KEYBOARD_INPUT_OBTAIN_A_Y_OR_N_RESPONSE.AWK

BEGIN {

return(rec)

}

{{out}}

<pre>

=={{header|Axe}}==

Since the TI-83/84 require a modifier key to access the letters, this example uses the 2nd key as Y and the Clear key as N.

End

 

Return

End

 

=={{header|BASIC}}==

==={{header|Applesoft BASIC}}===

 

20 PRINT "PRESS Y OR N TO CONTINUE"

30 GET K$

40 IF K$ < > "Y" AND K$ < > "N" THEN 30

50 PRINT "THE RESPONSE WAS ";K$

 

 

 

20 WHILE T$<>"y" AND T$<>"Y" AND T$<>"n" AND T$<>"N"

30 T$=""

80 WEND

90 PRINT "The response was "; T$

 

 

20 PRINT "Press Y or N to continue"

30 a$=LOWER$(INKEY$)

60 IF a$="n" THEN PRINT "No":END

70 PRINT "Try again"

 

==={{header|ZX Spectrum Basic}}===

Note that this will also work in [[GW-BASIC]] and most [[QBasic]]-compatible BASICs if all instances of "<code>GO TO</code>" are changed to "<code>GOTO</code>".

 

20 PRINT "Press Y or N to continue"

30 LET k$ = INKEY$

40 IF k$ <> "y" AND k$ <> "Y" AND k$ <> "n" AND k$ <> "N" THEN GO TO 30

 

=={{header|Batch File}}==

@echo off

choice

if errorlevel 1 echo You chose Y

>nul pause

 

=={{header|C}}==

For POSIX compliant systems (in theory that includes WinNT family).

#include <stdio.h>

#include <termios.h>

 

return 0;

 

=={{header|C sharp}}==

 

 

namespace Y_or_N

}

}

 

=={{header|Clojure}}==

 

 

(ns yprompt.core

(:import jline.Terminal)

(defn -main [& args]

(prompt))

 

=={{header|Common Lisp}}==

Version 1:

 

(defun rosetta-y-or-n ()

(clear-input *query-io*)

(y-or-n-p))

 

Version 2:

 

(defun y-or-n ()

(clear-input *standard-input*)

when q do (format t "~%Need Y or N~%")

unless q return (if (equal c #\y) 'yes 'no)))

 

Version 1 and 2 work as required in a LispWorks GUI interface, i.e. they return immediately when the y or n keys are pressed, without waiting for the Enter key.

Version 3:

 

(defun y-or-no ()

(with-screen (scr :input-buffering nil :input-blocking t)

((#\Y #\y) (return-from event-case t))

((#\N #\n) (return-from event-case nil)))))

 

=={{header|D}}==

 

extern (C) nothrow {

writefln("\nResponse: %c", cast(char)c);

_STD_conio();

{{out}}

<pre>Enter Y or N: abcN

Response: N</pre>

 

=={{header|Elm}}==

import Graphics.Element exposing (Element, empty, show)

import Keyboard

main : Signal Element

main =

 

=={{header|ERRE}}==

!$KEY

................

PRINT("The response was ";K$)

.................

<code>!$KEY </code> is a directive pragma: using it <code>GET</code> become an equivalent to Qbasic INKEY$, otherwise it's equivalent to QBasic INPUT$(1). !$KEY is also used to mantain portability with the C-64 version of ERRE language.

 

=={{header|Euphoria}}==

 

puts(1,"Your answer? (Y/N)\n")

end while

 

 

=={{header|F_Sharp|F#}}==

 

let rec yorn () =

| _ -> yorn()

 

 

=={{header|Forth}}==

begin key? while key drop repeat ;

 

[char] n of 2drop false exit endof

[char] N of 2drop false exit endof

 

=={{header|Fortran}}==

 

Even so, asking questions can often be useful when messing about with tests, etc., so some routines for this can help. These were devised afresh at the Culham Science Centre, so there was some language generality:

CHARACTER*120 FUNCTION REPLY(QUERY) !Obtain a text in reply.

Concocted by R.N.McLean (whom God preserve), December MM.

RETURN !Pass the inverted word.

END !So much for naysayers.

Usage might be something like <code>IF (NAY("Keep the results")) CALL PURGE</code>

 

=={{header|FreeBASIC}}==

 

While InKey <> "" : Wend '' flush keyboard buffer

End If

 

 

Sample input/output:

 

=={{header|FutureBasic}}==

end select

end fn

 

on dialog fn DoDialog

 

 

=={{header|GlovePIE}}==

var.end=0

debug="Press the Y key or the N key to continue:"

var.end=1

debug="You pressed the N key."

 

=={{header|Go}}==

{{libheader|Curses}}

 

import (

s.Refresh()

s.GetChar()

 

=={{header|GW-BASIC}}==

20 PRINT "Press Y or N to continue"

30 LET k$ = INKEY$

40 IF k$ <> "y" AND k$ <> "Y" AND k$ <> "n" AND k$ <> "N" THEN GOTO 30

 

=={{header|Haskell}}==

This may not be very idiomatic; it's pretty monad-oriented, and the use of do expressions makes the whole thing feel rather imperative.

 

 

hFlushInput :: Handle -> IO ()

hFlushInput stdin

answer <- yorn

 

=={{header|Icon}} and {{header|Unicon}}==

 

This solution works in both Icon and Unicon. It also accepts <tt>y</tt> or <tt>n</tt>.

write("Response was ",getResponse("OK? (Y or N): "))

end

repeat if map(answer := getch()) == ("y"|"n") then break

return answer

 

=={{header|Inform 7}}==

 

Inform 7 has a built-in function to ask the user for yes-or-no input, but it requires them to press enter afterward:

 

When play begins:

say "A wizard has turned you into a whale. Is this awesome (Y/N)? ";

if the player consents, say "Awesome!";

 

To read a single key without waiting for enter, we can redefine the function by including a snippet of Inform 6 code:

 

Include (-

do { ch = VM_KeyChar(); } until (ch == 'y' or 'Y' or 'n' or 'N');

return ch == 'y' or 'Y';

 

=={{header|JavaScript}}==

Here's a synchronous ES6 implementation. The synchronous code must be executed in an async function definition. In this example, `wait_key` returns the key pressed and `done` must be called decouple the listening to stdin and end the process. The example pauses for a second to show that the keys pressed before `wait_key` is called are not heard.

 

readline.emitKeypressEvents(process.stdin);

process.stdin.setRawMode(true);

 

go();

 

Here's how you can asynchronously read a single character in Node.js, using the <code>keypress</code> package.

This does not seem to be possible to do synchronously in Node.js or at all in the SpiderMonkey shell.

 

 

keypress(process.stdin);

 

process.stdin.setRawMode(true);

 

Using DOM events.

 

var key = String.fromCharCode(e.keyCode).toLowerCase();

if (key === 'y' || key === 'n') {

console.log('response is: ' + key);

}

 

=={{header|Julia}}==

Uses the Gtk library.

function keypresswindow()

keypresswindow()

 

=={{header|Kotlin}}==

 

import java.awt.event.KeyAdapter

f.isVisible = true

}

 

=={{header|Liberty BASIC}}==

nomainwin

open "Y/N" for graphics_nsb_nf as #1

end

end sub

 

=={{header|LiveCode}}==

 

In the text field, put the following in its code

if toUpper(k) is among the items of "Y,N" then

answer "Thanks for your response"

end if

put empty into me

 

n.b. This sort of confirmation in GUI apps is usually presented as a dialog box with Yes/No buttons, which automatically handles keyboard input.

 

=={{header|Logo}}==

type [Press Y or N to continue: ]

local "clear

print :yorn

output :yorn

 

=={{header|M2000 Interpreter}}==

===Simple Loop using Key$===

If keyboard is Greek the we have to change to English. Other examples use Keyboard codes.

Module Simple {

\\ a small modification from BBC BASIC entry

}

Simple

 

===Use a Function to return keypress and by reference return value===

Module Checkit {

Function GetYN$ (&Ret) {

}

Checkit

 

===Using Thread to read/write Keyboard buffer===

Using Profiler and Print Timecount we get the real duration (using high resolution timer), of response.

 

Module CheckisToo {

Module GetYN (&Ret) {

}

CheckisToo

 

===Using User Form (GUI)===

Module UseUIForm {

Const Y=0x59, N=0x4E, Center=2

}

UseUIForm

 

=={{header|Microsoft Small Basic}}==

Submitted by: '''AykayayCiti''' (''Earl L. Montgomery'') on Mar 19, 2018.

Once you hit a key a separate dialog box will appear. Place them side by side to see the results.

'Andy Oneill, 2-6-2015, "Small Basic: Key Input,

'" TechNet, https://social.technet.microsoft.com/wiki/contents/articles/29850.small-basic-key-input.aspx, accessed 3-19-2018

Sub OnKeyDown

TextWindow.WriteLine(GraphicsWindow.LastKey)

 

=={{header|NetRexx}}==

 

options replace format comments java crossref savelog symbols binary

when c='N' Then Say 'NO'

otherwise Say 'Undecided'

 

=={{header|Oforth}}==

 

 

: YorN

c 'Y' <> c 'N' <> and

]

 

=={{header|OpenEdge/Progress}}==

 

DO WHILE lanswer = ?:

END.

 

 

=={{header|PARI/GP}}==

{{works with|Free_Pascal}}

{{libheader|CRT}}

 

uses

writeln;

writeln ('Your answer was: ', key);

Output:

<pre>% ./ObtainYN

 

=={{header|Perl}}==

 

ReadMode 4; # change to raw input mode

 

print "\nYou typed: $key\n";

 

=={{header|Phix}}==

 

=={{header|PicoLisp}}==

(loop

(NIL (uppc (key)))

(T (= "Y" @) T)

 

=={{header|PL/I}}==

Dcl sysin stream input;

Dcl sysprint stream output;

Put Skip List('Undecided?');

End;

 

=={{header|PowerShell}}==

This is for console use only. The ISE is geared for a different type of input.

do

{

 

$keyPress | Format-Table -AutoSize

If the user pressed the "Y" key...

{{Out}}

=={{header|PureBasic}}==

Inkey() returns the character string of the key which is being pressed at the time.

 

Repeat

Delay(1)

Until Key$="Y" Or Key$="N"

 

=={{header|Python}}==

 

try:

if char.lower() in ("y", "n"):

print char

----

# -*- coding: utf-8 -*-

from curses import wrapper

if __name__ == "__main__":

#

 

=={{header|QUACKASM}}==

Note: The following is not a full program (it is only a subroutine, using standard calling conventions), nor does it flush the keyboard buffer (there is no standard way to do this in QUACKVM; it may be possible using extensions, but none are currently defined).

; Stores result in cell 2; 1 if yes, 0 if no.

:YORN

RETURN

:YORNMSG " (Y/N)? \

 

=={{header|Racket}}==

#lang racket

 

[else (loop)]))

(stty tty-settings)

 

 

=={{header|REXX}}==

<br>Some older Classic REXX interpreters have a keyboard read subroutine (BIF) so that the program can read keyboard keys as

<br>they are pressed &nbsp; (see the other versions below).

 

do queued(); pull; end /*flush the stack if anything is queued*/

ans=space(ans, 0) /*elide all blanks. */

end /*until*/

 

===version 1 for PC/REXX and Personal REXX===

This version of a REXX program works with PC/REXX and Personal REXX.

prompt = 'Please enter Y or N for verification:' /*this is the PROMPT message.*/

 

ans=inKey('wait') /*get the answer(s) from the terminal. */

end /*until*/

 

===version 2 for PC/REXX and Personal REXX===

This version is the same as above, but has a more idiomatic technique for testing the response.

prompt = 'Please enter Y or N for verification:' /*this is the PROMPT message.*/

 

ans=inKey('wait'); upper ans /*get the answer(s); and uppercase it.*/

end /*until*/

 

=={{header|Ring}}==

while true

give c

else see "Try again!" + nl ok

end

 

=={{header|Ruby}}==

def yesno

begin

end

end

 

Ruby provides the io/console module since version 2.0:

require 'io/console'

 

end

end

 

=={{header|Run BASIC}}==

html "Click Y or N" ' no other options

button #y, "Y", [Y] ' they either click [Y]

[Y] msg$ = "You entered [Y]es": goto [loop]

[N] msg$ = "You entered [N]o" : goto [loop]

=={{header|Rust}}==

{{libheader|Ncurses}}

 

extern crate ncurses;

refresh();

endwin();

 

=={{header|Scala}}==

 

----

import java.io.InputStreamReader

val in = new InputStreamReader(System.in)

if (Seq(121, 89, 110, 78).contains(in.read()) ) {println("Yes|No")} else {println("other")}

----

import scala.io.{Source, BufferedSource}

val kbd_In: BufferedSource = Source.stdin

//res?: Char = 'y' not :String = "y"

if (Seq('y', 'Y', 'n', 'Y').contains(kbd_In.next()) ) {println("Typed y|Y|n|N")} else {println("other key")}

 

=={{header|Seed7}}==

include "keybd.s7i";

 

var char: answer is ' ';

begin

ignore(getc(KEYBOARD));

end while;

begin

writeln(yesOrNo("Press Y or N to continue "));

 

=={{header|Sidef}}==

{{trans|Perl}}

static rk = frequire('Term::ReadKey');

rk.ReadMode(4); # change to raw input mode

 

var key = prompt_yn();

{{out}}

<pre>

You typed: Y

</pre>

 

=={{header|Tcl}}==

Using the console (expects U*Xish <tt>stty</tt>)

 

fconfigure stdin -blocking 0

exec stty raw

}

 

 

Without a console (answer in the global variable yn; this should work in any GUI for which there is a TCL):

 

proc yesno {message} {

toplevel .msg

yesno "Do you like programming?"

 

 

=={{header|TXR}}==

This works not only on Unix-like platforms, but also on Microsoft Windows, because TXR is ported to Windows using a [https://www.kylheku.com/cygnal/index.html modified version of Cygwin].

 

(let ((tio (copy tio-orig)))

tio.(go-raw)

(tcsetattr tio tcsaflush) ;; third arg optional, defaults to tcsadrain

(whilet ((k (get-char))

 

The <code>go-raw</code> method on the <code>termios</code> structure only manipulates the structure contents; <code>tcsetattr</code> pushes it down to the TTY driver.

<code>go-raw</code> is defined in the TXR standard library like this:

 

tio.(clear-iflags ignbrk brkint parmrk istrip inlcr igncr icrnl ixon)

tio.(clear-oflags opost)

tio.(set-cflags cs8)

(set tio.[cc vmin] 1)

 

=={{header|UNIX Shell}}==

{{works with|Bourne Again SHell}}

local stty="$(stty -g)"

trap "stty $stty; trap SIGINT; return 128" SIGINT

[Nn]) echo >&2 N; return 1;;

esac

 

Cleaner version using bash built-ins

 

 

yorn() {

}

 

 

=={{header|VB-DOS}}==

DIM T AS INTEGER

T = MSGBOX("Click on yes or no", 4, "Option")

IF T = 6 THEN PRINT "yes"; ELSE PRINT "no";

PRINT "."

 

=={{header|Vedit macro language}}==

do {

#1 = Get_Key("Are you sure? (Y/N): ") // prompt for a key

#1 &= 0xdf // to upper case

 

=={{header|XPL0}}==

loop [OpenI(1); \flush any pending keystroke

case ChIn(1) of \get keystroke

other ChOut(0, 7\bel\);

CrLf(0);

 

 

{{omit from|GUISS}}