Mano sinistra contro mano destra - Typists Challenge


32

Il tuo compito è quello di mettere l'uno contro l'altro i lati della tastiera e costruire due programmi, nella stessa lingua, uno usando solo i tasti sul lato sinistro di una tastiera standard che emette Pollinium milk; plump pumpkin; lollipop?e uno usando i tasti sulla destra che emette Weatherheaded sweetheart haberdasheress!.

Regole

I tasti esatti consentiti per il programma a sinistra sono:

123456!@#$%^QWERTYqwertyasdfghASDFGH`zxcvb~ZXCVB

e per il programma a destra:

7890-=&*()_+uiop[]UIOP{}jkl;'\JKL:"|nm,./NM<>?

Esistono quattro chiavi libere Esc( \x1b), Tab( \x09), Space( \x20) e Enter( \x0ae / o \x0d) che possono essere utilizzate in nessuna delle due soluzioni o in entrambe.

Il tuo punteggio sarà il conteggio totale dei byte per entrambi i programmi. Mentre ho usato il termine program, i tuoi invii possono essere programmi completi o funzioni come al solito ed entrambi possono essere di tipi diversi (ad es. Un programma completo e una funzione).

Il risultato deve includere il testo desiderato, qualsiasi quantità di spazi iniziali e finali va bene, purché il testo esatto appaia al suo interno.

Sono vietate le scappatoie standard .

Le soluzioni più brevi in ​​ogni lingua vincono.


6
Perché H è la mano sinistra?
TSH

1
@tsh Volevo dividere la tastiera 6/6 (o il più vicino possibile) solo per cercare di mantenere un numero pari di simboli per ogni "mano".
Dom Hastings,

8
// Forse dovrei imparare gli spazi bianchi e tornare più tardi ...
tsh

@tsh, immagino che una risposta agli spazi bianchi sia inevitabile! Non sono sicuro di quanto sarebbe competitivo! Forse avrei dovuto affrontarlo, troppo tardi ora!
Dom Hastings,

Va bene se il programma ha anche altri output (non bianchi), purché includa i testi richiesti?
Grzegorz Oledzki,

Risposte:


12

Perl 5 , 261 = 88 + 173 byte

Questo è un esempio in cui "le opzioni di lingua non contano" è un problema. La soluzione lato rigida utilizza -p, il lato sinistro no. Quindi conta come la stessa lingua o no? E le opzioni dovrebbero provenire dal set di caratteri sinistro / destro?

Sinistra 88

utilizzare -M5.10.0(o -Edalla riga di comando) per attivare sayAncora una volta discutibile se questa opzione deve essere considerata come codice e deve provenire dal lato sinistro o se rientra nelle "opzioni per impostare la versione della lingua non conteggiare"

say eYYYYZYEYWYYYYYWQYEYQWQEYQYYZYWYYYYYQYQW^q%565504004w4052bw!504!w!04!204bw56550!6!h%

Provalo online!

Giusto 173

