Espiral circular do teclado

24

Este é um 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 "espiralar" neste teclado, começando por G. A espiral começará em G, vai para H, depois para Y, depois para T, depois F, depois V, depois V, depois B, depois N, depois J e U , então R, então D, então C, ... etc. Seu desafio é, dado um número 1 ≤ N ≤ 26, gerar os primeiros N caracteres nesta espiral. (Se você estiver confuso, consulte as figuras no final da postagem.)

A pegada? A pontuação do seu programa é proporcional aos índices de caracteres encontrados dentro da espiral!

Pontuação

  1. Para cada letra (sem distinção entre maiúsculas e minúsculas) no seu código, adicione o índice desse caractere na espiral à sua pontuação (começando em 1).
  2. Para cada personagem que não esteja na espiral, adicione 10 à sua pontuação.
  3. A pontuação mais baixa vence.

Por exemplo, o programa print("Hello, World!")tem uma pontuação de 300.

Para sua conveniência, escrevi uma niveladora automática de programas.

Mostrar snippet de código

Outras regras

  • Seu envio pode ser um programa ou função.
  • Você pode pegar N iniciando em 0 ou 1 e terminando em 25 ou 26, respectivamente, mas as saídas ainda devem começar com "G" e terminar com "GHYTFVBNJURDCMKIESXLOWAZPQ".
  • Você deve imprimir os caracteres na espiral em ordem .
  • Se uma função, você pode retornar uma lista de caracteres em vez de uma string.
  • Você pode ter uma nova linha à direita após a saída.
  • Você pode usar letras minúsculas em vez de letras maiúsculas ou uma combinação de ambas.

Casos de teste

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

As fotos

teclado regular

A espiral sobreposta:

teclado espiral

ascii-art  code-challenge  keyboard 
— Conor O'Brien
fonte
3
Alguém assistiu Sphere recentemente ...
— Pureferret 29/11
@Pureferret Você poderia me esclarecer? Não sei ao que você se refere.
— Conor O'Brien
@ ConorO'Brien Na Sphere (romance e filme), um alienígena se comunica com humanos usando um código numérico de dois dígitos, em que cada número corresponde a uma letra no teclado em um padrão muito semelhante .
— Engenheiro Toast

Respostas:

14

Japt , 304 264 162 pontos

Guardado 40 pontos graças a @ ConorO'Brien

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

Teste online!

Para salvar o máximo de pontos possível, a sequência inteira é condensada em 9 caracteres Unicode, interpretando cada execução de 3 letras como um número base-36 e convertendo em um ponto de código. O programa em si pega essa sequência compactada (que custa 110 pontos, incluindo as aspas) e mapeia cada charcode convertendo-o em uma ssequência na base-36 ( Gapós ;o início). îrecebe os primeiros {input} caracteres disso, que são impressos implicitamente.

— ETHproductions
fonte
11

Espiral , pontuação:  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

Um intérprete pode ser encontrado aqui .

Explicação:

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

O programa começa no 0personagem na quarta linha. O primeiro pedaço de código a ser executado é 0;vg. ;pega um número como entrada e o coloca na pilha. vcoloca o que está no registrador (um zero) na pilha. Será usado como contador. gé um rótulo, quando é atingido, o controle salta para a outra ocorrência da letra gno código.

Então é aqui que o controle está agora:

X
v
g

Como existe espaço em branco em todas as outras direções, o ponteiro da instrução começa a se mover para cima. vcoloca um zero na pilha e Xa lança imediatamente. Como o valor exibido é zero, o ponteiro da instrução se move paraX (caso contrário, ele seria tratado como espaço em branco).

Por padrão, o fluxo de controle está no modo virar à direita; agora, quando atinge a junção, o ponteiro da instrução gira para a direita. vmais uma vez, empurra um zero para a pilha, *incrementa o registro em um.

v*v*v
  X
  v
  g

O próximo vcoloca o que está no registrador (número 1) na pilha, o ponteiro da instrução tenta girar para a direita, pressionando o próximo X. O valor adicionado à pilha é exibido e colocado no registro. Como ele é diferente de zero, Xnão é inserido e o IP prossegue para o próximo *à direita, aumentando novamente o valor no registro.

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

