Este es un teclado QWERTY.

Q W E R T Y U I O P
 A S D F G H J K L
  Z X C V B N M

Podemos "salir en espiral" en este teclado, comenzando desde G. La espiral comenzará en G, irá a H, luego a Y, luego a T, luego F, luego V, luego B, luego N, luego J, luego U , luego R, luego D, luego C, ... etc. Su desafío es, dado un número 1 ≤ N ≤ 26, generar los primeros N caracteres en esta espiral. (Si está confundido, consulte las imágenes al final de la publicación).

¿La captura? ¡La puntuación de su programa es proporcional a los índices de caracteres encontrados dentro de la espiral!

Tanteo

1. Para cada letra (sin distinción entre mayúsculas y minúsculas) en su código, agregue el índice de ese carácter en la espiral a su puntaje (a partir de 1).
2. Por cada personaje que no esté en la espiral, agrega 10 a tu puntaje.
3. El puntaje más bajo gana.

Por ejemplo, el programa print("Hello, World!")tiene una puntuación de 300.

Para su conveniencia, he escrito un calificador automático del programa.

var SPIRAL = "GHYTFVBNJURDCMKIESXLOWAZPQ";
function grade(program) {
    var score = 0;
    for(var i = 0; i < program.length; i++) {
        if(/^[A-Za-z]$/.test(program[i])) {
            score += SPIRAL.indexOf(program[i].toUpperCase()) + 1;
        }
        else {
            score += 10;
        }
    }
    return score;
}

input.oninput = function() {
    output.value = "Your program's score is: " + grade(input.value);
}

textarea { width: 500px; height: 6em; font-style: monospace; }

<textarea id="input"></textarea>
<textarea disabled id="output"></textarea>

Otras reglas

• Su envío puede ser un programa o función.
• Puedes tomar N comenzando en 0 o 1 y terminando en 25 o 26, respectivamente, pero las salidas deben comenzar con "G" y terminar con "GHYTFVBNJURDCMKIESXLOWAZPQ".
• Debe mostrar los caracteres en la espiral en orden .
• Si es una función, puede devolver una lista de caracteres en lugar de una cadena.
• Es posible que tenga una nueva línea al final de la salida.
• Puede usar letras minúsculas en lugar de letras mayúsculas, o una combinación de ambas.

Casos de prueba

number -> output
1 -> G
2 -> GH
5 -> GHYTF
12 -> GHYTFVBNJURD
15 -> GHYTFVBNJURDCMK
24 -> GHYTFVBNJURDCMKIESXLOWAZ
26 -> GHYTFVBNJURDCMKIESXLOWAZPQ

Imágenes

La espiral superpuesta:

Japt , 304 264 162 puntos

Ahorró 40 puntos gracias a @ ConorO'Brien

;î"历锋㫿鮹㿬崴ꨜꎋΞ"csG

¡Pruébalo en línea!

Para guardar tantos puntos como sea posible, toda la cadena se condensa en 9 caracteres Unicode interpretando cada serie de 3 letras como un número base 36, y luego convirtiéndolas en un punto de código. El programa en sí toma esta cadena comprimida (que cuesta 110 puntos, incluidas las comillas) y asigna cada charcode convirtiéndolo en un string en base-36 ( Gdespués ;del principio). îtoma los primeros {input} caracteres de esto, que se imprime implícitamente.

C, puntuación: 544

g(g){write(1,"GHYTFVBNJURDCMKIESXLOWAZPQ",g);}

Pruébalo en línea!

Espiral , puntaje:  61921   5127   4715   4655  4191

4.X~>v+^#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v
   X *   X X X X X X X X X X X X X X X X X X X X X X X X X
   ! >   h y t f V b n j u [ ( 1 3 2 ) ] U J N B F T Y H G
