Menu: Difference between revisions

 

=={{header|11l}}==

 

L

I Int(reply) C 1..items.len

print(‘You chose: ’items[Int(reply) - 1])

 

{{out}}

</pre>

 

 

procedure menu is

put_line ("You chose " &

choice ((+"fee fie",+"huff and puff",+"mirror mirror",+"tick tock"),"Enter your choice "));

 

=={{header|ALGOL 68}}==

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of '''format'''[ted] ''transput''}}

(

INT choice;

 

printf(($"You chose "g"."l$, menu select(items, prompt)))

Output:

<pre>

You chose huff and puff.

</pre>

 

=={{header|AutoHotkey}}==

if !list ; if called with an empty list

return ; return an empty string

InputBox , Choice, Please Select From Menu, % string ,, % 200<len*7 ? 200 ? len*7 , % 120 + x.count()*20

return x[Choice]

(

fee fie

MsgBox % Menu(list) ; call menu with list

MsgBox % Menu() ; call menu with empty list

 

 

=={{header|AWK}}==

# syntax: GAWK -f MENU.AWK

BEGIN {

}

}

 

=={{header|Axe}}==

{{incorrect|Axe|The function should return an empty string if called with an empty list. Please also check if this could really used as a [https://en.wikipedia.org/wiki/Subroutine function aka subroutine.]}}

In Axe, static data (such as strings) is laid out sequentially in memory. So the H in "HUFF" is the byte after the null terminator for "FIE". However, null terminators are only added to strings when they are stored with the store symbol →. strGet returns a pointer to the start of the nth null-terminated string in the data, which is why the strings must be laid out in memory correctly.

"HUFF AND PUFF"→Str2

"MIRROR MIRROR"→Str3

Return

End

 

=={{header|BASIC}}==

{{works with|QuickBasic|4.5}}

if ubound(choices$) - lbound(choices$) = 0 then sel$ = ""

ret$ = ""

while ret$ = ""

sel$ = ret$

 

 

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

Example 1

 

set "menuChoices="fee fie","huff and puff","mirror mirror","tick tock""

echo.Invalid Input. Please try again...

pause

Example 2

@echo off

 

echo.!string[%choice%]!

goto:eof

 

=={{header|BBC BASIC}}==

list$() = "fee fie", "huff and puff", "mirror mirror", "tick tock"

selected$ = FNmenu(list$(), "Please make a selection: ")

IF index%>=0 IF index%<=DIM(list$() ,1) IF list$(index%)="" index% = -1

UNTIL index%>=0 AND index%<=DIM(list$(), 1)

Empty entries in the list are not offered as options, nor accepted as a selection.

 

=={{header|Brat}}==

true? choices.empty?

{ "" }

}

 

 

=={{header|C}}==

#include <stdlib.h>

#include <string.h>

 

return items[choice - 1];

 

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

using System;

using System.Collections.Generic;

}

}

 

=={{header|C++}}==

#include <string>

#include <vector>

std::cout << "You chose: " << data_entry("> ", terms) << std::endl;

}

 

=={{header|Ceylon}}==

shared void run() {

value selection = menu("fee fie", "huff And puff", "mirror mirror", "tick tock");

}

 

 

=={{header|Clojure}}==

