Per un linguaggio informatico, una parola riservata è una parola che non può essere utilizzata come identificatore, ad esempio il nome di una variabile, funzione o etichetta. Per altri linguaggi informatici, le parole chiave possono essere considerate come l'insieme delle istruzioni linguistiche.

Sfida

Usando la lingua che preferisci, scrivi un codice nella lingua prescelta che fornisca un numero compreso tra uno e dieci e 1<=n<=10produca tutte le nparole riservate (parole chiave) della lingua scelta.

specifiche

• Se la lingua scelta fa distinzione tra maiuscole e minuscole, devono essere presenti anche le parole chiave emesse.
• Se la lingua scelta non fa distinzione tra maiuscole e minuscole, le parole chiave prodotte possono essere comunque.
• Se la lingua scelta contiene meno di 10 parole chiave p, il codice deve generare tutte le parole riservate per qualsiasi ntra pe 10.
• Se possibile, specificare nella risposta se considerare gli operatori come parole chiave o meno.

Possibili campioni per Java (JDK10)

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

Possibili campioni per> <>

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

Possibili campioni per Brain-Flak

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

Regole

• L'input e l'output possono essere forniti in qualsiasi formato conveniente .
• Non è necessario gestire valori di input non validi, gli input validi sono: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10.
• È accettabile un programma completo o una funzione. Se una funzione, è possibile restituire l'output anziché stamparlo.
• Se possibile, si prega di includere un collegamento a un ambiente di test online in modo che altre persone possano provare il tuo codice!
• Sono vietate le scappatoie standard .
• Si tratta di code-golf, quindi si applicano tutte le normali regole del golf e vince il codice più breve (in byte).

APL (Dyalog Unicode) , ^{SBCS da} 9 byte

Programma completo. Richiede stdin per n(in realtà funziona per l'intervallo 0–29). Le parole chiave APL sono simboli a carattere singolo, quindi vengono stampati nsimboli su stdout.

⎕↑156↓⎕AV

Provalo online!

⎕AV Atomic Vector (ovvero il set di caratteri)

156↓ rilascia i primi 156 elementi

⎕↑ richiedere ne prendere molti elementi di cui sopra

Python 2 , 25 byte

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

Una funzione senza nome che accetta un numero intero in [1,10] che restituisce una stringa di operatori binari a byte singolo.

Provalo online!

Gli operatori:

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

Se sono consentite solo parole chiave effettive: 40 byte

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

Una funzione senza nome che accetta un numero intero in [1,10] che restituisce un elenco di stringhe.

Provalo online!

Il codice dovrebbe essere piuttosto semplice: definisce una funzione che prende un argomento, nusando lambda n:...quale restituisce la prima n( ...[:n]) delle parole chiave conosciute usando la libreria standard keywords.kwlist(insieme alla tecnica di golf standard di import*).

Java 10, 83 72 byte (parole chiave)

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

Provalo online.

Risposta di 83 byte vecchi:

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

Provalo online.

Spiegazione:

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

Elenco delle parole chiave disponibili per Java 8. Java 10 ha la parola chiave varin aggiunta a queste.

Java 8+, 30 byte (operatori)

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

Provalo online.

Gelatina , 3 byte

ØAḣ

Un collegamento monadico che accetta un numero intero e restituisce un elenco di caratteri.

Provalo online!

I personaggi risultanti sono tutti atomi monadici nella tabella codici di 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)].

Come?

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

Carbone , 16 byte

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

Peccato che non ci sia una variabile preimpostata per la propria tabella codici in Carbone.

Provalo online.

Spiegazione:

Ottieni una sottostringa dall'indice 0 al numero di input:

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

La stringa con 10 parole chiave:

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

Perl 5 -lp , 24 byte

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

Provalo online!

Facile da estendere a più e più a lungo le parole chiave, ma sarà necessario fare cassa speciale a partire da 4 lettere perché si incorrere in problemi con dump, eval, exit, getcecc ..

Ovviamente il solo output di operatori e sigilli è noioso ma più breve a 11 byte:

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

Provalo online!

