Spirale circolare per tastiera

24

Questa è una tastiera 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

Possiamo "uscire a spirale" su questa tastiera, partendo da G. La spirale inizierà da G, andrà a H, poi a Y, poi a T, poi F, poi V, poi B, quindi N, quindi J, quindi U , quindi R, quindi D, quindi C, ecc. La tua sfida è, dato un numero 1 ≤ N ≤ 26, produrre i primi N caratteri in questa spirale. (Se sei confuso, fai riferimento alle immagini alla fine del post.)

La presa? Il punteggio del tuo programma è proporzionale agli indici dei personaggi trovati all'interno della spirale!

punteggio

  1. Per ogni lettera (senza distinzione tra maiuscole e minuscole) nel tuo codice, aggiungi l'indice di quel carattere nella spirale al tuo punteggio (a partire da 1).
  2. Per ogni personaggio non presente nella spirale, aggiungi 10 al tuo punteggio.
  3. Vince il punteggio più basso.

Ad esempio, il programma print("Hello, World!")ha un punteggio di 300.

Per tua comodità, ho scritto un selezionatore automatico di programmi.

Mostra snippet di codice

Altre regole

  • Il tuo invio può essere un programma o una funzione.
  • Puoi prendere N partire da 0 o 1 e terminando rispettivamente a 25 o 26, ma le uscite dovrebbero comunque iniziare con "G" e terminare con "GHYTFVBNJURDCMKIESXLOWAZPQ".
  • È necessario generare i caratteri nella spirale in ordine .
  • Se una funzione, è possibile restituire un elenco di caratteri anziché una stringa.
  • Potresti avere una nuova riga finale dopo l'output.
  • Puoi usare lettere minuscole anziché maiuscole o una combinazione di entrambe.

Casi test

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

Immagini

tastiera normale

La spirale sovrapposta:

tastiera a spirale

ascii-art  code-challenge  keyboard 
— Conor O'Brien
fonte
3
Qualcuno ha visto Sphere di recente ...
— Pureferret,
@Pureferret Potresti illuminarmi? Non sono sicuro di cosa ti riferisci.
— Conor O'Brien,
@ ConorO'Brien In Sphere (sia il romanzo che il film), un alieno comunica con gli umani usando un codice numerico a due cifre in cui ogni numero corrisponde a una lettera sulla tastiera in uno schema molto simile .
— Ingegnere Toast,

Risposte:

14

Japt , 304 264 162 punti

Hai risparmiato 40 punti grazie a @ ConorO'Brien

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

Provalo online!

Per salvare il maggior numero possibile di punti, l'intera stringa viene condensata in 9 caratteri Unicode interpretando ogni serie di 3 lettere come un numero base 36, quindi convertendo in un punto di codice. Il programma stesso prende questa stringa compressa (che costa 110 punti, comprese le virgolette) e mappa ogni charcode convertendolo in una sstringa in base-36 ( Gdopo ;l'inizio). îprende i primi {input} caratteri di questo, che è implicitamente stampato.

— ETHproductions
fonte
11

Spirale , punteggio:  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

Un interprete può essere trovato qui .

Spiegazione:

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

Il programma inizia dal 0personaggio sulla quarta riga. Il primo pezzo di codice da eseguire è 0;vg. ;prende un numero come input e lo posiziona nello stack. vposiziona ciò che è nel registro (uno zero) nello stack. Sarà usato come contatore. gè un'etichetta, quando viene raggiunta, il controllo passa all'altra occorrenza della letterag nel codice.

Quindi qui è dove si trova il controllo:

X
v
g

Poiché c'è spazio bianco in tutte le altre direzioni, il puntatore dell'istruzione inizia a spostarsi verso l'alto. vposiziona uno zero nello stack e lo Xestrae immediatamente dallo stack. Poiché il valore visualizzato è zero, il puntatore dell'istruzione si sposta suX (altrimenti lo tratterebbe come uno spazio).

Per impostazione predefinita, il flusso di controllo è in modalità svolta a destra, quindi ora quando raggiunge la giunzione, il puntatore dell'istruzione gira a destra. vancora una volta spinge uno zero nello stack, *incrementa il registro di uno.

v*v*v
  X
  v
  g

Il prossimo vposto ciò che è nel registro (numero 1) nello stack, il puntatore dell'istruzione tenta di girare a destra, colpendo il successivo X. Il valore appena aggiunto allo stack viene estratto e inserito nel registro. Poiché è diverso da zero, Xnon viene immesso e l'IP procede invece alla successiva *a destra, incrementando nuovamente il valore nel registro.

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