Isso acontece repetidamente até chegarmos ao final desta parte e a linha de *s começa. Até agora, o valor no registro é 6, que é a letra gASCII menos a letra ASCII a. Assim, com uma linha de 97 *s, aumentamos o valor no registro para 103, que corresponde à letra gque queremos imprimir. vempurra-o para a pilha e Pé outro rótulo ao bater, que pulamos para o outroP na primeira linha do código.

Aqui .aparece o valor da pilha e o imprime como um caractere. Depois disso, Xaparece o zero estranho da pilha e ~compara os dois valores restantes na pilha (os valores sendo o contador e o valor de entrada). Se os valores forem iguais, o operador coloca zero na pilha (caso contrário, -1 ou 1). Novamente, o controle tenta virar à direita. Xexibe o valor da comparação da pilha, se for zero X, e depois de !inserida, finalizando o programa.

P.X~ZZ*v+^
   X
   !

Caso contrário, o IP continuará no Z, que é um rótulo que, neste caso, salta apenas um passo para a direita. A razão para fazer isso é que pular define o valor no registro de volta a zero. *incrementa o registro e vcoloca o 1 resultante na pilha. +exibe os dois elementos principais da pilha (o 1 e o contador), os adiciona e coloca o resultado na pilha (na verdade, isso incrementa o contador em um). ^copia o resultado da pilha para o registro sem removê-lo da pilha.

#diminui o valor no registro em um, vempurra o valor diminuído para a pilha, o IP tenta virar para a direita e Xexibe o valor da pilha. Se o valor for diferente de zero, o IP continuará se movendo para o leste, diminuindo o valor no registro, até atingir zero, e o IP entrar em uma Xramificação.

#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

A ramificação leva a um rótulo correspondente ao valor do contador. Ao atingir o rótulo, o controle salta para a outra ocorrência do rótulo na seção em que começamos com o rótulog , iniciando outra iteração. Assim como em g, o valor no registro é incrementado até o valor ASCII da letra que precisamos imprimir. Em seguida, o caractere é impresso e o contador incrementado, outra etiqueta é selecionada. Isso acontece até depois da última iteração, o contador é igual à entrada e o programa termina.

Editar:

P.X~Zv+^
   X *
   ! Z

Consegue a mesma coisa que

P.X~ZZ*v+^
   X
   !

mas com menos espaço em branco.

Edição 2:

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

Pode ser usado em vez de:

*****************************************************************vP
— Steadybox
fonte
2
Irônico que um languaje chamado "Espiral" tenha uma pontuação tão alta em um problema de saída em espiral.
— Shirkam
6

Haskell , 471

(`take`"GHYTFVBNJURDCMKIESXLOWAZPQ")

Experimente online!

Isso é um pouco de referência, acho que deve haver uma maneira melhor, mas é a melhor que encontrei até agora.

Explicação

Suponho que devo explicar isso para aqueles que não conhecem muito bem Haskell. A função takepega os primeiros n elementos da lista. É chamado assim:

take n list

Queremos pegar os primeiros n elementos da picada "GHYTFVBNJURDCMKIESXLOWAZPQ", então queremos algo como

f n=take n"GHYTFVBNJURDCMKIESXLOWAZPQ"

Podemos fazer melhor, porém, podemos infixar takeusando backticks

f n=n`take`"GHYTFVBNJURDCMKIESXLOWAZPQ"

E agora isso pode ser feito sem sentido

(`take`"GHYTFVBNJURDCMKIESXLOWAZPQ")
— Assistente de Trigo
fonte
É uma pena que uma aplicação parcial exija o uso partialno Clojure. Era isso que eu estava procurando, mas partialera muito caro.
— Carcigenicate
3
A sua pontuação não é 470? É o que o trecho da pergunta está me dando de qualquer maneira ...
— Apenas um aluno
4

Befunge, Pontuação: 531

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

Eu sinto que esse desafio teria sido mais interessante se o resultado também estivesse em espiral.

— Brincadeira
fonte
4

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