Esegui con l' -popzione (che comprende anche caratteri giusti)

}{*_=\(uuuuuuuuuuuuuiuuuuuuuuuuiuuuuuuuuuuuuuui&Uiipjipjiijij0puiipjiipp0jijipjipjipipp7|Ouiujujjuiuuu0kouuujuiju0jijujuikjujukk7&"7oulio7iouloli77ooliou7liiu7o7lu7io7o77i")

Questo può quasi certamente essere migliorato, ma per ora è stato abbastanza difficile far funzionare qualcosa. Non avendo accesso a print, say, $_e sub{}rende difficile l'uscita

Provalo online!


Non preoccupato per le bandiere, sono contento che questo sia valido. Una soluzione molto più breve di quella con cui ho armeggiato come ho chiamato evalvia &{(u&I.._)[9-7].O.(P|'"'&_).("U::u"&"o::o").("&"|p).(uo&il).(u&i.._)[9-8].("{|o"&"}uu").(j..u)[9]}!
Dom Hastings

12

Spazio bianco , 1175 1143 655 645 638 632 639 578 (293 + 285) byte

Doveva essere fatto ..; p
Può sicuramente essere giocato riempiendo lo stack invertito e stampandolo tutto alla fine in una sorta di ciclo, ma questo è solo il mio secondo programma su Whitespace di sempre, quindi non ho ancora capito .. EDIT: golf.

+7 byte perché ho scritto male pumpkincome pumkin.. (Grazie per aver notato, @ fəˈnɛtɪk .)

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

Lato sinistro Pollinium milk; plump pumpkin; lollipop?:

[S S T  T   S T T   T   T   N
_Push_-47_?][S S S T    S N
_Push_2_p][S S S T  N
_Push_1_o][S T  S S T   N
_Copy_1st_p][S S T  T   S T N
_Push_-5_i][S S T   T   S N
_Push_-2_l][S N
S _Duplicate_-2_l][S S S T  N
_Push_1_o][S T  S S T   N
_Copy_1st_l][S S T  T   S S T   T   T   S N
_Push_-78_space][S S T  T   T   S S T   T   N
_Push_-51_;][S S S N
_Push_0_n][S S T    T   S T N
_Push_-5_i][S S T   T   T   N
_Push_-3_k][S S S T S N
_Push_2_p][S S T    T   N
_Push_-1_m][S S S T T   T   N
_Push_7_u][S S S T  S N
_Push_2_p][S S T    T   S S T   T   T   S N
_Push_-78_space][S S S T    S N
_Push_2_p][S S T    T   N
_Push_-1_m][S S S T T   T   N
_Push_7_u][S S T    T   S N
_Push_-2_l][S S S T S N
_Push_2_p][S S T    T   S S T   T   T   S N
_Push_-78_space][S S T  T   T   S S T   T   N
_Push_-51_;][S S T  T   T   N
_Push_-3_k][S S T   T   S N
_Push_-2_l][S S T   T   S T N
_Push_-5_i][S S T   T   N
_Push_-1_m][S S T   T   S S T   T   T   S N
_Push_-78_space][S S T  T   N
_Push_-1_m][S S S T T   T   N
_Push_7_u][S S T    T   S T N
_Push_-5_i][S S S N
_Push_0_n][S S T    T   S T N
_Push_-5_i][S S T   T   S N
_Push_-2_l][S N
S _Duplicate_-2_l][S S S T  N
_Push_1_o][S S T    T   T   T   T   S N
_Push_-30_P][N
S S N
_Create_Label_LOOP][S S S T T   S T T   T   S N
_Push_110][T    S S S _Add][T   N
S S _Print_as_char][N
S N
N
_Jump_to_Label_LOOP]

Provalo online (solo con spazi non elaborati, schede e nuove righe).

Lato destro Weatherheaded sweetheart haberdasheress!:

[S S T  T   S S S T S S N
_Push_-68_!][S S S T    T   T   S N
_Push_14_s][S N
S _Duplicate_14_s][S S S N
_Push_0_e][S S S T  T   S T N
_Push_13_r][S S S N
_Push_0_e][S S S T  T   N
_Push_3_h][S S S T  T   T   S N
_Push_14_s][S S T   T   S S N
_Push_-4_a][S S T   T   N
_Push_-1_d][S S S T T   S T N
_Push_13_r][S S S N
_Push_0_e][S S T    T   T   N
_Push_-3_b][S S T   T   S S N
_Push_-4_a][S S S T T   N
_Push_3_h][S S T    T   S S S T S T N
_Push_-69_space][S S S T    T   T   T   N
_Push_15_t][S S S T T   S T N
_Push_13_r][S S T   T   S S N
_Push_-4_a][S S S N
_Push_0_e][S S S T  T   N
_Push_3_h][S S S T  T   T   T   N
_Push_15_t][S S S N
_Push_0_e][S N
S _Duplicate_0_e][S S S T   S S T   S N
_Push_18_w][S S S T T   T   S N
_Push_14_s][S S T   T   S S S T S T N
_Push_-69_space][S S T  T   N
_Push_-1_d][S S S N
_Push_0_e][S S T    T   N
_Push_-1_d][S S T   T   S S N
_Push_-4_a][S S S N
_Push_0_e][S S S T  T   N
_Push_3_h][S S S T  T   S T N
_Push_13_r][S S S N
_Push_0_e][S S S T  T   N
_Push_3_h][S S S T  T   T   T   N
_Push_15_t][S S T   T   S S N
_Push_-4_a][S S S N
_Push_0_e][S S T    T   T   T   S N
_Push_-14_W][N
S S N
_Create_Label_LOOP][S S S T T   S S T   S T N
_Push_101][T    S S S _Add][T   N
S S _Print_as_char][N
S N
N
_Jump_to_Label_LOOP]

Provalo online (solo con spazi non elaborati, schede e nuove righe).


Spiegazione:

Costruisce prima lo stack invertito. La pressione di un numero viene eseguita come segue:

  • S all'inizio: abilitare la manipolazione dello stack
  • S: Spingi quello che segue come numero nello stack
  • S/ T: Bit di segno dove Sè positivo ed Tè negativo
  • Alcuni Te Sseguito da un N: Metti il ​​numero come binario nello stack ( T=1e S=0).

Quindi passerà sopra la pila invertita e stamperà tutto come caratteri. Lo fa come segue:

  1. Premere 0 ( SSSN)
  2. Spingere tutti i numeri che indicano i caratteri invertiti come spiegato sopra
  3. Crea un Label_0( NSSN)
    1. Duplica la parte superiore dello stack ( SNS)
    2. Se questo valore è 0: passa a Label_1( NTSTN)
    3. Altro: Pop e stampa la parte superiore della pila come carattere ( TNSS)
    4. Vai a Label_0( NSNN)
  4. Crea Label_1( NSSTN)

Questo sopra è il layout predefinito per entrambi i programmi. Ecco il registro delle modifiche per questo layout predefinito che ha ulteriormente ridotto il conteggio dei byte:

  1. Tutti i numeri vengono abbassati dello stesso importo ( nel primo programma e nel secondo) per ridurre le cifre binarie utilizzate per i numeri ora più bassi e tra i passaggi 3.2 e 3.3 vengono aggiunti i seguenti due passaggi secondari:100 110102 101

    • Premere 110 ( SSSTTSTTTSN) nel programma 1 o 101 ( SSSTTSSTSTN) nel programma 2
    • Pop e aggiungi i primi due valori dello stack tra loro e il risultato è il nuovo top dello stack ( TSSS)
  2. Ho usato anche SNSin alcuni casi di duplicare la parte superiore della pila, che viene utilizzato per il golf il ll, ll, eee ss.

  3. Inoltre, il passaggio 4 (creazione Label_1) è stato rimosso completamente. Uscirà con un errore, ma produrrà comunque tutto correttamente ( cosa consentita in base al meta ).

  4. È possibile copiare un n'esimo valore dalla cima dello stack (con STS+ 0-indicizzato n), che in alcuni casi è più breve della creazione di un nuovo numero.
    Nel primo programma l'ho fatto per: il secondo pin pop( STSSTN(copia 1) è più corto di SSSTTSSN(crea il numero per 'p')), il secondo lin lol( STSSTN(copia 1) è più corto di SSSTSSSN(crea il numero per 'l' )), il secondo pin p p( STSSTN(copia 1) è più corto di SSSTTSSN(crea il numero per 'p')), il secondo pin pumlp( STSSTTN(copia 3) è più corto di SSSTTSSN(crea il numero per 'p')), il secondo pin pmup( STSSTSN( copia 2) è più breve diSSSTTSSN(crea il numero per 'p')), il secondo min m m( STSSTN(copia 1) è più corto di SSSTSSTN(crea il numero per 'm')), il secondo iin ini( STSSTN(copia 1) è più corto di SSSTSTN(crea il numero per 'i') ).
    Nel secondo programma questo non è fatto per nessuno. La distanza tra alcuni è piuttosto breve, come ereo ded, ma la creazione del numero per 'e' ( SSTTN) o 'd' ( SSTTSN) è più breve o della stessa lunghezza della copia 1st ( STSSTN), quindi non ho potuto applicare questo trucco nel secondo programma per salvare byte. NOTA: dopo il passaggio di golf 7, non tutti si applicano più.

  5. In entrambi i programmi ho modificato il passaggio 1 del loop da SSSN(Push 0) a SSN(Push error_value) e ho rimosso i passaggi 3.1 ( SNSDuplica) e 3.2 ( NTSTNSe 0: Esci). Ora uscirà semplicemente con un errore che SSNè un valore sconosciuto non appena tenta di accedervi.

  6. Rimosso il SSN(valore_errore) completamente in entrambi i programmi. Si interromperà ora con l'errore " Impossibile eseguire Infix Plus " quando tenta di eseguire la funzione Aggiungi senza lasciare nulla nello stack.

  7. Modificati i valori costanti di 100e 102in 110e 101rispettivamente. Qui il programma Java utilizzato per generare la 110costante; e qui il programma Java utilizzato per generare la 101costante. Si noti che ora ci sono meno copie utilizzate rispetto a quelle descritte al punto 4 sopra, perché i nuovi valori sono in molti casi più brevi delle copie, quindi reinserirli è più breve.


La roba ST è semplicemente spingere il numero come binario, con spazio come 0, tab come 1. L'output è il TNSS, quindi hai due spazi extra all'inizio di ogni programma. Probabilmente salva anche i byte da duplicare e quindi aggiunge / sottrai per ciascun carattere e passa in rassegna i valori alla fine.
Jo King

1
Hai sbagliato la zucca.
fəˈnɛtɪk,

@ fəˈnɛtɪk Whoops lol .. Dovrebbe essere risolto ora, grazie per averlo notato.
Kevin Cruijssen,

4

Lenguage, così tanti byte

Il lato sinistro è 65721878296123796350462639500449228197646164622176218219262161264085219054330862921130017235140285847450697804123168755463678390611789188813352602373675420824698785508893489685489807676509031860196742608788337382365939621331808044899882497347443262020486908162559376082705672994569868 ripetizioni del acarattere, che è equivalente alla seguente programma Brainfuck:

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

Provalo online!

Il lato destro è 636605880289050800007960838028215177632402180834140124157618258152393860687206680356620669530585999501769442445842690365640523699585001167392310123764258380235064746704898152544431842440556280249638840374132783257375880144623575829131522611446544303839106505176776161206935275549421170646618266717893044911373119804737614528140 ripetizioni del pcarattere, che è equivalente alla seguente programma Brainfuck:

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

Provalo online!


3

CJam , 128 + 192 = 320 byte

64G^c111c111Z^cT$111c6^111X^c1$116X^c111Y^c32c1$6$Y3#$111c4^56Z^c32c112c13$A$A$3$5$1$4$4$4$12$22$22$14$32c13$111c1$T$7$A$4$1$63c

Provalo online!

'U))'i(((('_))'u('i('i(((('p))'i('i(((('_))'_)))))'i(((('_)))))'&(((((('u(('u))'i(((('i(((('u('i('i(((('_))'p))'u('&(((((('i('_))'_)))'i(((('p))'_)))))'_))'u(('i('i(((('p))'i(((('u(('u(('&(((((

Provalo online!


3

Fissione , 958 + 752 = 1710 byte

._.

Sinistra

D
z
^@$$$$$$$$$$$$$$$$$$$@!@$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$@!@~~~@!!@~~~@!@$$$$$@!@~~~~~@!@$$$$$$$$$$$$@!@~~~~~~~~@!@~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@!@$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$@!@~~~~@!@$$$@!@~@!@~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@!@~~~~~~~~~~~~~~~~~~~~~~~~~~~@!@$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$@!@~~~~@!@$$$$$$$$$@!@~~~~~~~~@!@$$$@!@~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@!@$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$@!@$$$$$@!@~~~~~~~~@!@$$$@!@~~~~~@!@~~@!@$$$$$@!@~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@!@~~~~~~~~~~~~~~~~~~~~~~~~~~~@!@$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$@!@$$$@!@~~~@!!@~~~@!@$$$$$$$@!@~@!@$@!@~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@!V

Provalo online!

Destra

                                           } \} \    } \      } \    } \   } \   } \    } \   } \       } \    } \   } \ } \       } \   } \                                           } \   } \    } \    } \   } \   } \   } \} \      } \    } \    } \                                           } \ } \ } \   } \    } \   } \   } \    } \   } \   } \   } \    } \      } \ 