0;vgv*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*vvv****v+^v+^v+^v+^*v++4
    X X X X X X X X X X X X X X X X X X X X X X X X X X
    v v v v v v v v v v v v v v v v v v v v v v v v v v
    Y y J F V u t U [ G H B n 3 N 2 j ) h g f ] ( 1 b T

Se puede encontrar un intérprete aquí .

Explicación:

P.X~ZZ*v+^#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v
   X       X X X X X X X X X X X X X X X X X X X X X X X X X
   !       h y t f V b n j u r d c m k i e s x l o w a z p q
0;vgv*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*v*****************************************************************vP
    X X X X X X X X X X X X X X X X X X X X X X X X X X
    v v v v v v v v v v v v v v v v v v v v v v v v v v
    z y x w V u t s r q p o n m l k j i h g f e d c b a

El programa comienza en el 0personaje en la cuarta línea. El primer fragmento de código que se ejecuta es 0;vg. ;toma un número como entrada y lo coloca en la pila. vcoloca lo que está en el registro (un cero) en la pila. Será usado como el contador.ges una etiqueta, cuando se alcanza, el control salta a la otra aparición de la letra gen el código.

Entonces aquí es donde está el control ahora:

X
v
g

Como hay espacios en blanco en todas las demás direcciones, el puntero de instrucción comienza a moverse hacia arriba. vcoloca un cero en la pila yX saca de la pila inmediatamente. Como el valor emergente es cero, el puntero de instrucción se mueve a X(de lo contrario, lo trataría como un espacio en blanco).

Por defecto, el flujo de control está en modo de giro a la derecha, por lo que ahora, cuando llega a la unión, el puntero de instrucciones gira a la derecha. vuna vez más empuja un cero en la pila, *incrementa el registro en uno.

v*v*v
  X
  v
  g

Lo siguiente vcoloca lo que está en el registro (número 1) en la pila, el puntero de instrucción intenta girar a la derecha, presionando el siguiente X. El valor que se acaba de agregar a la pila aparece y se coloca en el registro. Debido a que no es cero, Xno se ingresa y la IP pasa a la siguiente *a la derecha, incrementando nuevamente el valor en el registro.

v*v*v*v*v
X X X X X
v v v v v
i h g f e

Esto sucede una y otra vez hasta que lleguemos al final de esta parte y *comience la línea de s. Por ahora el valor en el registro es 6, que es la letra gASCII menos la letra ASCII a. Por lo tanto, con una línea de 97 *s incrementamos el valor en el registro a 103, que coincide con la letra gque queremos imprimir. vlo empuja a la pila yP es otra etiqueta al golpear que saltamos a la otraP en la primera línea del código.

Aquí .aparece el valor de la pila y lo imprime como un personaje. Después de eso, se Xsaca el cero extraño de la pila, luego se ~comparan los dos valores restantes en la pila (los valores son el contador y el valor de entrada). Si los valores son los mismos, el operador coloca cero en la pila (de lo contrario -1 o 1). Nuevamente, el control intenta girar a la derecha. Xmuestra el valor de la comparación de la pila, si es cero X, y después de !ingresarlo, finaliza el programa.

P.X~ZZ*v+^
   X
   !

De lo contrario, la IP continúa hasta el Z, que es una etiqueta que en este caso salta solo un paso hacia la derecha. La razón para hacerlo es que saltar vuelve a poner el valor en el registro a cero. *incrementa el registro y vcoloca el 1 resultante en la pila. +muestra los dos elementos superiores de la pila (el 1 y el contador), los agrega y coloca el resultado en la pila (en efecto, esto incrementa el contador en uno).^copia el resultado de la pila al registro sin eliminarlo de la pila.

#disminuye el valor en el registro en uno, vempuja el valor disminuido a la pila, la IP intenta girar a la derecha y Xsaca el valor de la pila. Si el valor no es cero, la IP continúa moviéndose hacia el este, disminuyendo el valor en el registro, hasta que llega a cero, y la IP ingresa a una Xrama.

#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v
 X X X X X X X X X X X X X X X X X X X X X X X X X
 h y t f V b n j u r d c m k i e s x l o w a z p q

La rama lleva a una etiqueta correspondiente al valor del contador. Al golpear la etiqueta, el control salta a la otra aparición de la etiqueta en la sección donde comenzamos con la etiquetag , comenzando otra iteración. Al igual que con el g, el valor en el registro se incrementa hasta el valor ASCII de la letra que necesitamos imprimir. Luego se imprime el carácter y se incrementa el contador, se selecciona otra etiqueta. Esto sucede hasta después de la última iteración, el contador es igual a la entrada y el programa termina.

Editar:

P.X~Zv+^
   X *
   ! Z

Logra lo mismo que

P.X~ZZ*v+^
   X
   !

pero con menos espacio en blanco.

Edición 2:

vv****v+^v+^v+^v+^*v++P

Se puede usar en lugar de:

*****************************************************************vP

Haskell , 471

(`take`"GHYTFVBNJURDCMKIESXLOWAZPQ")

Pruébalo en línea!

Este es un punto de referencia, creo que debe haber una mejor manera, pero es lo mejor que he encontrado hasta ahora.

Explicación

Supongo que debería explicar esto para aquellos que no están familiarizados con Haskell demasiado bien. La función taketoma los primeros n elementos de la lista. Se llama así:

take n list

Queremos tomar los primeros n elementos de la picadura "GHYTFVBNJURDCMKIESXLOWAZPQ", por lo que queremos algo como

f n=take n"GHYTFVBNJURDCMKIESXLOWAZPQ"

Sin embargo, podemos hacerlo mejor, podemos infijar takeusando backticks

f n=n`take`"GHYTFVBNJURDCMKIESXLOWAZPQ"

Y ahora esto puede hacerse sin problemas

(`take`"GHYTFVBNJURDCMKIESXLOWAZPQ")

Jelly , puntaje 211

19 bytes

“eȷÞ('¢ạẓkȮV’œ?ØAðḣ

Pruébalo en línea!

ahorró un montón de puntaje gracias a la sugerencia de Emigna de usar œ?: D

Vim , 461 418

CGHYTFVBNJURDCMKIESXLOWAZPQg^[G@" D

Gracias @pacholik por -43 puntaje!

Pruébalo en línea!

Befunge, Puntuación: 531

QPZAWOLXSEIKMCDRUJNBVFTYHG"&\>,# 1#\-# :# _@

Siento que este desafío habría sido más interesante si la salida tuviera que estar en espiral también.

TI-Basic (TI-84 Plus CE), 454 432 puntos

sub("GHYTFVBNJURDCMKIESXLOWAZPQ",1,Ans

-22 puntos de Conor O'Brien

Corre con 5:prgmNAME.

Devuelve / imprime la subcadena de1 a Ans(la entrada del número).

TI-Basic es un lenguaje tokenizado , así que lo califico por los valores de bytes de los tokens.

sub( es 0xbb 0x0c, entonces 20

" es 0x2a, entonces * 10 * 2 = 20

Las letras mayúsculas no cambian, por lo que la cadena es 351

, es 0x2b, entonces + 10 * 2 = 20

1 es 0x31, entonces 1 , entonces 10

Ans es 0x72, que es r , entonces 11

20 + 20 + 351 + 20 + 10 + 11 = 432

Python 3, puntaje = 762 753

Entrada basada en 1. Esto es peor que el enfoque trivial, ya que utiliza 37 no letras. Sin embargo, es algo interesante.

-9 gracias a Leo .

h=lambda g:g and h(g-1)+chr(65+int('GYGGYHGYYGYTGTYHGYGGHGGTGHGYGYGFGHGGYGGHHGGHHYYGHGHGGYFGGYHGGTHGHTGGGGGFGGVHGT'[g*3-3:g*3],35)%26)or''

Pruébalo en línea!

05AB1E , puntuación: 204

.•3ŽγY
₁ùÐÁo0ª ’ö:•£

Pruébalo en línea!

Brainf ** k, puntaje = 2690

Ingrese un solo byte que va de 0x1a 0x1a.

>>++++>+++>>>>++++++++++[<+<-<+>>>-]<<--<+++>>>++>->+++++++++++>++++++>-------->---->-->>---------->--------->+++++>++++++++>--->+>----------->+++++++++>------->+++++++>++++++++++++>----->------>+>>+++++++[<+++++++++++[<[[+<]+<]>->[[>]>]<<<-]>-]<<[-]>,[[<]<.[-]>+[>]<-]

Pruébalo en línea!

APL (Dyalog) , puntuación: 391

↑∘'GHYTFVBNJURDCMKIESXLOWAZPQ'

Pruébalo en línea!

El único uso para letras latinas en Dyalog es en nombres de variables y algunas funciones del sistema. Aparte de eso, solo se usan glifos y algunas letras griegas.

Pitón 3, 522

lambda g:"GHYTFVBNJURDCMKIESXLOWAZPQ"[:g]

Pruébalo en línea!

Una lambda anónima que utiliza el corte de cadenas de Python ( "asdf"[:i]obtiene los primeros icaracteres de "asdf")

Clojure, 484 474 puntos

-10 puntos porque aparentemente %puede existir después de un número sin un espacio que los separe. Puede que tenga que volver y mejorar algunas presentaciones.

#(subs"ghytfvbnjurdcmkiesxlowazpq"0%)

Una función anónima. Básicamente un puerto Clojure de lo que ya se ha publicado. Puntúa muy bien! Creo que este es el primer programa de Clojure que he escrito que no contiene un solo espacio.

(defn spiral [n]
  ; Substring the hardcoded list, going from index 0 to n
  (subs "ghytfvbnjurdcmkiesxlowazpq" 0 n))

Ly , 521 puntos

"QPZAWOLXSEIKMCDRUJNBVFTYHG"ns[,spol];

Pruébalo en línea!

No siento que esto sea optimizable.

Bash , puntuación: 465

cut -b-$1<<<GHYTFVBNJURDCMKIESXLOWAZPQ

Pruébalo en línea!

Casco , 293 bytes

↑¨ghytfvb⌋ȷÜdcmkÏexl⁰Λzpq

Este es el más corto que pude encontrar, el más cercano ¨gHYtfvB⌋ȷÜdCmkÏex←ẆAzpq¨ para un puntaje de 293 ..

Pruébalo en línea!

Explicación

Búsqueda de fuerza bruta, resulta que todas las minúsculas dieron la mejor puntuación. Básicamente es lo mismo que la solución de @Wheat Wizard, take( ↑) en una cadena comprimida ( ¨).

Common Lisp, puntuación: 580

(subseq"GHYTFVBNJURDCMKIESXLOWAZPQ"0(read))

Pruébalo en línea!

Excel, 490 puntos

=LEFT("GHYTFVBNJURDCMKIESXLOWAZPQ",A1)

La Convención para los respondedores de Excel es recibir información de A1. Cambiar esto a G1cortes 22 puntos (468).

=LEFT("GHYTFVBNJURDCMKIESXLOWAZPQ",G1)

C # , puntaje 546

g=>"GHYTFVBNJURDCMKIESXLOWAZPQ".Substring(0,g);

Óxido, puntaje 443

No es frecuente que Rust sea bueno en el código de golf, pero aquí supera muchos idiomas

|g|&"GHYTFVBNJURDCMKIESXLOWAZPQ"[..g]

Golang, puntaje 861

func g(g int){io.WriteString(os.Stdout,"GHYTFVBNJURDCMKIESXLOWAZPQ"[0:g])}

¡Juega en línea!

Javascript ES6, 527 puntos

g=>`GHYTFVBNJURDCMKIESXLOWAZPQ`.slice(0,g)

Intentalo !

f=g=>`GHYTFVBNJURDCMKIESXLOWAZPQ`.slice(0,g)

input.oninput = function() {
    output.value = f(input.value);
}

textarea { width: 500px; height: 6em; font-style: monospace; }

<textarea id="input"></textarea>
<textarea disabled id="output"></textarea>

PHP, 590 puntos

<?=substr(GHYTFVBNJURDCMKIESXLOWAZPQ,0,$argv[1]);

Pruébalo en línea!

PHP, puntaje 584

jugueteó un poco con el diccionario; El hecho de que xoring la cadena lo corte se vuelve substrobsoleto.

<?=">1 -?/;73,+=:420<*!56.8#)("^str_repeat(y,$argv[1]);

Pruébalo en línea .

Mathematica, 528

"GHYTFVBNJURDCMKIESXLOWAZPQ"~StringTake~#&

Pruébalo en línea!

Pyth , puntuación: 371

<"GHYTFVBNJURDCMKIESXLOWAZPQ

Pruébalo aquí

¿Cómo?

<"GHYTFVBNJURDCMKIESXLOWAZPQ"Q   implicit string end, implicit input
<                            Q   first Q(=input) elements ...
 "GHYTFVBNJURDCMKIESXLOWAZPQ"    ... of this string

Rubí , 453 puntos

->g{'GHYTFVBNJURDCMKIESXLOWAZPQ'[0,g]}

Pruébalo en línea!

> <> , 558 + 16 = 574 puntos

<;v? : <{"GHYTFVBNJURDCMKIESXLOWAZPQ"
  >$o1-^

Utiliza el -v bandera para empujar la entrada a la pila.

Empuja la espiral sobre la pila en orden inverso, luego gira la entrada hacia arriba. Luego, mientras la parte superior de la pila no es cero, imprime la siguiente letra y disminuye la parte superior de la pila.

Pruébalo en línea!

Pyth , 261 puntos

<."AZJ{Û§zoÆæÏýú

Pruébalo aquí!

Esto genera letras mayúsculas. Para minúsculas, puede probar la alternativa 261 byter .