(Ho saltato #poiché non è chiaro come dovrei classificarlo nel contesto di questa sfida)

JavaScript (Node.js) , 79 61 byte

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

Provalo online!

Come :

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 è consentito l'uso di operatori (molto probabilmente lo sarà poiché sono parole riservate), allora:

JavaScript (Node.js) , 26 25 byte

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

Provalo online!

Risparmiato 8 byte grazie a @Adam e 1 byte in più grazie a @ l4m2

Come :

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.

Rubino , 22 byte

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

Provalo online!

-2 byte grazie a @ benj2240

Pyth , 4 byte

>QPG

Provalo online!

Sfortunatamente, molte delle lettere sono variabili ( 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 byte (parole chiave)

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

Provalo online.

Risposta di vecchi 76 byte:

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

Provalo online.

Spiegazione:

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

Elenco delle parole chiave disponibili in C # .NET.

C # .NET, 30 byte (operatori)

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

Provalo online.

Fascino , 52 byte

Ciò genera tutte le parole riservate in Charm.

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

Poiché tutto il codice non ricorsivo in Charm è inline-capace, questa è una funzione anonima. Chiama in questo modo:

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

(genera [ := :: ", le uniche quattro parole riservate.)

Dando un nome a questa funzione si aggiungono 5 byte:

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

Brain-Flak , 122 120 byte

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

Provalo online!

Sto solo facendo la mia parte per compilare le lingue di esempio. Uscite ()[]<>}{, saltando fuori dalla parte anteriore per numeri inferiori a 8.

Unario , 6072204020736072426436 378380483266268 byte

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

Grazie a Jo King per la riduzione del 99,999993768646738908474177860631%

Rubino , 50 49 byte

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

Provalo online!

Non usando qualsiasi operatore ( +, |, ecc).

Rubino, 71 68 byte

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

Va bene, non l'approccio più breve, ma troppo divertente per non pubblicare. Trova a livello di codice tutte le stringhe di massimo tre lettere minuscole a cui non è possibile assegnare. Ci capita di essere esattamente 10: ["do", "if", "in", "or", "and", "def", "end", "for", "nil", "not"].

Modifica: salvato 3 byte grazie ad Asone Tuhid.

Japt , 3 byte

Restituisce una stringa, con ogni singolo carattere come nome del metodo in Japt.

;îC

Provalo

;Cè l'alfabeto minuscolo e lo îripete fino a quando la sua lunghezza è uguale all'input.

Pollo , 7 byte

chicken

Non è una risposta seria. Ma deve essere qui.

R , 76 62 60 57 byte

12 byte salvati grazie a MickyT

5 byte salvati grazie a snoram

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

Provalo online!

Non ci sono molte parole riservate in R ma queste sono tra le più brevi da codificare. Ci sono solo 9 qui, ma se 10viene fornito un input di , un valore mancante NAviene aggiunto alla fine dell'elenco e stampato.

Python 2 , 64 byte

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

Provalo online!

Python 2 , 57 byte (con operatori)

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

Provalo online!

operatori di parole chiave

Spazio bianco , 84 byte

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

Lettere S(spazio), T(scheda) e N(nuova riga) aggiunti solo come evidenziazione.
[..._some_action]aggiunto solo come spiegazione.

Lo spazio bianco contiene solo tre "parole chiave" valide: spazi, schede e nuove righe.

Spiegazione in pseudo-codice:

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

Esempi di esecuzione:

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

Il programma si interrompe con un errore: nessuna uscita definita.
Provalo online (solo con spazi non elaborati, schede e nuove righe).
Emette un singolo spazio.

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

Il programma si interrompe con un errore: nessuna uscita definita.
Provalo online (solo con spazi non elaborati, schede e nuove righe).
Emette uno spazio, seguito da una scheda.

Input: 3(o superiore)

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

Il programma si interrompe con un errore: nessuna uscita definita.
Provalo online (solo con spazi non elaborati, schede e nuove righe).
Emette uno spazio, seguito da una scheda, seguita da una nuova riga.

Brain-Flak , 118 byte

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

Provalo online!

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

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

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

# Display alternate stack
<>

05AB1E , 2 byte

A£

Provalo online!

Ogni lettera dell'alfabeto è un comando in 05AB1E.

Tutto ciò che fa è stampare le prime Nlettere dell'alfabeto.

> <> , 11 10 9 byte

1-:n:0=?;

Provalo online!

Si è scoperto che la soluzione più semplice era la migliore. Questo genera i primi n numeri, a partire da 0.

Vecchie soluzioni da 10 byte

"'r{$[>o<3

Provalo online!

Alcune alternative a 10 byte:

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

Haskell , 22 byte

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

Provalo online!

Grazie a @Angs per la rilevazione degli errori delle parole chiave.

Ho pensato che questo potesse essere più breve generando la stringa invece di definirla esplicitamente, ma non sono riuscito a trovare un intervallo di 10 caratteri ASCII consecutivi che sono parole chiave di Haskell (ne ho trovati alcuni vicini, se si contano le parole chiave con estensione di lingua). Se ce n'è uno, potresti ridurlo a 15 byte con questo, sostituendolo %con il carattere iniziale:

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

Senza parole chiave simboliche:

Haskell , 58 byte

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

Provalo online!

C (gcc) , 62 60 byte

-2 grazie al GPS

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

Provalo online!

Voglio dire ... non c'è mai stato alcun requisito per separare effettivamente le parole chiave.

Nel caso in cui ho letto male - o sei più interessato a qualcosa di più nello spirito della domanda - ecco una versione alternativa con spazi separati:

C (gcc) , 69 byte

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

Provalo online!

Tcl , 37 byte

puts [lrange [info commands] 1 $argv]

Provalo online!

Taxi, 509 byte

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

Questo prende una stringa codificata nella parte superiore, e stampa i caratteri "n" da essa, quindi errori con "errore: nessun passeggero in uscita trovato".

La stringa contiene:

1. [e ], i personaggi usati per dichiarare un piano
2. a utilizzato nella sintassi "Pickup a passenger ...".
3. Il carattere spazio, necessario per separare i pezzi di sintassi
4. le r, abbreviazione di "sinistra" e "destra", usato per dire al conducente quale modo di girare.
5. n, s, e, E w, le quattro direzioni.

Credo che tutti contino come parole chiave a carattere singolo. 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 byte

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

Provalo online!

Fornisce una serie di stringhe A.a J..

Le parole tratteggiate in J fungono da built-in (come a.o A.) o strutture di controllo (come if.o do.), o semplicemente generano errori di ortografia. Nessuno di essi può essere utilizzato come identificatore.

Meno interessante, 15 byte

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

Provalo online!

Fornisce alcuni dei 10 verbi a un byte.

Bash e shell utilizzano 20 byte

compgen -b|head -$1

Puoi salvarlo in un file con permessi di esecuzione (builtin) ed eseguirlo sotto bash in questo modo:

$ ./builtins 5
 .
 : 
 [
 alias 
 bg  

Emette i primi ins incorporati N bash.

Se stai eseguendo una shell diversa da bash, avrai bisogno della riga shebang #! / Bin / bash all'inizio del file, per + 12b

QBasic, 60 byte

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

Questa risposta si adatta meglio allo spirito della domanda, credo: produrre parole chiave alfabetiche riservate con spazi nel mezzo. Non penso che gli operatori simbolici contino davvero come "parole" in QBasic, ma per completezza, ecco una risposta di 30 byte usando gli operatori:

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