Questa sfida ti è stata data dalla vera (e tragica) ispirazione. Recentemente, la riga dei numeri sulla mia tastiera è stata un po 'sporadica. Le chiavi 1-9funzionano a volte, ma altre volte non hanno alcun risultato. Come appassionato programmatore, questo è orribile! (Vedi quel punto esclamativo? È così che sai che funzionano in questo momento.) Non solo ho spesso bisogno dei numeri stessi, ma dei simboli!@#$%^&*(sono completamente inefficaci anche la metà delle volte! Come programmatore C, piuttosto che prendermi del tempo libero dal mio fitto programma di scarabocchiare con il codice per riparare il mio laptop, sono stato più interessato a risolvere il problema. Nel corso delle ultime settimane, lentamente, tutti i letterali numerici nel mio codice sono stati sostituiti con esadecimali in modo da non dover andare in giro alla ricerca di numeri da copiare e incollare. Tuttavia, alcuni numeri non sono facili da digitare senza i tasti 1-9. Ad esempio, il numero 1non può essere scritto così semplicemente in esadecimale, e ho fatto ricorso alla sostituzione di 1s nel mio codice con 0xF - 0xE. Gli unici tasti che vengono colpiti sono 1-9, quindi io sostengo pieno uso di simboli come +, -e /. Tuttavia, non posso usare la moltiplicazione o le parentesi, come*e (sono spesso rotti. Questo porta alla tua sfida.

Ingresso

Un numero intero, na stdin o equivalente della tua lingua. Se lo desideri, l'intero può essere preceduto o seguito da una nuova riga o da un altro carattere di spazio bianco. In alternativa, è possibile ricevere input tramite un argomento della riga di comando.

Il programma dovrebbe rispondere correttamente all'input negativo ed essere in grado di gestire numeri interi con segno a 32 bit.

Produzione

Il tuo programma dovrebbe generare, in una forma osservabile, il modo più breve (in caratteri non bianchi) di scrivere il numero ncome somma, differenza o divisione di uno o più valori esadecimali. Esiste più di un modo per risolvere questo problema e non è necessario che si favorisca un output di uguale lunghezza rispetto a qualsiasi altro.

L'output deve essere nella forma in A % A % A...cui Aè presente un valore esadecimale che 0xcontiene solo cifre A-F a-fed %è uno dei simboli -+/. Puoi /descrivere integer divisione, non virgola mobile.

