Para um idioma de computador, uma palavra reservada é uma palavra que não pode ser usada como identificador, como o nome de uma variável, função ou rótulo. Para outros idiomas de computador, as palavras-chave podem ser consideradas como o conjunto de instruções de idioma.

Desafio

Usando o idioma de sua escolha, escreva um código no idioma escolhido, que forneça um número entre um e dez 1<=n<=10, produza quaisquer npalavras reservadas (palavras-chave) do idioma escolhido.

Específicos

• Se o idioma escolhido diferencia maiúsculas de minúsculas, as palavras-chave geradas também devem ser.
• Se o idioma escolhido não diferencia maiúsculas de minúsculas, as palavras-chave geradas podem ser de qualquer forma.
• Se o idioma escolhido tiver menos de 10 palavras-chave dizendo p, o código deverá gerar todas as palavras reservadas para qualquer um nentre pe 10.
• Se possível, especifique na resposta se você considera os operadores como palavras-chave ou não.

Amostras possíveis para Java (JDK10)

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

Amostras possíveis para> <>

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

Amostras possíveis para Brain-Flak

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

Regras

• A entrada e saída podem ser fornecidas em qualquer formato conveniente .
• Não há necessidade de lidar com valores de entrada inválidos , as entradas válidas são: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10.
• Um programa completo ou uma função são aceitáveis. Se uma função, você pode retornar a saída em vez de imprimi-la.
• Se possível, inclua um link para um ambiente de teste on-line para que outras pessoas possam experimentar seu código!
• As brechas padrão são proibidas.
• Isso é código-golfe, portanto todas as regras usuais de golfe se aplicam e o código mais curto (em bytes) vence.

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

Programa completo. Solicita stdin para n(realmente funciona para o intervalo de 0 a 29). As palavras-chave APL são símbolos de caractere único, portanto, imprime nsímbolos no stdout.

⎕↑156↓⎕AV

Experimente online!

⎕AV o vetor atômico (ou seja, o conjunto de caracteres)

156↓ solte os primeiros 156 elementos

⎕↑ solicitar ne levar muitos elementos acima

Python 2 , 25 bytes

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

Uma função sem nome que aceita um número inteiro em [1,10] que retorna uma sequência de operadores binários de byte único.

Experimente online!

Os operadores:

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

Se apenas palavras-chave reais forem permitidas: 40 bytes

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

Uma função sem nome que aceita um número inteiro em [1,10] que retorna uma lista de strings.

Experimente online!

O código deve ser bem direto - ele define uma função que nusa um argumento,, usando o lambda n:...qual retorna a primeira n( ...[:n]) das palavras-chave conhecidas usando as bibliotecas padrão keywords.kwlist(junto com a técnica de golfe padrão de import*).

Java 10, 83 72 bytes (palavras-chave)

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

Experimente online.

Resposta antiga de 83 bytes:

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

Experimente online.

Explicação:

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 palavras-chave disponíveis para Java 8. Java 10 possui a palavra-chave varalém dessas.

Java 8 ou mais, 30 bytes (operadores)

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

Experimente online.

Gelatina , 3 bytes

ØAḣ

Um link monádico que aceita um número inteiro e retorna uma lista de caracteres.

Experimente online!

Os caracteres resultantes são todos átomos monádicos na página de código 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)].

Como?

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

Carvão , 16 bytes

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

Pena que não há uma variável predefinida para sua própria página de código no Charcoal.

Experimente online.

Explicação:

Obtenha uma substring do índice 0 para o número de entrada:

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

A sequência com 10 palavras-chave:

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

Perl 5 -lp , 24 bytes

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

Experimente online!

Fácil de estender para mais e mais palavras-chave, mas você vai precisar fazer caixa especial a partir de 4 letras, porque você vai ter problemas com dump, eval, exit,getc etc ..

É claro que apenas a saída de operadores e sigilos é chata, mas menor em 11 bytes:

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

Experimente online!