sub("GHYTFVBNJURDCMKIESXLOWAZPQ",1,Ans

-22 pontos de Conor O'Brien

Corra com 5:prgmNAME.

Retorna / imprime a subsequência de 1até Ans(a entrada numérica).

O TI-Basic é um idioma tokenizado , por isso estou pontuando isso pelos valores de bytes dos tokens.

sub( é 0xbb 0x0c, então 20

"é 0x2a, então *, então 10 * 2 = 20

Letras maiúsculas não são alteradas, portanto a string é 351

,é 0x2b, então +, então 10 * 2 = 20

1é 0x31, então 1, então 10

Ansé 0x72, ou seja r, 11

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

— pizzapants184
fonte
Com essa interpretação das regras de pontuação, você pode salvar mais 31 bytes procurando as letras em locais criativos. Substitua S, A, Z, P pelas variáveis ​​estatísticas s, a, z, p (no menu STAT + 5), que obtêm 17 pontos cada: são tokens de 2 bytes cujo primeiro byte corresponde a b. Substitua O, W, Q pelas letras minúsculas comuns, que possuem 20 pontos cada: são tokens de 2 bytes 0xBBBF, 0xBBC7, 0xBBC1.
— Misha Lavrov #
3

Python 3, pontuação = 762 753

Entrada baseada em 1. Isso é pior do que a abordagem trivial, pois usa 37 letras não. É um pouco interessante, no entanto.

-9 graças a Leo .

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

Experimente online!

— Colera Su
fonte
11
Eu gosto dessa abordagem :) A propósito, [:g*3][-3:]pode tornar-se [g*3-3:g*3]diminuir a pontuação total em 9 pontos #
— Leo
2

Brainf ** k, pontuação = 2690

Insira um único byte variando de 0x1até 0x1a.

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

Experimente online!

— Colera Su
fonte
2

APL (Dyalog) , pontuação: 391

↑∘'GHYTFVBNJURDCMKIESXLOWAZPQ'

Experimente online!

O único uso para letras latinas no Dyalog está em nomes de variáveis ​​e em algumas funções do sistema. Além disso, apenas glifos e algumas letras gregas são usadas.

— Uriel
fonte
1

Python 3, 522

lambda g:"GHYTFVBNJURDCMKIESXLOWAZPQ"[:g]

Experimente online!

Um lambda anônimo utilizando o fatiamento de strings do Python ( "asdf"[:i]obtém os primeiros icaracteres de "asdf")

— pizzapants184
fonte
1

Clojure, 484 474 pontos

-10 pontos porque aparentemente um %pode existir após um número sem um espaço que os separa !? Talvez eu precise voltar e melhorar alguns envios.

#(subs"ghytfvbnjurdcmkiesxlowazpq"0%)

Uma função anônima. Basicamente, uma porta Clojure do que já foi publicado. Pontuações agradavelmente! Eu acho que este é o primeiro programa Clojure que eu já escrevi que não contém um único espaço.

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

Casca , 293 bytes

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

Este é o mais curto que pude encontrar, o próximo mais próximo, ¨gHYtfvB⌋ȷÜdCmkÏex←ẆAzpq¨com uma pontuação de 293 ..

Experimente online!

Explicação

Pesquisa por força bruta, verifica-se que todas as letras minúsculas deram a melhor pontuação. É basicamente o mesmo que a solução do @Wheat Wizard, take( ↑) em uma string compactada ( ¨).

— ბიმო
fonte
1

Excel, 490 pontos

=LEFT("GHYTFVBNJURDCMKIESXLOWAZPQ",A1)

A convenção para usuários do Excel deve receber contribuições A1. Alterar isso para G1corta 22 pontos (468).

=LEFT("GHYTFVBNJURDCMKIESXLOWAZPQ",G1)
— Wernisch
fonte
1

C # , pontuação 546

g=>"GHYTFVBNJURDCMKIESXLOWAZPQ".Substring(0,g);
— auhmaan
fonte
1

Ferrugem, pontuação 443

Não é sempre que o Rust é bom em golfe de código, mas aqui ele vence muitos idiomas

|g|&"GHYTFVBNJURDCMKIESXLOWAZPQ"[..g]
— esfarrapado
fonte
1

Javascript ES6, 527 pontos

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

Tente !

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>
Expandir snippet

— Weedoze
fonte
1

PHP, pontuação 584

mexeu um pouco com o dicionário; o fato de xorar a corda a cortar tornava substrobsoleto.

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

Experimente online .

— Titus
fonte
0

Pyth , pontuação: 371

<"GHYTFVBNJURDCMKIESXLOWAZPQ

Experimente aqui.

Quão?

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

> <> , 558 + 16 = 574 pontos

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

Usa o -v sinalizador para enviar a entrada para a pilha.

Empurra a espiral para a pilha na ordem inversa e depois gira a entrada para o topo. Então, enquanto o topo da pilha é diferente de zero, imprime a próxima letra e diminui o topo da pilha.

Experimente online!

— KSmarts
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.