(Si noti che l'output dovrebbe risultare nquando si valutano prima le divisioni, da sinistra a destra, quindi le aggiunte e le sottrazioni, da sinistra a destra, come per convenzione.)

Casi test

Input Output

1. 1

   0xF - 0xE(o 0xF-0xEo 0xB-0xAo 0xd - 0xco 0xF/0xF)

2. 15

   0xF

3. 255

   0xFF

4. 30

   0xF + 0xF

Punteggio e regole

Questo è code-golf. Il tuo punteggio preliminare è il numero di byte nel tuo file sorgente.

NON puoi usare nessuna delle cifre 1-9nella tua fonte.

PUOI usare simboli !@#$%^&*(nella tua fonte, ma ognuno arriva ad una penalità di +20 al tuo punteggio.

Il programma può essere sostituito da una funzione che accetta ncome argomento purché tale funzione produca una forma di output leggibile dall'uomo. Il valore restituito dalla funzione NON viene conteggiato come output.

Non sono ammesse scappatoie standard .

Il punteggio più basso vince! In bocca al lupo!

Ho fatto qualcosa di formattazione / domande / chiarezza? Fammi sapere! Questa è la mia prima presentazione a questo sito!

JavaScript 287 (187 + 20 * 5) 295 (195 + 20 * 5) 338 (198 + 20 * 7)

Una funzione che controlla tutte le possibili combinazioni delle 6 cifre esadecimali consentite (da 0xA a 0xF) e dei 3 operatori consentiti. Output tramite popup e non restituire un valore, come richiesto.

Ho usato [] per raggruppare espressioni separate da virgola, ma non ho potuto evitare 5 7 parentesi aperte per loop e chiamate di funzioni.
Per evitare le cifre ci sono variabili A, B, C per 1,2,3 (questo rende il codice ancora più oscuro)

Modifica il codice rivisto concentrandosi sull'evitare "(". Rimossa ifla creazione esplicita di RegExp

Attenzione: questa funzione è incredibilmente lenta, supererà il limite di tempo per uno script in FireFox, anche per piccoli input come 90.

Per enumerare tutta l'espressione possibile, uso il numero che inizia da 3 e sale per sempre. Codifica delle cifre:
0,1,2 sono gli operatori +, -, / da
4 a 9 sono le cifre esadecimali A..F
3 non consentite
Ogni numero viene controllato con una regexp /3|[0-2]{2}/per evitare la cifra 3 e avere 2 operatori consecutivi (il controlla anche evitare traling e operatori principali - vedi codice)

La stringa risultante è qualcosa del genere 0xA + 0xA - 0xDè javascript valido, quindi uso eval per valutarlo. Sfortunatamente l'operatore '/' è a virgola mobile e non intero in JavaScript, quindi non sono sicuro al 100% che il risultato sia il cast dell'evento corretto per intero il risultato finale (ma sono abbastanza fiducioso, dato che un piccolo errore di arrotondamento non può essere amplificato da un '*')

F=x=>{
  for(A=-~0,B=A+A,i=C=A+B,j=0;j?x-~~eval(L):A;)
  {
    j=++i+'0',k=0+j;
    for(c of~k.search(C+'|[0-'+B+']{'+B+'}',L='',w='0x')?j='':j)
      c>C?w+=' ABCDEF'[c-C]:[L+=w,w=' '+'+-/'[c]+' 0x']
  }
  alert(L)
}

Qualcos'altro

Ora, qualcosa di più divertente. Ho usato un parser expressione semplificato per evitare la chiamata eval e, in modo divertente, si è rivelato molto più veloce.

Il parser è davvero semplificato, in un vero parser V e O dovrebbero essere array contenenti lo stack dei valori in sospeso e lo stack degli operatori in sospeso. Qui V è il singolo valore in sospeso (e anche il valore restituito) e O è una stringa con al massimo 2 caratteri. P contiene la tabella di precedenza degli operatori, per '- + /' => '112'

Questo vale 275 + 4 * 20 => 355

F=x=>{
  for(A=-~0,B=A+A,i=C=A+B,D=A+C,j=0,P=''+A+A+B;j?x-V:A;)
  {
    j=++i+'0',k=0+j;
    for(c of~k.search(C+'|[0-'+B+']{'+B+'}',v=V=O=L='',w='0x')?j='':j)
      c>C?
        w+='ABCDEF'[v<<=D,v+=D+A-~c,c-D]
      :[
          P[O[0]]>=P[c]?[v=O>A?V/v|0:O>0?V+v:V-v,O=c]:O=c+O,
          L+=w,w=' '+'-+/'[c]+' 0x',V=v,v=0
      ]
  }
  alert(L)
}

Test Nella console di Firefox / FireBug, cambia avviso con ritorno (molto più utilizzabile)

;[0, 1, 15, 255, 30].forEach(x=>console.log(x,F(x)))

0 0xA - 0xA
1 0xA / 0xA
15 0xF
255 0xFF
30 0xF + ​​0xF

Solo un po 'meno ovvio (ma sii paziente)

;[16,40, 51, 62, 73, 84, 95].forEach(x=>console.log(x,F(x)))

16 0xBA / 0xB
40 0xA + 0xF + ​​0xF
51 0xDD - 0xAA
62 0xEA - 0xAC
73 0xA + 0xEA - 0xAB
84 0xFE - 0xAA
95 0xA + 0xFF - 0xAA

Python 2: 185 byte + 2 * 20 = 225

Troppo a lungo per una risposta seria. Ma poiché non ci sono ancora risposte, lo posterò comunque.

from itertools import product as p
n=input()
l=t=0
while~l:
 l=-~l
 for i in p("0xABCDEF+-/",repeat=l):
  j=""
  for k in i:j+=k
  try:exec"t="+j
  except:0
  if t==n:print j;l=~0;break

productcrea tutte le diverse disposizioni dei caratteri consentiti. execprova a decodificarlo. Questo purtroppo restituisce un'eccezione, quindi il lungo try - catchblocco. Il risultato va bene, stampa ed esiste.

Penalità di 2 volte, a causa di quelle parentesi graffe durante le chiamate di funzione.