(if (empty? choices)

""

(println "You chose: "

(menu "Which is from the three pigs: "

 

=={{header|COBOL}}==

PROGRAM-ID. Test-Prompt-Menu.

 

.

 

 

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

(if (null choices)

""

(force-output)

(setf n (parse-integer (read-line *standard-input* nil)

 

=={{header|D}}==

 

string menuSelect(in string[] entries) {

try {

immutable n = input.to!int;

return typeof(return)((n >= 0 && n <= nEntries) ? n : -1);

} catch (Exception e) // Very generic

writefln(" %d) %s", i, entry);

"> ".write;

immutable input = readln.chomp;

if (choice.isNull)

"Wrong choice.".writeln;

immutable items = ["fee fie", "huff and puff",

"mirror mirror", "tick tock"];

writeln("You chose '", items.menuSelect, "'.");

{{out}}

0) fee fie

1) huff and puff

3) tick tock

> 2

 

=={{header|Elixir}}==

def select(_, []), do: ""

def select(prompt, items) do

items = ["fee fie", "huff and puff", "mirror mirror", "tick tock"]

response = Menu.select("Which is from the three pigs", items)

 

{{out}}

you chose: "tick tock"

</pre>

 

=={{header|ERRE}}==

PROCEDURE Selection(choices$[],prompt$->sel$)

IF UBOUND(choices$,1)-LBOUND(choices$,1)=0 THEN

sel$=ret$

END PROCEDURE

 

=={{header|Euphoria}}==

 

function menu_select(sequence items, object prompt)

constant prompt = "Which is from the three pigs? "

 

 

=={{header|F Sharp|F#}}==

 

let rec menuChoice (options : string list) prompt =

printfn "You chose: %s" choice

 

 

=={{header|Factor}}==

 

: print-menu ( seq -- )

] [ drop (select) ] if* ;

 

 

Example usage:

=={{header|Fantom}}==

{{incorrect|Fantom|The function should return an empty string if called with an empty list. Please also check if this could really used as a [https://en.wikipedia.org/wiki/Subroutine function aka subroutine.]}}

{

static Void displayList (Str[] items)

echo ("You chose: $choice")

}

 

=={{header|Forth}}==

===Idiomatic Forth===

Out of the box Forth does not have lists. This version uses strings and a vector table, which arguably is more how one would do this task in Forth. It returns a nil string if a nil string is given otherwise the input string becomes the title of the menu.

 

\ vector table compiler

CR [CHAR] 0 - SELECT

THEN

 

===If there must be lists===

Here we extend Forth to support simple lists and complete the task using the language extensions.

 

: STRING, ( caddr len -- ) HERE OVER CHAR+ ALLOT PLACE ;

CR SWAP {NTH}

THEN

 

Test at the gForth console

 

Please find the build instructions in the comments at the start of the FORTRAN 2008 source. Compiler: gfortran from the GNU compiler collection. Command interpreter: bash.

!a=./f && make $a && OMP_NUM_THREADS=2 $a

!gfortran -std=f2008 -Wall -fopenmp -ffree-form -fall-intrinsics -fimplicit-none f.f08 -o f

end program menu_demo

 

 

=={{header|Gambas}}==

Public Sub Main()

 

 

End

 

=={{header|Go}}==

 

import "fmt"

pick = menu(choices, "Enter number: ")

fmt.Printf("You picked %q\n", pick)

Output:

<pre>

You picked "huff and puff"

</pre>

 

=={{header|Haskell}}==

 

import Data.Maybe (listToMaybe)

 

maybeRead :: Read a => String -> Maybe a

 

Example usage, at the GHCI prompt:

1) fee fie

2) huff and puff

Choose an item: 3

"mirror mirror"

 

=={{header|HicEst}}==

{{incorrect|HicEst|The function should return an empty string if called with an empty list. Please also check if this could really used as a [https://en.wikipedia.org/wiki/Subroutine function aka subroutine.]}}

 

POP(Menu=list, SelTxt=answer)

! The global variable $$ returns the selected list index

WRITE(Messagebox, Name) answer, $$

 

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

 

L := ["fee fie", "huff and puff", "mirror mirror", "tick tock"]

 

repeat {

writes("Choose a number from the menu above: ")

a := read()

}

 

=={{header|J}}==

 

'''Solution:'''

CHOICES =: ];._2 'fee fie;huff and puff;mirror mirror;tick tock;'

PROMPT =: 'Which is from the three pigs? '

RESULT {:: CHOICES

)

 

See [[Talk:Select#J_implementation|Talk page]] for explanation.

 

=={{header|Java}}==

if(list.size() == 0) return "";

Scanner sc = new Scanner(System.in);

}while(ret == null);

return ret;

 

=={{header|JavaScript}}==

{{works with|Node.js}}

 

async function menuSelect(question, choices) {

menuSelect(question, choices).then((answer) => {

console.log(`\nYou chose ${answer}`);

 

=={{header|jq}}==

{{works with|jq|1.5}}

This version uses jq 1.5's 'input' builtin to read programmatically from STDIN.

def read(prompt; max):

def __read__:

| if ($read|type) == "string" then $read

else "Thank you for selecting \($in[$read-1])" end

'''Example:'''

$ jq -n -r -f Menu.jq

Enter your choice:

 

1

 

=={{header|Julia}}==

{{trans|Python}}

 

 

function _menu(items)

items = ["fee fie", "huff and puff", "mirror mirror", "tick tock"]

item = _selector(items, "Which is from the three pigs: ")

 

=={{header|Kotlin}}==

 

fun menu(list: List<String>): String {

val choice = menu(list)

println("\nYou chose : $choice")

Sample session:

{{out}}

 

=={{header|langur}}==

 

# print the menu

 

"Select entry #: ",

.y > 0 and .y <= len(.entries)

},

}

 

 

{{out}}

{{incorrect|Logo|The function should return an empty string if called with an empty list. Please also check if this could really used as a [https://en.wikipedia.org/wiki/Subroutine function aka subroutine.]}}

{{works with|UCB Logo}}

foreach :options [(print # ?)]

forever [

[Which is from the three pigs?]

[fee fie] [huff and puff] [mirror mirror] [tick tock])

 

=={{header|Lua}}==

if not list or #list == 0 then

return ""

print("Nothing:", select {})

print()

 

{{out}}

You chose: mirror mirror

</pre>

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

'''Interpreter:''' Wolfram Desktop and Wolfram Desktop Kernel

Redisplays the list of choices on every invalid input as per the task description. In the notebook interface (of Wolfram Desktop, at least), Print[] would most pragmatically be located outside of the loop because Input[] uses a dialog box.

 

If[Length@data == 0, Return@""];

While[!(IntegerQ@choice && Length@data >= choice > 0),

];

data[[choice]]

{{out|Kernel (REPL) output|note=function definition omitted}}

<pre>Wolfram Desktop Kernel (using Wolfram Language 12.0.0) for Microsoft Windows (64-bit)

 

=={{header|MATLAB}}==

if numel(list) == 0

end

 

=={{header|min}}==

{{works with|min|0.19.3}}

min has an operator <code>choose</code> that nearly conforms to this task. The input list is altered so that the choice can be returned, and the empty list case is handled.

:prompt =list

(list bool)

("fee fie" "huff and puff" "mirror mirror" "tick tock")

"Enter an option" menu

{{out}}

<pre>

=={{header|Modula-2}}==

{{incorrect|Modula-2|The function should return an empty string if called with an empty list. Please also check if this could really used as a [https://en.wikipedia.org/wiki/Subroutine function aka subroutine.]}}

 

FROM InOut IMPORT WriteString, WriteCard, WriteLn, ReadCard;

WriteLn;

END (*of IF*)

 

=={{header|MUMPS}}==

;http://rosettacode.org/wiki/Menu

NEW I,A,MAX

IF (A<1)!(A>MAX)!(A\1'=A) GOTO WRITEMENU

KILL I,MAX

Usage:<pre>

USER>W !,$$MENU^ROSETTA("fee fie^huff and puff^mirror mirror^tick tock","^")

=={{header|Nanoquery}}==

{{trans|Ursa}}

for ($i = 0) ($i < len($items)) ($i = $i + 1)

println " " + $i + ") " + $items[$i]

append $items "fee fie" "huff and puff" "mirror mirror" "tick tock"

$item = selector($items, "Which is from the three pigs: ")

 

=={{header|Nim}}==

{{trans|Python}}

proc menu(xs: openArray[string]) =

const xs = ["fee fie", "huff and puff", "mirror mirror", "tick tock"]

let item = selector(xs, "Which is from the three pigs: ")

 

{{out}}

 

=={{header|OCaml}}==

let select ?(prompt="Choice? ") = function

| [] -> ""

with _ -> menu ()

in menu ()

 

Example use in the REPL:

# select ["fee fie"; "huff and puff"; "mirror mirror"; "tick tock"];;

0: fee fie

Choice? 2

- : string = "mirror mirror"

 

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

i_c AS CHAR

):

MESSAGE

bashMenu( "fee fie,huff and puff,mirror mirror,tick tock" )

 

=={{header|Oz}}==

fun {Select Prompt Items}

case Items of nil then ""

in

 

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

{{incorrect|PARI/GP|The function should return an empty string if called with an empty list. Please also check if this could really used as a [https://en.wikipedia.org/wiki/Subroutine function aka subroutine.]}}

 

=={{header|Pascal}}==

{{works with|Free_Pascal}}

Tested with Free Pascal 2.6.4 (arm).

{$ASSERTIONS ON}

uses

 

dispose(MenuItems, Done);

 

{{out}}

 

=={{header|Perl}}==

{

my ($prompt,@array) = @_;

$a = &menu($prompt,@a);

 

 

=={{header|Phix}}==

sequence res = ""

items = remove_all("",items)

constant prompt = "Which is from the three pigs? "

string res = menu_select(items,prompt)

 

=={{header|PHP}}==

$stdin = fopen("php://stdin", "r");

$allowed = array(1 => 'fee fie', 'huff and puff', 'mirror mirror', 'tick tock');

break;

}

 

=={{header|PicoLisp}}==

(use N

(loop

(T (>= (length Items) N 1) (prinl (get Items N))) ) ) )

(choose "Which is from the three pigs?"

{{out}}

<pre>

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

{{incorrect|PL/I|The function should return an empty string if called with an empty list. Please also check if this could really used as a [https://en.wikipedia.org/wiki/Subroutine function aka subroutine.]}}

 

test: proc options (main);

 

end test;

 

=={{header|PowerShell}}==

function Select-TextItem

{

 

“fee fie”, “huff and puff”, “mirror mirror”, “tick tock” | Select-TextItem -Prompt "Select a string"

 

{{Out}}

=={{header|ProDOS}}==

{{incorrect|ProDOS|The function should return an empty string if called with an empty list. Please also check if this could really used as a [https://en.wikipedia.org/wiki/Subroutine function aka subroutine.]}}

:a

printline ==========MENU==========

printline You either chose an invalid choice or didn't chose.

editvar /newvar /value=goback /userinput=1 /title=Do you want to chose something else?

 

=={{header|Prolog}}==

{{works with|SWI-Prolog|6}}

rosetta_menu([], "") :- !. %% Incase of an empty list.

rosetta_menu(Items, SelectedItem) :-

prompt1('Select a menu item by number:'),

read(Choice).

 

Example run:

 

?- rosetta_menu(["fee fie", "huff and puff", "mirror mirror", "tick tock"], String).

 

Select a menu item by number:3.

String = "mirror mirror".

 

=={{header|PureBasic}}==

Define i, txt$, choice

Dim txts.s(4)

TheStrings:

Data.s "fee fie", "huff And puff", "mirror mirror", "tick tock"

 

=={{header|Python}}==

 

for indexitem in enumerate(items):

print (" %2i) %s" % indexitem)

items = ['fee fie', 'huff and puff', 'mirror mirror', 'tick tock']

item = selector(items, 'Which is from the three pigs: ')

 

Sample runs:

 

Uses [http://www.stat.ucl.ac.be/ISdidactique/Rhelp/library/base/html/menu.html menu].

{

if (is.null(choices)) return("")

str <- showmenu(c("fee fie", "huff and puff", "mirror mirror", "tick tock"))

str <- showmenu()

 

=={{header|Racket}}==

 

#lang racket

 

 

(menu '("fee fie" "huff and puff" "mirror mirror" "tick tock"))

 

Sample Run:

=={{header|Raku}}==

(formerly Perl 6)

return '' unless @items.elems;

repeat until my $selection ~~ /^ \d+ $/ && @items[--$selection] {

 

$answer = menu( $prompt, @choices );

 

=={{header|REBOL}}==

{{incorrect|REBOL|The function should return an empty string if called with an empty list. Please also check if this could really used as a [https://en.wikipedia.org/wiki/Subroutine function aka subroutine.]}}

Title: "Text Menu"

URL: http://rosettacode.org/wiki/Select

choice: ask "Which is from the three pigs? "

]

 

Output:

You chose: huff and puff</pre>

=={{header|Red}}==

 

menu: function [items][

attempt [pick items to-integer ask "Your choice: "]

]]

 

{{out}}

 

=={{header|REXX}}==

do forever /*keep prompting until response is OK. */

call list_create /*create the list from scratch. */

return

/*──────────────────────────────────────────────────────────────────────────────────────*/

{{out|output|text=&nbsp; (which includes what the user entered):}}

<pre>

 

=={{header|Ring}}==

aList = ["fee fie", "huff and puff", "mirror mirror", "tick tock"]

selected = menu(aList, "please make a selection: ")

end

return aList[index]

Output:

<pre>

mirror mirror

</pre>

 

=={{header|Ruby}}==

def select(prompt, items = [])

if items.empty?

response = select('Which is from the three pigs', items)

puts "you chose: >#{response}<"

 

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

choose$(1) = "1 Fee Fie"

choose$(2) = "2 Huff Puff"

cls

end

 

=={{header|Rust}}==

fn menu_select<'a>(items: &'a [&'a str]) -> &'a str {

if items.len() == 0 {

println!("You chose: {}", selection);

}

 

=={{header|Scala}}==

===Scala idiom (Functional)===

 

object Menu extends App {

 

println(s"\nYou chose : $choice")

 

=={{header|Seed7}}==

 

const func string: menuSelect (in array string: items, in string: prompt) is func

begin

writeln("You chose " <& menuSelect(items, prompt));

 

=={{header|Sidef}}==

arr.len > 0 || return ''

loop {

 

var answer = menu(prompt, list)

 

=={{header|Swift}}==

 

guard !selections.isEmpty else {

return ""

])

 

 

=={{header|Tcl}}==

set nc [llength $choices]

if {!$nc} {

}

}

Testing it out interactively...

><

% puts >[select "Which is from the three pigs" {

4: tick tock

Which is from the three pigs: 2

 

=={{header|TI-83 BASIC}}==

Output with <tt>FEE FIE:HUFF AND PUFF:MIRROR MIRROR:TICK TOCK</tt>

 

2:HUFF AND PUFF

3:MIRROR MIRROR

4:TICK TOCK

 

 

Lbl D

Disp Str3

 

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

{{works with|pdksh}}

{{works with|zsh}}

# Prints menu to standard error. Prompts with PS3.

# Reads REPLY from standard input. Sets CHOICE.

choose 'fee fie' 'huff and puff' 'mirror mirror' 'tick tock'

[[ -n $CHOICE ]] && echo You chose: $CHOICE

 

<pre>$ bash menu.sh

* ''Deviation from task:'' When the list of choices is empty, this function returns an empty list, not an empty string.

 

# Prints menu to standard error. Prompts with $prompt.

# Returns choice. If no input, returns empty list.

~ $#choice 1 && echo You chose: $choice

~ $#choice 0 && echo No input.

 

<pre>$ es menu.es

=={{header|Ursa}}==

{{trans|Python}}

for (decl int i) (< i (size items)) (inc i)

out " " i ") " items<i> endl console

decl string item

set item (selector items "Which is from the three pigs: ")

 

=={{header|VBScript}}==

Function Menu(ArrList, Prompt)

Select Case False 'Non-standard usage hahaha

Sample = Array("fee fie", "huff and puff", "mirror mirror", "tick tock")

InputText = "Which is from the three pigs: "

{{Out}}

<pre>C:\>cscript /nologo menu.vbs

Which is from the three pigs: 2

Output: huff and puff</pre>

 

=={{header|XPL0}}==

 

func Menu(List);

 

Text(0, Menu([5, "fee fie", "huff and puff", "mirror mirror", "tick tock",

 

Example output:

huff and puff

</pre>

 

=={{header|zkl}}==

os:=T("exit").extend(vm.arglist); N:=os.len();

if(N==1) return("");

 

teleprompter("fee fie" , "huff and puff" , "mirror mirror" , "tick tock")

{{out}}

<pre>