O________________________________________I'/O\/O\__u'/O\____i'/O\++p'/O\___/O\_i'/O\__u'/O\___/O\_____i'/O\++p'/O\+++/O\+/O\_______/O\_i'/O\_________________________________________I'/O\_u'/O\++p'/O\____/O\___/O\_i'/O\_u'/O\/O\____i'/O\++u'/O\__u'/O\_________________________________________I'/O\_/O\+/O\+++/O\____/O\___/O\_i'/O\++p'/O\___/O\_i'/O\_u'/O\____/O\____i'/O\+++++++P'L

Provalo online!

OK, eccoci qui con buona fortuna, in realtà ._.
La prima caratteristica interessante di Fission è che ha 4 comandi per creare puntatori di comandi, atomi AKA:, RLDUquindi ho due comandi per i gruppi sinistro e destro.
Il secondo portafortuna sono 2 comandi per l'output !e O, che si verifica in diversi gruppi.
Terza volta il fascino. Entrambi i comandi in uscita producono l'equivalente ASCII della massa degli atomi. Quindi devo cambiarlo in qualche modo. Fortunato me! Sia + (+1 mass)e _ (-1 mass)sono in un gruppo e tutti necessari tre $ (+1 energy), ~ (-1 energy), @ (swap mass and energy)sono in un altro gruppo.

