对于计算机语言，保留字是不能用作标识符的字，例如变量，函数或标签的名称。对于其他计算机语言，可以将关键字视为语言说明的集合。

挑战

使用您选择的语言，使用所选语言编写代码，给定一个介于1到10之间的数字1<=n<=10，输出n所选语言的任何保留字（关键字）。

细节

• 如果选择的语言区分大小写，则输出的关键字也必须是区分大小写的。
• 如果所选语言不区分大小写，则输出的关键字在任何情况下都可以。
• 如果所选语言的关键词少于10个p，则代码必须输出和n之间的所有保留字。p10
• 如果可能，请在答案中指定是否将运算符视为关键字。

Java（JDK10）的可能示例

• n=1 --> true
• n=3 --> try new interface
• n=4 --> continue this long break

> <>的可能样本

• n=1 --> >
• n=3 --> > < ^
• n=4 --> > < \ /

Brain-Flak的可能样本

• n=1 --> (
• n=3 --> ( ) [ ]
• n=9 --> ( ) [ ] { } < >

规则

• 输入和输出可以任何方便的格式给出。
• 无需处理无效的输入值，有效的输入为：1、2、3、4、5、6、7、8、9、10。
• 完整的程序或功能都是可以接受的。如果是函数，则可以返回输出而不是打印输出。
• 如果可能，请提供一个指向在线测试环境的链接，以便其他人可以尝试您的代码！
• 禁止出现标准漏洞。
• 这是 代码高尔夫球 因此所有常规的高尔夫规则都适用，并且最短的代码（以字节为单位）获胜。

APL（Dyalog Unicode），9 字节^SBCS

完整程序。提示输入stdin n（实际上适用于0-29范围）。APL关键字是单字符符号，因此这会将n符号输出到stdout。

⎕↑156↓⎕AV

在线尝试！

⎕AV 原子向量（即字符集）

156↓ 删除前156个元素

⎕↑ 提示n并从上面吸收很多元素

Python 2，25个字节

lambda n:'=+*/%&^|<>'[:n]

一个未命名的函数，它在[1,10]中接受一个整数，该整数返回一串单字节二进制运算符。

在线尝试！

运营商：

=  Assign
+  Addition
*  Multiplication
/  Division
%  Modulo
&  Bitwise-AND
^  Bitwise-XOR
|  Bitwise-OR
<  Less Than?
>  Greater Than?

如果只允许使用实际关键字：40个字节

from keyword import*
lambda n:kwlist[:n]

一个未命名的函数，该函数在[1,10]中接受一个整数，该整数返回字符串列表。

在线尝试！

该代码应该是相当简单的-它定义了一个函数带一个参数，n使用lambda n:...它返回第一n（...[:n]使用标准库的已知的关键字）keywords.kwlist（连同标准高尔夫技术的import*）。

Java 10、83 72个字节（关键字）

n->"do   if   for  int  new  try  var  byte case char ".substring(0,n*5)

在线尝试。

旧的83个字节的答案：

n->java.util.Arrays.copyOf("do if for int new try var byte case char".split(" "),n)

在线尝试。

说明：

n->                         // Method with integer parameter and String-array return-type
  java.util.Arrays.copyOf(  //  Create a copy of the given array:
    "do if for int new try var byte case char".split(" ") 
                            //   The keywords as String-array,
    ,n)                     //   up to and including the given `n`'th array-item

Java 8可用关键字的列表。Java 10 var除了这些关键字以外，还具有关键字。

Java 8 +，30个字节（运算符）

n->"+-/*&|^~<>".substring(0,n)

在线尝试。

果冻，3 个字节

ØAḣ

一个接受整数并返回字符列表的单子链接。

在线尝试！

结果字符是Jelly 代码页中的所有单子原子：

A   Absolute value.
B   Convert from integer to binary.
C   Complement; compute 1 − z.
D   Convert from integer to decimal.
E   Check if all elements of z are equal.
F   Flatten list.
G   Attempt to format z as a grid.
H   Halve; compute z ÷ 2.
I   Increments; compute the differences of consecutive elements of z.
J   Returns [1 … len(z)].

怎么样？

ØAḣ - Link: integer n (in [1,10])
ØA  - yield uppercase alphabet = ['A','B','C',...,'Z']
  ḣ - head to index n

木炭，16 字节

✂”yＰＢＧ¤Ｔ⎚Ｍ↶↷Ｊ”⁰Ｎ

不幸的是，木炭中没有用于其自身代码页的预设变量。

在线尝试。

说明：

获取从索引0到输入数字的子字符串：

Slice("...",0,InputNumber)
✂”y...”⁰Ｎ

包含10个关键字的字符串：

”yＰＢＧ¤Ｔ⎚Ｍ↶↷Ｊ”

Perl 5，24 -lp个字节

#!/usr/bin/perl -lp
$_=(grep!eval,a..zz)[$_]

在线尝试！

轻松扩展至更多和更长的关键字，但你需要做特殊的外壳开始在4个字母，因为你会遇到有问题的dump，eval，exit，getc等。

当然，仅输出运算符和信号很无聊，但更短，只有11个字节：

#!/usr/bin/perl -lp
$_=chr$_+35

在线尝试！

（#由于不清楚如何应对这一挑战，我将其跳过了）

JavaScript（Node.js），79 61字节

n=>'true int var for in if new try of do'.split` `.slice(0,n)

在线尝试！

怎么样 ：

n =>         // the input (will be an integer) between 1 and 10 (both inclusive)
    '        // beginning our string 
        true int var for in if new try of do'. // space separated reserved words
    split` `.        // turn it into an array every time there is a space we add to array
    slice(0,n)      // return elements of array starting from 0 and upto n

如果允许使用运算符（最有可能是因为它们是保留字），则：

JavaScript（Node.js），26 25字节

n=>'|/^%+<&*-='.slice(-n)

在线尝试！

@Adam节省了8个字节，@ L4m2节省了 1个字节

怎么样 ：

n =>     // input (integer from 0-9 inclusive)
    '|/^%+<&*-='.    // operators make a shorter string 
        slice(-n)   // outputs string chars from last upto n 
            // this works since all operators are single chars and not multi chars.

红宝石，22字节

->n{'+-*/%&|^<>'[0,n]}

在线尝试！

-2个字节，感谢@ benj2240

Pyth，4个字节

>QPG

在线尝试！

不幸的是，许多字母都是变量（GHJKNQTYZbdkz）。

p  <any>                  Print A, with no trailing newline. Return A.
q  <any> <any>            A == B
r  <str> 0                A.lower()
r  <str> 1                A.upper()
r  <str> 2                A.swapcase()
r  <str> 3                A.title()
r  <str> 4                A.capitalize()
r  <str> 5                string.capwords(A)
r  <str> 6                A.strip() - Remove whitespace on both sides of A.
r  <str> 7                Split A, eval each part.
r  <seq> 8                Run length encode A. Output format [[3, 'a'], [2, 'b'], [1, 'c'], [1, 'd']].
r  <str> 9                Run length decode A. Input format '3a2bcd' -> 'aaabbcd'
r  <seq> 9                Run length decode A. Input format [[3, 'a'], [2, 'b'], [1, 'c'], [1, 'd']].
r  <int> <int>            Range, half inclusive. range(A, B) in Python, or range(A, B, -1).
r  <str> <str>            String range. r(C(A), C(B)), then convert each int to string using C.
r  <int> <seq>            r(B, A)
s  <col(str)>             Concatenate. ''.join(A)
s  <col>                  reduce on +, base case []. (Pyth +)
s  <cmp>                  Real part. A.real in Python.
s  <num>                  Floor to int. int(A) in Python.
s  <str>                  Parse as int. "" parses to 0. int(A) in Python.
t  <num>                  A - 1.
t  <seq>                  Tail. A[1:] in Python.
u  <l:GH> <seq/num> <any> Reduce B from left to right, with function A(_, _) and C as starting value. G, H -> N, T ->. A takes current value, next element of B as inputs. Note that A can ignore either input.
u  <l:GH> <any> <none>    Apply A(_, _) until a result that has occurred before is found. Starting value B. A takes current value, iteration number as inputs.
v  <str>                  Eval. eval(A) without -s, ast.literal_eval(A) with -s (online). literal_eval only allows numeric, string, list, etc. literals, no variables or functions.
w                         Take input. Reads up to newline. input() in Python 3.
x  <int> <int>            Bitwise XOR. A ^ B in Python.
x  <lst> <any>            First occurrence. Return the index of the first element of A equal to B, or -1 if none exists.
x  <str> <str>            First occurrence. Return the index of the first substring of A equal to B, or -1 if none exists.
x  <non-lst> <lst>        All occurrences. Returns a list of the indexes of elements of B that equal A.
x  <str> <non-lst>        First occurence. Return the index of the first substring of A equal to str(B), or -1 if none exists.
y  <seq>                  Powerset. All subsets of A, ordered by length.
y  <num>                  A * 2.

C＃.NET，76 62字节（关键字）

n=>"as  do  if  in  is  for int new out ref ".Substring(0,n*4)

在线尝试。

旧的76个字节的答案：

using System.Linq;n=>"as do if in is for int new out ref".Split(' ').Take(n)

在线尝试。

说明：

using System.Linq;  // Required import for Take
n=>                 // Method with integer parameter and IEnumerable<string> return-type
  "as do if in is for int new out ref".Split(' ') 
                    //  The keywords as string-array,
  .Take(n)          //  and return the first `n` items

C＃.NET中的可用关键字列表。

C＃.NET，30个字节（运算符）

n=>"+-/*&|^~<>".Substring(0,n)

在线尝试。

魅力 52字节

这将输出Charm中的所有保留字。

" [  := :: \"   " 0 2 copyfrom 3 * substring pstring

由于Charm中的所有非递归代码都是可内联的，因此这是一个匿名函数。像这样打电话：

4 " [  := :: \"   " 0 2 copyfrom 3 * substring pstring 

（输出[ := :: "，只有四个保留字。）

给该函数命名会增加5个字节：

f := " [  := :: \"   " 0 2 copyfrom 3 * substring pstring

Brain-Flak，122120字节

({}<((((((((((((((()()){}()){}){}){})())[][]){}())()())[(([][]){}){}()])()())){}())[()()])>){({}<{({}<>)(<>)}{}>[()])}<>

在线尝试！

尽我所能填写示例语言。输出()[]<>}{，从前面弹出小于8的数字。

一元，6072204020736072426436 378380483266268字节

+[>+<+++++]>---. (0o12602122222703334)

感谢Jo King减少了99.999993768646738908474177860631％

红宝石，50 49字节

->n{%w[do if or in end not for def nil and][0,n]}

在线尝试！

不使用任何运算符（+，|等）。

Ruby，71 68字节

->n{(?a..'zzz').reject{|x|begin;eval x+'=n';rescue Object;end}[0,n]}

好的，这不是最短的方法，但是太有趣了，不能发布。以编程方式查找所有不能分配给最多三个小写字母的字符串。有碰巧正好是10： ["do", "if", "in", "or", "and", "def", "end", "for", "nil", "not"]。

编辑：由于Asone Tuhid，节省了3个字节。

Japt，3个字节

返回一个字符串，每个字符都是Japt中的方法名称。

;îC

尝试一下

;C是小写字母，î重复该字母直到其长度等于输入。

鸡肉，7个字节

chicken

不是认真的答案。但是它必须在这里。

R，76 62 60 57字节

多亏了MickyT，节省了12个字节

snoram节省了5个字节

cat(c("if","in",1:0/0,"for",F,T,"NULL","else")[1:scan()])

在线尝试！

R中的保留字并不多，但其中最短的是编码。这里只有9个，但是如果输入，10则缺少的值NA将附加到列表的末尾并打印出来。

Python 2，64个字节

lambda n:'as if def del for try elif else from pass'.split()[:n]

在线尝试！

Python 2，57个字节（带运算符）

lambda n:'as if in is or and def del for not'.split()[:n]

在线尝试！

关键字
运算符

空格，84字节

[S S S T    S S S S S N
_Push_32][S N
S _Duplicate][T N
S S _Print_as_character][S N
S _Duplicate][T N
T   T   _Read_STDIN_as_integer][T   T   T   _Retrieve][S S S T  N
_Push_1][T  S S T   _Subtract][S N
S _Duplicate][N
T   S N
_If_0_Jump_to_Label_EXIT][S S S T   S S T   N
_Push_9][T  N
S S Print_as_character][S S S T N
_Push_1][T  S S T   _Subtract][N
T   S N
_If_0_Jump_to_Label_EXIT][S S S T   S T S N
_Push_10][T N
S S _Print_as_character][N
S S N
_Create_Label_EXIT]

字母S（空格），T（制表符）和N（换行符）仅作为突出显示而添加。
[..._some_action]仅作为说明添加。

空格仅包含三个有效的“关键字”：空格，制表符和换行符。

伪代码中的解释：

Print space
Integer i = STDIN as integer - 1
If i is 0:
  Exit program
Else:
  Print tab
  i = i - 1
  If i is 0:
    Exit program
  Else:
    Print new-line
    Exit program

示例运行：

输入： 1

Command       Explanation                 Stack      Heap      STDIN    STDOUT   STDERR

SSSTSSSSSN    Push 32                     [32]
SNS           Duplicate top (32)          [32,32]
TNSS          Print as character          [32]                          <space>
SNS           Duplicate top (32)          [32,32]
TNTT          Read STDIN as integer       [32]       {32:1}    1
TTT           Retrieve                    [1]        {32:1}
SSSTN         Push 1                      [1,1]      {32:1}
TSST          Subtract top two (1-1)      [0]        {32:1}
SNS           Duplicate top (0)           [0,0]      {32:1}
NTSN          If 0: Jump to Label_EXIT    [0]        {32:1}
NSSN          Create Label_EXIT           [0]        {32:1}
                                                                                 error

程序因错误而停止：未定义出口。
在线尝试（仅使用空格，制表符和换行符）。
输出单个空格。

输入： 2

Command       Explanation                 Stack      Heap      STDIN    STDOUT   STDERR

SSSTSSSSSN    Push 32                     [32]
SNS           Duplicate top (32)          [32,32]
TNSS          Print as character          [32]                         <space>
SNS           Duplicate top (32)          [32,32]
TNTT          Read STDIN as integer       [32]       {32:2}    2
TTT           Retrieve                    [2]        {32:2}
SSSTN         Push 1                      [2,1]      {32:2}
TSST          Subtract top two (2-1)      [1]        {32:2}
SNS           Duplicate top (1)           [1,1]      {32:2}
NTSN          If 0: Jump to Label_EXIT    [1]        {32:2}
SSSTSSTN      Push 9                      [1,9]      {32:2}
TNSS          Print as character          [1]        {32:2}             \t
SSSTN         Push 1                      [1,1]      {32:2}
TSST          Subtract top two (1-1)      [0]        {32:2}
NTSN          If 0: Jump to Label_EXIT    []         {32:2}
NSSN          Create Label_EXIT           []         {32:2}
                                                                                 error

程序因错误而停止：未定义出口。
在线尝试（仅使用空格，制表符和换行符）。
输出一个空格，后跟一个制表符。

输入：（3或更高）

Command       Explanation                 Stack      Heap      STDIN    STDOUT   STDERR

SSSTSSSSSN    Push 32                     [32]
SNS           Duplicate top (32)          [32,32]
TNSS          Print as character          [32]                          <space>
SNS           Duplicate top (32)          [32,32]
TNTT          Read STDIN as integer       [32]       {32:3}    3
TTT           Retrieve                    [3]        {32:3}
SSSTN         Push 1                      [3,1]      {32:3}
TSST          Subtract top two (3-1)      [2]        {32:3}
SNS           Duplicate top (2)           [2,2]      {32:3}
NTSN          If 0: Jump to Label_EXIT    [2]        {32:3}
SSSTSSTN      Push 9                      [2,9]      {32:3}
TNSS          Print as character          [2]        {32:3}             \t
SSSTN         Push 1                      [2,1]      {32:3}
TSST          Subtract top two (2-1)      [1]        {32:3}
SSSTSTSN      Push 10                     [1,10]     {32:3}
TNSS          Print as character          [1]        {32:3}             \n
NSSN          Create Label_EXIT           []         {32:3}
                                                                                 error

程序因错误而停止：未定义出口。
在线尝试（仅使用空格，制表符和换行符）。
输出一个空格，然后是一个选项卡，然后是一个换行符。

Brain-Flak，118字节

({}<(((((((((((()()()()()){}){}){})())(([][][])){}{}())()())([][][])[]{})()())[][][][][])()())>){({}<({}<>)<>>[()])}<>

在线尝试！

# Push stuffs under the counter
({}<(((((((((((()()()()()){}){}){})())(([][][])){}{}())()())([][][])[]{})()())[][][][][])()())>)

# While True
{
    # Decrement the counter
    ({}<

        # Toggle a character
        ({}<>)<>
    >[()])
}

# Display alternate stack
<>

05AB1E，2个字节

A£

在线尝试！

字母的每个字母都是05AB1E中的命令。

所有这些都是打印N字母表的第一个字母。

> <>，11 10 9字节

1-:n:0=?;

在线尝试！

事实证明，最简单的解决方案是最好的。这将输出从0开始的前n个数字。

旧的10字节解决方案

"'r{$[>o<3

在线尝试！

一些10字节的替代方案：

• "':1+{[>o<
• "r:n[~>o<a
• "'a{[>o<bc

Haskell，22个字节

(`take`"';,=\"@\\`|~")

在线尝试！

感谢@Angs捕获关键字错误。

我觉得可以通过生成字符串而不是显式定义它来缩短它，但是我找不到作为Haskell关键字的10个连续ASCII字符的范围（如果算上语言扩展关键字，我发现其中一些很接近）。如果有一个，您可以将其减少到15个字节，%并以起始字符代替：

(`take`['%'..])

没有符号关键字：

Haskell，58个字节

(`take`words"of in do let then else case data type class")

在线尝试！

C（gcc），62 60字节

-2多亏了GPS

f(n){puts("autocasecharelseenumgotolongvoidint do"+40-4*n);}

在线尝试！

我的意思是...从来没有任何要求将关键字分开。

万一我误读了-或者您对更多问题更感兴趣-这是一个备用版本，其中用空格隔开：

C（gcc），69字节

f(n){puts("auto case char else enum goto long void int  do"+50-5*n);}

在线尝试！

Tcl，37个字节

puts [lrange [info commands] 1 $argv]

在线尝试！

出租车，509字节

"[]a lrnsew" is waiting at Writer's Depot. Go to Post Office: w 1 l 1 r 1 l. Pickup a passenger going to The Babelfishery. Go to The Babelfishery: s 1 l 1 r.Pickup a passenger going to The Underground.Go to Writer's Depot: n 1 l, 1 l, 2 l.Pickup a passenger going to Chop Suey.Go to Chop Suey: n, 3 r, 3 r.[a]Pickup a passenger going to Post Office.Go to Post Office: s 1 r 1 l 2 r 1 l.Go to The Underground: n 1 r 1 l.Pickup a passenger going to The Underground.Go to Chop Suey: n 2 r 1 l.Switch to plan "a".

这将在顶部使用一个硬编码的字符串，并从中打印“ n”个字符，然后显示错误消息“错误：未找到外发乘客”。

该字符串包含：

1. [和]，用于声明计划的字符
2. a 在“接客...”语法中使用。
3. 空格字符，用于分隔语法片段
4. l和r是“向左”和“向右”的缩写，用于告诉驾驶员转弯的方向。
5. n，s，e，和w，四个方向。

我相信所有这些都算作一个字符的关键字。取消高尔夫：

"[]a lrnsew" is waiting at Writer's Depot.
Go to Post Office: west, 1st left, 1st right, 1st left.
Pickup a passenger going to The Babelfishery.
Go to The Babelfishery: south, 1st left, 1st right.
Pickup a passenger going to The Underground.
Go to Writer's Depot: north, 1st left, 1st left, 2nd left.
Pickup a passenger going to Chop Suey.
Go to Chop Suey: north, 3rd right, 3rd right.
[print character]
Pickup a passenger going to Post Office.
Go to Post Office: south, 1st right, 1st left, 2nd right, 1st left.
Go to The Underground: north, 1st right, 1st left.
Pickup a passenger going to The Underground.
Go to Chop Suey: north, 2nd right, 1st left.
Switch to plan "print character".

J，15个字节

[:u:46,"0~65+i.

在线尝试！

将字符串数组提供A.给J.。

J中的虚线词充当内置函数（如a.或A.）或控制结构（如if.或do.），或者只是引发拼写错误。它们都不能用作标识符。

不太有趣，15个字节

{.&'!#$%^*-+=|'

在线尝试！

给出10个一字节动词中的一些。

Bash和Shell utils 20字节

compgen -b|head -$1

您可以将其保存在具有执行权限（内置）的文件中，并在bash下运行，如下所示：

$ ./builtins 5
 .
 : 
 [
 alias 
 bg  

输出前N个bash内置插件。

如果您正在运行除bash以外的其他shell，则在文件开头需要使用shebang＃！/ bin / bash行，且+ 12b

QBasic，60个字节

INPUT n
?LEFT$("CLS FOR DEF RUN DIM PUT GET SUB END IF",n*4)

我相信，这个答案最适合该问题的精神：输出带有字母的保留关键字，并在两者之间留有空格。我不认为符号运算符在QBasic中真的算作“单词”，但是为了完整起见，这里有一个30字节的使用运算符的答案：

INPUT n
?LEFT$("+-*/\^=><?",n)