Este desafío es presentado por inspiración real (y trágica). Recientemente, la fila de números en mi teclado ha sido un poco esporádica. Las teclas 1-9funcionan a veces, pero otras veces no tienen resultado. Como un ávido programador, ¡esto es horrible! (¿Ves ese signo de exclamación? Así es como sabes que están funcionando en este momento). No solo a menudo necesito los números, sino también los símbolos!@#$%^&*(¡son completamente ineficaces la mitad del tiempo también! Como programador en C, en lugar de tomarme un tiempo libre de mi apretada agenda de garabatear código para arreglar mi laptop, he estado más interesado en solucionar el problema. En el transcurso de las últimas semanas, lentamente, todos los literales de números en mi código han sido reemplazados por hexadecimales para que no tenga que buscar números para copiar y pegar. Sin embargo, algunos números no son fáciles de escribir sin las teclas 1-9. Por ejemplo, el número 1no se puede escribir simplemente en hexadecimal, y he recurrido a reemplazar 1s en mi código con 0xF - 0xE. Las únicas teclas que se ven afectados son 1-9, por lo mantengo pleno uso de símbolos como +, -, y /. Sin embargo, no puedo usar multiplicación o paréntesis, como*y a (menudo se rompen. Esto lleva a tu desafío.

Entrada

Un número entero, nstdin o el equivalente de su idioma. Si lo desea, el entero puede ir precedido o seguido de una nueva línea u otro carácter de espacio en blanco. Alternativamente, puede recibir información a través de un argumento de línea de comando.

Su programa debe responder correctamente a la entrada negativa y ser capaz de manejar al menos enteros con signo de 32 bits.

Salida

Su programa debería generar, de alguna forma observable, la forma más corta posible (en caracteres que no sean espacios en blanco) de escribir el número ncomo una suma, diferencia o división de uno o más valores hexadecimales. Hay más de una forma de resolver este problema, y ​​no es necesario que favorezca cualquier salida de igual longitud sobre cualquier otra.

La salida debe estar en la forma A % A % A...donde Aes un valor hexadecimal siguiente que 0xcontiene solo dígitos A-F a-f, y %es uno de los símbolos -+/. Vamos a /describir la división entera, no el punto flotante.

(Tenga en cuenta que su resultado debería resultar nal evaluar las divisiones primero, de izquierda a derecha, y luego sumas y restas, de izquierda a derecha, como es la convención).

Casos de prueba

De entrada y salida

1. 1

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

2. 15

   0xF

3. 255

   0xFF

4. 30

   0xF + 0xF

Puntaje y Reglas

Este es el código de golf. Su puntaje preliminar es el número de bytes en su archivo fuente.

NO puede usar ninguno de los dígitos 1-9en su fuente.

PUEDE usar símbolos !@#$%^&*(en su fuente, pero cada uno tiene una penalización de +20 a su puntaje.

Su programa puede ser reemplazado por una función que tome ncomo argumento siempre que esa función produzca algún tipo de salida legible por humanos. El valor de retorno de su función NO cuenta como salida.

Las lagunas estándar no están permitidas.

¡La puntuación más baja gana! ¡Buena suerte!

¿Me equivoqué con el formato / cuestionamiento / claridad? ¡Házmelo saber! ¡Esta es mi primera presentación a este sitio!

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

Una función que verifica todas las combinaciones posibles de los 6 dígitos hexadecimales permitidos (0xA a 0xF) y los 3 operadores permitidos. Salida a través de una ventana emergente y no devuelve un valor, según lo solicitado.

Solía ​​[] agrupar expresiones separadas por comas, pero no podía evitar los 5 7 corchetes abiertos para bucles y llamadas a funciones.
Para evitar dígitos hay variables A, B, C para 1,2,3 (esto hace que el código sea aún más oscuro)

Editar código revisado enfocándose en evitar '('. Eliminado ifsy creación explícita de RegExp

Cuidado: esta función es increíblemente lenta, excederá el límite de tiempo para un script en Firefox, incluso para entradas pequeñas como 90.

Para enumerar todas las expresiones posibles, uso un número que comienza en 3 y sube para siempre. Codificación de dígitos:
0,1,2 son los operadores +, -, /
4 a 9 son los dígitos hexadecimales A..F
3 no está permitido
Cada número se verifica con una expresión regular /3|[0-2]{2}/para evitar el dígito 3 y tener 2 operadores consecutivos (el comprobar también evitar operadores de arrastre y líderes - ver código)

La cadena resultante es algo así como 0xA + 0xA - 0xDJavaScript válido, por lo que uso eval para evaluarlo. Desafortunadamente, el operador '/' es de coma flotante y no es entero en JavaScript, por lo que no estoy 100% seguro de que el resultado sea un evento correcto para enterar el resultado final (pero estoy bastante seguro, dado que un pequeño error de redondeo no puede ser amplificado por 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)
}

Algo más

Ahora, algo más divertido. Utilicé un analizador de expresiones excesivamente simplificado para evitar la llamada de evaluación y, divertida, resultó ser mucho más rápido.

El analizador está realmente simplificado, en un analizador real V y O deben ser matrices que contengan la pila de valores pendientes y la pila de operadores pendientes. Aquí V es el único valor pendiente (y también el valor de retorno) y O es una cadena con un máximo de 2 caracteres. P contiene la tabla de precedencia de operadores, para '- + /' => '112'

Esto puntúa 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)
}

Prueba En la consola Firefox / FireBug, cambie la alerta con retorno (mucho más utilizable)

;[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 poco menos obvio (pero sea paciente)

;[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 bytes + 2 * 20 = 225

Demasiado tiempo para una respuesta seria. Pero como todavía no hay respuestas, lo publicaré de todos modos.

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 todos los arreglos diferentes de los caracteres permitidos. execintenta descifrarlo. Lamentablemente, esto devuelve una excepción, de ahí el largo try - catchbloque. Si el resultado está bien, se imprime y existe.

2 veces de penalización, debido a esas llaves durante las llamadas a funciones.