Inoltre ci sono specchi per controllare gli atomi in entrambi i gruppi! Ma non li ho usati nel primo programma

Quindi non c'è nulla che mi fermi, ma non può essere compatto, impostando le masse passo dopo passo.

Primo programma

Il primo programma è composto solo da Dz^@$~!V

D   create atom, going down
z   set its mass to ASCII code of 'z'
^   split atom in 2, dividing their mass. One goes left, second - right

L'inizio può essere più semplice (solo R), ma l'uso di divide salva alcuni byte per la prima lettera.
Atom, che va a sinistra si avvolge e incontra V, il che lo fa scendere e avvolgere indefinitamente, senza fare nulla.
Il secondo atomo diventa più rigoroso e incontrerà una serie di schemi ripetuti @...@!per ogni lettera in uscita.

@   swap atom's mass and energy
... increament or decrement energy until it would match desired ASCII code
@   swap again
!   print character by atoms mass

Alla fine incontrerà Ve condividerà il destino del primo atomo. Non c'è modo di distruggerli o fermarsi con la parte sinistra della tastiera.

Secondo programma

Il secondo arriva con i suoi alti e bassi. Ho dei comandi per cambiare direttamente la massa, ma il comando di output Odistrugge gli atomi, quindi devo preservarli in qualche modo.
Il programma inizia a destra Lcon atomo che va a sinistra.

Modello ripetuto:

} \
/O\...X'

'inserisce il codice ASCII del prossimo carattere rilevato nella massa degli atomi, quindi il codice di alcuni Xviene memorizzato per primo, quindi la massa viene modificata da _e +al valore esatto.
A volte X'viene saltato, se è più corto usare solo _e +.

L'atomo viene da sinistra, si specchia due volte e colpisce }da sinistra. In questo caso }funziona come un clonatore, inviando due atomi identici su e giù. L'atomo verso il basso si riflette dallo specchio e va a sinistra. L'atomo si avvolge, colpisce lo stesso specchio ma dal basso e quindi riflette bene, incontrando Oe stampando.
Alla fine l'ultimo atomo incontra il finale Oper essere distrutto.

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.