Para un lenguaje de computadora, una palabra reservada es una palabra que no se puede usar como un identificador, como el nombre de una variable, función o etiqueta. Para otros idiomas de computadora, las palabras clave se pueden considerar como el conjunto de instrucciones de idioma.

Desafío

Usando el idioma de su elección, escriba un código en el idioma elegido que, dado un número entre uno y diez 1<=n<=10, emite las npalabras reservadas (palabras clave) del idioma elegido.

Detalles específicos

• Si el idioma elegido distingue entre mayúsculas y minúsculas, las palabras clave de salida también deben serlo.
• Si el idioma elegido no distingue entre mayúsculas y minúsculas, las palabras clave generadas pueden serlo en cualquier caso.
• Si el idioma elegido tiene menos de 10 palabras clave que dicen p, el código debe generar todas las palabras reservadas para cualquier nentre py 10.
• Si es posible, especifique en la respuesta si considera a los operadores como palabras clave o no.

Posibles muestras para Java (JDK10)

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

Posibles muestras para> <>

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

Posibles muestras para Brain-Flak

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

Reglas

• La entrada y la salida se pueden dar en cualquier formato conveniente .
• No es necesario manejar valores de entrada inválidos , las entradas válidas son: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10.
• Un programa completo o una función son aceptables. Si es una función, puede devolver el resultado en lugar de imprimirlo.
• Si es posible, incluya un enlace a un entorno de prueba en línea para que otras personas puedan probar su código.
• Las lagunas estándar están prohibidas.
• Este es el código de golf, por lo que se aplican todas las reglas habituales de golf, y gana el código más corto (en bytes).

APL (Dyalog Unicode) , ^{SBCS de} 9 bytes

Programa completo Solicita stdin para n(en realidad funciona para el rango 0–29). Las palabras clave APL son símbolos de un solo carácter, por lo que imprime nsímbolos en stdout.

⎕↑156↓⎕AV

Pruébalo en línea!

⎕AV el vector atómico (es decir, el conjunto de caracteres)

156↓ soltar los primeros 156 elementos

⎕↑ solicitar ny tomar tantos elementos de lo anterior

Python 2 , 25 bytes

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

Una función sin nombre que acepta un número entero en [1,10] que devuelve una cadena de operadores binarios de un solo byte.

Pruébalo en línea!

Los operadores:

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

Si solo se permiten palabras clave reales: 40 bytes

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

Una función sin nombre que acepta un número entero en [1,10] que devuelve una lista de cadenas.

Pruébalo en línea!

El código debe ser bastante sencillo: define una función que toma un argumento, ny utiliza la lambda n:...que devuelve la primera n( ...[:n]) de las palabras clave conocidas utilizando la biblioteca estándar keywords.kwlist(junto con la técnica de golf estándar de import*).

Java 10, 83 72 bytes (palabras clave)

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

Pruébalo en línea.

Antigua respuesta de 83 bytes:

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

Pruébalo en línea.

Explicació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

Lista de palabras clave disponibles para Java 8. Java 10 tiene la palabra clave varademás de estas.

Java 8+, 30 bytes (operadores)

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

Pruébalo en línea.

Jalea , 3 bytes

ØAḣ

Un enlace monádico que acepta un número entero y devuelve una lista de caracteres.

Pruébalo en línea!

Los caracteres resultantes son todos átomos monádicos en la página de códigos de 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)].

¿Cómo?

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

Carbón , 16 bytes

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

Lástima que no haya una variable preestablecida para su propia página de códigos en Charcoal.

Pruébalo en línea.

Explicación:

Obtenga una subcadena del índice 0 al número de entrada:

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

La cadena con 10 palabras clave:

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

Perl 5 -lp , 24 bytes

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

Pruébalo en línea!

Fácil de ampliar a más y más largas palabras clave, pero se necesita hacer carcasa especial a partir de las 4 letras debido a que se ejecutará en problemas con dump, eval, exit, getcetc ..