Questo succede ancora e ancora fino a quando non raggiungiamo la fine di questa parte e *inizia la linea di s. Ormai il valore nel registro è 6, che è la lettera gASCII meno la lettera ASCII a. Quindi con una riga di 97 *s incrementiamo il valore nel registro a 103, che corrisponde alla lettera gche vogliamo stampare. vlo spinge nello stack, ed Pè un'altra etichetta dopo aver colpito che saltiamo all'altraP sulla prima riga del codice.

Qui .estrae il valore dalla pila e lo stampa come personaggio. Dopodiché Xestrae lo zero estraneo dallo stack, quindi ~confronta i due valori rimanenti nello stack (i valori sono il contatore e il valore di input). Se i valori sono gli stessi, l'operatore inserisce zero nello stack (altrimenti -1 o 1). Ancora una volta, il controllo tenta di girare a destra. Xestrae il valore del confronto dallo stack, se è zero X, e dopo averlo !inserito, terminando il programma.

P.X~ZZ*v+^
   X
   !

Altrimenti l'IP continua con Z, che è un'etichetta che in questo caso salta solo di un passo verso destra. La ragione di ciò è che il salto riporta a zero il valore nel registro. *incrementa il registro e vposiziona 1 risultante nello stack. +apre i due elementi superiori dello stack (l'1 e il contatore), li aggiunge e posiziona il risultato nello stack (in effetti questo incrementa il contatore di uno). ^copia il risultato dalla pila al registro senza rimuoverlo dalla pila.

#decrementa il valore nel registro di uno, vspinge il valore decrementato nello stack, l'IP tenta di girare a destra e Xfa apparire il valore dallo stack. Se il valore è diverso da zero, l'IP continua a spostarsi verso est, diminuendo il valore nel registro, fino a quando non raggiunge lo zero e l'IP entra in un Xramo.

#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

Il ramo porta a un'etichetta corrispondente al valore del contatore. Dopo aver colpito l'etichetta, il controllo passa all'altra occorrenza dell'etichetta nella sezione in cui abbiamo iniziato con l'etichetta g, iniziando un'altra iterazione. Come per il g, il valore nel registro viene incrementato fino al valore ASCII della lettera che dobbiamo stampare. Quindi il carattere viene stampato e il contatore incrementato, viene selezionata un'altra etichetta. Ciò accade fino a dopo l'ultima iterazione il contatore è uguale all'input e il programma termina.

Modificare:

P.X~Zv+^
   X *
   ! Z

Raggiunge la stessa cosa di

P.X~ZZ*v+^
   X
   !

ma con meno spazi bianchi.

Modifica 2:

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

Può essere utilizzato al posto di:

*****************************************************************vP
— Steadybox
fonte
2
Ironia della sorte che un languaje chiamato "Spirale" abbia un punteggio così alto in un problema di uscita a spirale.
— Shirkam,
6

Haskell , 471

(`take`"GHYTFVBNJURDCMKIESXLOWAZPQ")

Provalo online!

Questo è un po 'un punto di riferimento, penso che ci debba essere un modo migliore, ma è il migliore che ho trovato finora.

Spiegazione

Suppongo che dovrei spiegare questo per coloro che non hanno familiarità con Haskell troppo bene. La funzione takeaccetta i primi n elementi dell'elenco. Si chiama così:

take n list

Vogliamo prendere i primi n elementi della puntura "GHYTFVBNJURDCMKIESXLOWAZPQ", quindi vogliamo qualcosa di simile

f n=take n"GHYTFVBNJURDCMKIESXLOWAZPQ"

Possiamo fare di meglio, tuttavia, possiamo aggiungere takeusando i backtick

f n=n`take`"GHYTFVBNJURDCMKIESXLOWAZPQ"

E ora questo può essere reso inutile

(`take`"GHYTFVBNJURDCMKIESXLOWAZPQ")
— Mago del grano
fonte
È un peccato che l'applicazione parziale richieda l'utilizzo partialin Clojure. Questo è quello che stavo cercando, ma partialera troppo costoso.
— Carcigenicato il
3
Il tuo punteggio non è 470? Questo è quello che mi dà lo snippet nella domanda ...
— Solo uno studente il
4

Befunge, Punteggio: 531

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

Penso che questa sfida sarebbe stata più interessante se anche l'output dovesse essere in una spirale.

— Jo King
fonte
4

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

sub("GHYTFVBNJURDCMKIESXLOWAZPQ",1,Ans

-22 punti da Conor O'Brien

Corri con 5:prgmNAME.

Restituisce / stampa la substringa da 1a Ans(il numero inserito).

TI-Basic è una lingua tokenizzata , quindi sto calcolando questo con i valori in byte dei token.

sub( è 0xbb 0x0c, quindi 20

"è 0x2a, quindi *, quindi 10 * 2 = 20

Le lettere maiuscole non cambiano, quindi la stringa è 351

,è 0x2b, quindi +10 * 2 = 20

1è 0x31, quindi 1, quindi 10

Ansè 0x72, ovvero r11

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

— pizzapants184
fonte
Con questa interpretazione delle regole di punteggio, puoi salvare altri 31 byte cercando le lettere in luoghi creativi. Sostituisci S, A, Z, P con le variabili stat s, a, z, p (nel menu STAT + 5), che ottengono 17 punti ciascuno: sono token a 2 byte il cui primo byte corrisponde a b. Sostituisci O, W, Q con le normali lettere minuscole, che segnano 20 punti ciascuna: sono token a 2 byte 0xBBBF, 0xBBC7, 0xBBC1.
— Misha Lavrov,
3

Python 3, punteggio = 762 753

1 input basato. Questo è peggio dell'approccio banale, poiché utilizza 37 non lettere. È in qualche modo interessante, comunque.

-9 grazie a Leo .

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

Provalo online!

— Colera Su
fonte
1
Mi piace questo approccio :) A proposito, [:g*3][-3:]può diventare [g*3-3:g*3]abbassare il punteggio totale di 9 punti
— Leo
2

Brainf ** k, punteggio = 2690

Immettere un singolo byte che va da 0x1a 0x1a.

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

Provalo online!

— Colera Su
fonte
2

APL (Dyalog) , punteggio: 391

↑∘'GHYTFVBNJURDCMKIESXLOWAZPQ'

Provalo online!

L'unico uso delle lettere latine in Dyalog è nei nomi delle variabili e in alcune funzioni di sistema. A parte questo, vengono utilizzati solo glifi e alcune lettere greche.

— Uriel
fonte
1

Python 3, 522

lambda g:"GHYTFVBNJURDCMKIESXLOWAZPQ"[:g]

Provalo online!

Un lambda anonimo che utilizza lo slicing di stringhe di Python ( "asdf"[:i]ottiene i primi icaratteri di "asdf")

— pizzapants184
fonte
1

Clojure, 484 474 punti

-10 punti perché apparentemente a % può esistere dopo un numero senza uno spazio che li separa !? Potrei dover tornare indietro e migliorare alcune osservazioni.

#(subs"ghytfvbnjurdcmkiesxlowazpq"0%)

Una funzione anonima. Fondamentalmente una porta Clojure di ciò che è già stato pubblicato. I punteggi piacevolmente! Penso che questo sia il primo programma Clojure che abbia mai scritto che non contenga un singolo spazio.

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

Buccia , 293 byte

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

Questo è il più corto che ho trovato, il prossimo più vicino ¨gHYtfvB⌋ȷÜdCmkÏex←ẆAzpq¨per un punteggio di 293 ..

Provalo online!

Spiegazione

La ricerca della forza bruta, risulta che tutte le lettere minuscole hanno dato il punteggio migliore. È praticamente lo stesso della soluzione di @Wheat Wizard, take( ↑) su una stringa compressa ( ¨).

— ბიმო
fonte
1

Excel, 490 punti

=LEFT("GHYTFVBNJURDCMKIESXLOWAZPQ",A1)

La convenzione per le risposte di Excel è quella di ricevere input da A1. Cambiando questo per G1tagliare 22 punti (468).

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

C # , punteggio 546

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

Rust, punteggio 443

Non capita spesso che Rust sia bravo nel code golf, ma qui batte molte lingue

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

Javascript ES6, 527 punti

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

Provalo !

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>
Espandi frammento

— Weedoze
fonte
1

PHP, punteggio 584

armeggiato un po 'con il dizionario; il fatto che il xoring della stringa la interrompa reso substrobsoleto.

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

Provalo online .

— Titus
fonte
0

Pyth , punteggio: 371

<"GHYTFVBNJURDCMKIESXLOWAZPQ

Provalo qui.

Come?

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

> <> , 558 + 16 = 574 punti

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

Usa il -vflag per spingere l'input nello stack.

Spinge la spirale sulla pila in ordine inverso, quindi ruota l'ingresso verso l'alto. Quindi, mentre la parte superiore della pila è diversa da zero, stampa la lettera successiva e diminuisce la parte superiore della pila.

Provalo online!

— KSmarts
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.