(Ignorei, #pois não está claro como devo classificá-lo no contexto deste desafio)

JavaScript (Node.js) , 79 61 bytes

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

Experimente online!

Quão :

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

Se o uso de operadores for permitido (provavelmente será porque são palavras reservadas), então:

JavaScript (Node.js) , 26 25 bytes

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

Experimente online!

Economizou 8 bytes graças a @Adam e mais 1 byte graças a @ l4m2

Quão :

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

Experimente online!

-2 bytes graças a @ benj2240

Pitão , 4 bytes

>QPG

Experimente online!

Infelizmente, muitas das letras são variáveis ​​( 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 (palavras-chave)

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

Experimente online.

Resposta antiga de 76 bytes:

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

Experimente online.

Explicação:

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 palavras-chave disponíveis no C # .NET.

C # .NET, 30 bytes (operadores)

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

Experimente online.

Charme , 52 bytes

Isso gera todas as palavras reservadas no encanto.

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

Como todo código não-recursivo no Charm pode ser incorporado em linha, essa é uma função anônima. Ligue assim:

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

(gera [ := :: ", as únicas quatro palavras reservadas.)

Dar um nome a esta função adiciona 5 bytes:

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

Flak cerebral , 122 120 bytes

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

Experimente online!

Apenas fazendo minha parte para preencher os idiomas de exemplo. Saídas ()[]<>}{, aparecendo na frente para números menores que 8.

Unário , 6072204020736072426436 378380483266268 bytes

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

Obrigado Jo King por 99.999993768646738908474177860631% de redução

Ruby , 50 49 bytes

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

Experimente online!

Não usar nenhum operadores ( +, |, etc.).

Ruby, 71 68 bytes

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

Ok, não é a abordagem mais curta, mas é divertido demais para não postar. Programaticamente encontra todas as seqüências de caracteres de até três letras minúsculas às quais não pode ser atribuído. Acontece exatamente 10:["do", "if", "in", "or", "and", "def", "end", "for", "nil", "not"] .

Editar: salvou 3 bytes graças a Asone Tuhid.

Japt , 3 bytes

Retorna uma string, com cada caractere individual sendo um nome de método em Japt.

;îC

Tente

;Cé o alfabeto em minúsculas e o îrepete até que seu comprimento seja igual à entrada.

Frango , 7 bytes

chicken

Não é uma resposta séria. Mas tem que estar aqui.

R , 76 62 60 57 bytes

12 bytes salvos graças ao MickyT

5 bytes salvos graças ao snoram

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

Experimente online!

Não há muitas palavras reservadas em R, mas essas são as mais curtas de codificar. Existem apenas 9 aqui, mas se uma entrada 10for fornecida, um valor ausente NAserá anexado ao final da lista e impresso.

Python 2 , 64 bytes

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

Experimente online!

Python 2 , 57 bytes (com operadores)

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

Experimente online!

operadores de palavras-chave

Espaço em branco , 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(espaço), T(guia) eN (nova linha) adicionadas apenas como destaque.
[..._some_action]adicionado apenas como explicação.

O espaço em branco contém apenas três 'palavras-chave' válidas: espaços, guias e novas linhas.

Explicação em pseudo-có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

Exemplo é executado:

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

O programa para com um erro: Nenhuma saída definida.
Experimente online (apenas com espaços brutos, guias e novas linhas).
Produz um único espaço.

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

O programa para com um erro: Nenhuma saída definida.
Experimente online (apenas com espaços brutos, guias e novas linhas).
Gera um espaço, seguido por uma guia.

Entrada: 3(ou 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

O programa para com um erro: Nenhuma saída definida.
Experimente online (apenas com espaços brutos, guias e novas linhas).
Gera um espaço, seguido por uma guia, seguida por uma nova linha.

Flacidez Cerebral , 118 bytes

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

Experimente online!

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

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

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

# Display alternate stack
<>

05AB1E , 2 bytes

A£

Experimente online!

Cada letra do alfabeto é um comando em 05AB1E.

Tudo o que isso faz é imprimir as primeiras Nletras do alfabeto.

> <> , 11 10 9 bytes

1-:n:0=?;

Experimente online!

Acabou que a solução mais simples foi a melhor. Isso gera os primeiros n números, começando em 0.

Soluções antigas de 10 bytes

"'r{$[>o<3

Experimente online!

Algumas alternativas de 10 bytes:

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

Haskell , 22 bytes

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

Experimente online!

Agradecemos ao @Angs por detectar erros de palavras-chave.

Eu senti que isso poderia ser mais curto gerando a string em vez de defini-la explicitamente, mas não consegui encontrar um intervalo de 10 caracteres ASCII consecutivos que sejam palavras-chave Haskell (eu encontrei alguns que são próximos, se você contar palavras-chave de extensão de idioma). Se houver um, você poderá reduzi-lo para 15 bytes por isso, substituindo %pelo caractere inicial:

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

Sem palavras-chave simbólicas:

Haskell , 58 bytes

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

Experimente online!

C (gcc) , 62 60 bytes

-2 graças ao GPS

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

Experimente online!

Quero dizer ... nunca houve nenhum requisito para realmente separar as palavras-chave.

Caso eu interprete mal - ou você esteja mais interessado em algo mais no espírito da pergunta - aqui está uma versão alternativa com espaços separados:

C (gcc) , 69 bytes

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

Experimente online!

Tcl , 37 bytes

puts [lrange [info commands] 1 $argv]

Experimente online!

Táxi, 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".

Isso pega uma string codificada no topo e imprime caracteres "n" e, em seguida, erros com "error: nenhum passageiro de saída encontrado".

A cadeia contém:

1. [e ], os caracteres usados ​​para declarar um plano
2. a usado na sintaxe "Receber um passageiro ...".
3. O caractere de espaço, necessário para separar partes da sintaxe
4. le r, abreviação de "left" e "right", costumava dizer ao motorista para que lado virar.
5. n, s, e, E w, as quatro direções.

Acredito que tudo isso conta como palavras-chave de um caractere. Ungolfed:

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

Experimente online!

Dá uma matriz de seqüências de caracteres A.para J..

Palavras pontilhadas em J atuam como built-ins (como a.ou A.) ou estruturas de controle (como if.ou do.), ou simplesmente lançam um erro de ortografia. Nenhum deles pode ser usado como identificador.

Menos interessante, 15 bytes

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

Experimente online!

Dá alguns dos 10 verbos de um byte.

Utilitários Bash e Shell 20 bytes

compgen -b|head -$1

Você pode salvar isso em um arquivo com permissões de execução (builtins) e executá-lo no bash assim:

$ ./builtins 5
 .
 : 
 [
 alias 
 bg  

Produz o primeiro N bash embutido.

Se você estiver executando algum shell que não seja o bash, precisará da linha shebang #! / Bin / bash no início do arquivo, para + 12b

QBasic, 60 bytes

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

Esta resposta se encaixa melhor no espírito da pergunta: gerar palavras-chave reservadas alfabéticas com espaços entre elas. Eu não acho que operadores simbólicos realmente contam como "palavras" no QBasic, mas, para completar, aqui está uma resposta de 30 bytes usando operadores:

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