Por supuesto, la salida de operadores y sigilos es aburrida pero más corta en 11 bytes:

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

Pruébalo en línea!

(Me salté, #ya que no está claro cómo debo clasificarlo en el contexto de este desafío)

JavaScript (Node.js) , 79 61 bytes

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

Pruébalo en línea!

Cómo :

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

Si se permite el uso de operadores (lo más probable es que sean palabras reservadas), entonces:

JavaScript (Node.js) , 26 25 bytes

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

Pruébalo en línea!

Ahorró 8 bytes gracias a @Adam y 1 byte más gracias a @ l4m2

Cómo :

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.

Ruby , 22 bytes

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

Pruébalo en línea!

-2 bytes gracias a @ benj2240

Pyth , 4 bytes

>QPG

Pruébalo en línea!

Desafortunadamente, muchas de las letras son variables ( 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 bytes (palabras clave)

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

Pruébalo en línea.

Antigua respuesta de 76 bytes:

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

Pruébalo en línea.

Explicació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

Lista de palabras clave disponibles en C # .NET.

C # .NET, 30 bytes (operadores)

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

Pruébalo en línea.

Encanto , 52 bytes

Esto genera todas las palabras reservadas en Charm.

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

Dado que todo el código no recursivo en Charm es en línea, esta es una función anónima. Llame así:

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

(salidas [ := :: ", las únicas cuatro palabras reservadas).

Darle un nombre a esta función agrega 5 bytes:

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

Brain-Flak , 122 120 bytes

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

Pruébalo en línea!

Solo estoy haciendo mi parte para completar los idiomas de ejemplo. Salidas ()[]<>}{, que salen del frente para números menores que 8.

Unario , 6072204020736072426436 378380483266268 bytes

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

Gracias, Jo King por 99.999993768646738908474177860631% reductor

Ruby , 50 49 bytes

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

Pruébalo en línea!

No usar cualquier operador ( +, |, etc.).

Ruby, 71 68 bytes

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

De acuerdo, no es el enfoque más corto, pero es demasiado divertido para no publicar. Programáticamente encuentra todas las cadenas de hasta tres letras minúsculas que no se pueden asignar. Sucede que hay exactamente 10: ["do", "if", "in", "or", "and", "def", "end", "for", "nil", "not"].

Editar: Guardado 3 bytes gracias a Asone Tuhid.

Japt , 3 bytes

Devuelve una cadena, con cada carácter individual como un nombre de método en Japt.

;îC

Intentalo

;Ces el alfabeto en minúsculas y lo îrepite hasta que su longitud sea igual a la entrada.

Pollo , 7 bytes

chicken

No es una respuesta seria. Pero tiene que estar aquí.

R , 76 62 60 57 bytes

12 bytes guardados gracias a MickyT

5 bytes guardados gracias a snoram

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

Pruébalo en línea!

No hay muchas palabras reservadas en R, pero estas se encuentran entre las más cortas para codificar. Aquí solo hay 9, pero si se proporciona una entrada de 10, NAse agrega un valor faltante al final de la lista y se imprime.

Python 2 , 64 bytes

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

Pruébalo en línea!

Python 2 , 57 bytes (con operadores)

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

Pruébalo en línea!

operadores de palabras clave

Espacio en blanco , 84 bytes

[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]

Letras S(espacio), T(tabulación) yN agregaron (nueva línea) solo como resaltado.
[..._some_action]agregado solo como explicación.

El espacio en blanco solo contiene tres 'palabras clave' válidas: espacios, pestañas y nuevas líneas.

Explicación en pseudocódigo:

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

Ejecuciones de ejemplo:

Entrada: 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

El programa se detiene con un error: no hay salida definida.
Pruébelo en línea (solo con espacios en bruto, pestañas y nuevas líneas).
Emite un solo espacio.

Entrada: 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

El programa se detiene con un error: no hay salida definida.
Pruébelo en línea (solo con espacios en bruto, pestañas y nuevas líneas).
Emite un espacio, seguido de una pestaña.

Entrada: 3(o superior)

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

El programa se detiene con un error: no hay salida definida.
Pruébelo en línea (solo con espacios en bruto, pestañas y nuevas líneas).
Emite un espacio, seguido de una pestaña, seguido de una nueva línea.

Brain-Flak , 118 bytes

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

Pruébalo en línea!

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

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

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

# Display alternate stack
<>

05AB1E , 2 bytes

A£

Pruébalo en línea!

Cada letra del alfabeto es un comando en 05AB1E.

Todo lo que hace es imprimir las primeras Nletras del alfabeto.

> <> , 11 10 9 bytes

1-:n:0=?;

Pruébalo en línea!

Resultó que la solución más simple era la mejor. Esto genera los primeros n números, comenzando desde 0.

Soluciones antiguas de 10 bytes

"'r{$[>o<3

Pruébalo en línea!

Algunas alternativas de 10 bytes:

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

Haskell , 22 bytes

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

Pruébalo en línea!

Gracias a @Angs por detectar errores de palabras clave.

Sentí que esto podría ser más corto al generar la cadena en lugar de definirla explícitamente, pero no pude encontrar un rango de 10 caracteres ASCII consecutivos que son palabras clave de Haskell (encontré algunos que están cerca, si cuenta palabras clave de extensión de idioma). Si hay uno, puede reducirlo a 15 bytes con esto, reemplazando %con el carácter inicial:

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

Sin palabras clave simbólicas:

Haskell , 58 bytes

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

Pruébalo en línea!

C (gcc) , 62 60 bytes

-2 gracias a GPS

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

Pruébalo en línea!

Quiero decir ... nunca hubo ningún requisito para separar realmente las palabras clave.

En caso de que haya leído mal, o si está más interesado en algo más en el espíritu de la pregunta, aquí hay una versión alternativa con espacios de separación:

C (gcc) , 69 bytes

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

Pruébalo en línea!

Tcl , 37 bytes

puts [lrange [info commands] 1 $argv]

Pruébalo en línea!

Taxi, 509 bytes

"[]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".

Esto toma una cadena codificada en la parte superior e imprime "n" caracteres de ella, y luego errores con "error: no se encontraron pasajeros salientes".

La cadena contiene:

1. [y ], los personajes utilizados para declarar un plan
2. a utilizado en la sintaxis "Recoger a un pasajero ...".
3. El carácter de espacio, que se requiere para separar piezas de sintaxis.
4. ly r, abreviatura de "izquierda" y "derecha", solía decirle al conductor qué camino tomar.
5. n, s, e, Y w, las cuatro direcciones.

Creo que todos ellos cuentan como palabras clave de un carácter. Sin golf:

"[]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 bytes

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

Pruébalo en línea!

Da una variedad de cadenas A.a J..

Las palabras punteadas en J actúan como elementos integrados (como a.o A.) o estructuras de control (como if.o do.), o simplemente arrojan errores ortográficos. Ninguno de ellos puede usarse como identificadores.

Menos interesante, 15 bytes

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

Pruébalo en línea!

Da algunos de los 10 verbos de un byte.

Bash y shell utilidades 20 bytes

compgen -b|head -$1

Puede guardar eso en un archivo con permisos de ejecución (incorporados) y ejecutarlo en bash de esta manera:

$ ./builtins 5
 .
 : 
 [
 alias 
 bg  

Emite los primeros N bash built ins.

Si está ejecutando algún shell que no sea bash, necesitará la línea shebang #! / Bin / bash al comienzo del archivo, para + 12b

QBasic, 60 bytes

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

Creo que esta respuesta se ajusta mejor al espíritu de la pregunta: generar palabras clave reservadas alfabéticas con espacios intermedios. No creo que los operadores simbólicos realmente cuenten como "palabras" en QBasic, pero para completar, aquí hay una respuesta de 30 bytes usando operadores:

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