Sigmafy la expresión


20

Para aquellos que no sabían, Sigma es una letra griega que se usa mucho en matemáticas como signo de suma. Dada una cadena que representa una expresión dependiendo de que denotaremos , calcule la suma de los resultados para , para cada . De manera concisa, debe encontrar tal que:E ( k ) E ( k ) k { 1 , 2 , 3 , 4 , 5 } SkE(k)E(k)k{1,2,3,4,5}S

S=k=15E(k)

Un ejemplo de una expresión:mi(k)=k2+k2


Especificaciones

  • Estás garantizado:
    • que la expresión es válida, por lo que no contiene errores, y que depende de la sintaxis elegida (por ejemplo: si solo admite 2*k, no habrá 2k)
    • que sólo han definido los valores entre sus resultados, por lo que no hay valores como 1/0, info nanaparecerá
  • Puede suponer que la expresión anterior se ajusta a los límites del lenguaje de programación de su elección, por lo que no provocará desbordamientos ni ningún otro error relacionado con el límite.
  • Se kpuede elegir cualquier otro carácter ASCII que no sea un espacio en blanco en lugar de
  • Su programa debe soportar las siguientes operaciones:
    • Además ( +, plus(), add(), sum())
    • resta ( -, minus(), subtract())
    • exponenciación ( **, ^, pow()o de otros, debe ser especificada), con apoyo a las bases negativas y exponentes
    • raíz cuadrada en forma de sqrt(k), k^0.5, k**0.5, o como otra cosa que desea
    • multiplicación y división
  • El envío puede ser un programa completo o una función, mientras menciona su uso
  • Cualquier espacio en blanco al final / al inicio está permitido al generar
  • Precisión mínima: 2 decimales

Casos de prueba (con k)

+---------------+--------------+   
|  Input = E(k) |    Output    |
|---------------+--------------|
|2*k            | 30           |
|---------------+--------------|
|sqrt(k)        | 8.38         | (* with minimum decimal precision)
|---------------+--------------|
|k+k/2+k**2     | 77.5         |
|---------------+--------------|
|k**2           | 55           |
+---------------+--------------+

La puntuación será el número de bytes (de las banderas fuente + compilador). La presentación válida con la puntuación más baja gana, mientras se toma nota de que estas lagunas están estrictamente prohibidas. Aquí hay un pseudocódigo de Python, para aclarar las cosas.


¿Podemos tomar en plus()lugar de +? (Las mismas preguntas para todos los demás operadores también)
Stewie Griffin

@StewieGriffin Sí, plus(), add(), sum()se permite y equivalentes. Ver la edición.
Sr. Xcoder

No, solo puede tomar la expresión una vez, @ComradeSparklePony
Sr. Xcoder

¿Podemos usar la notación postfix? Por ejemplo, casos de prueba 3 de la parte superior sería algo así como: N N2/+N2**+.
Camarada SparklePony

Eso es muy extraño, pero está permitido siempre que E(x)indique claramente el "formato" de @ComradeSparklePony
Sr. Xcoder

Respuestas:


3

Jalea , 5 bytes

vЀ5S

Pruébalo en línea!

Ingrese una cadena monádica Jelly válida (las golfé en mi enlace).

Cómo funciona

vЀ5S
 Ѐ     for each of ...
   5        5 (implicitly converted to [1,2,3,4,5]), ...
v           evaluate the input with the above as argument
    S   and find the sum

9

Mathematica, 17 14 13 bytes

Gracias a Ian Miller por guardar 3 bytes.

Gracias a LegionMammal978 por guardar 1 byte.

#~NSum~{k,5}&

La entrada debe ser una expresión real que contenga k, por ejemplo:

#~NSum~{k,5}&[Sqrt[k]^3+4]

2
Debería haber adivinado que Mathematica tenía incorporados para esto
Sr. Xcoder,

2
Mathematica siempre tiene incorporados para situaciones. : P
totalmente humano

No necesitas el 1,para eso Sum.
Ian Miller

De hecho, se puede acortar aN@#~Sum~{k,5}&
Ian Miller

@IanMiller Oh, claro, por supuesto. ¡Gracias!
Martin Ender


7

JavaScript (ES7), 31 30 bytes

Usos k**0.5para sqrt(k).

f=(e,k=6)=>--k&&f(e,k)+eval(e)

console.log(f("2*k"))
console.log(f("k**0.5"))
console.log(f("k+k/2+k**2"))
console.log(f("k**2"))

Pruébalo en línea!


Ninjaed otra vez! Bien hecho.
Shaggy

3

05AB1E , 8 7 6 bytes

6G¹.VO

Pruébalo en línea!

De entrada es en notación postfix, y utiliza la variable N . 05AB1E es un lenguaje basado en pila, por lo que solo funciona la notación postfix.

Formato de E(N): escriba los números con los que desea realizar la operación y luego escriba el signo de la operación. Por ejemplo, 3+4sería 3 4+, 3*4+2*3sería 3 4* 2 3* +. También tenga en cuenta que esto usa en tlugar de sqrt, y en mlugar de **, así sqrt(N)sería Nt.

Explicación:

6G¹.VO
6G     For N in range(1,6). This includes [1,2,3,4,5].
  ¹.V  Read and eval input.
     O Sum results.

3

Octava , 50 46 31 29 bytes

@(d)eval(["k=1:5;sum(" d 41])

Pruébalo en línea!

La exponenciación se denota con el símbolo de intercalación .^y la multiplicación se denota con .*.

Esto declara una función anónima que toma en argumento d. Establece kser igual al rango 1:5y suma lo evaluado dy lo devuelve.


3

Japt , 10 bytes

6ÆK=XOxUÃx

La cadena de entrada debe tener una variable en mayúscula K. sqrt(K)debe ingresarse como K**0.5.

Pruébalo en línea!

Explicación

evalel alcance no funcionó a mi favor; tuvo que redefinir la variable de conteo Xcomo global K.

6ÆK=XOxUÃx      // implicit: U = input string
6oXYZ{K=XOxU} x // expanded

6oXYZ{      }   // create array [0, 6) and map to function:
      K=X       //   redefine the array value to global K
         OxU    //   eval the input string
              x // sum the resulting array

Hmm, me pregunto si transpirar Oxdirectamente eval(ayudaría con eso ...
ETHproductions


2

APL (Dyalog) , 9 bytes

+/⍎⎕⊣k←⍳5

Pruébalo en línea!

La suma es +, la resta es -, la multiplicación es ×, la división es la ÷exponenciación *y la ejecución es de derecha a izquierda, así que use ()para agrupar expresiones.

La entrada es en términos de k.

Explicación

k←⍳5                    Set k to be equal to the vector 1 2 3 4 5
                       The left argument:
+/                      Sum of
⍎⎕                      The evaluated input (the eval returns an array because k is an array)

Y he aquí una solución que toma como entrada los trenes (como la respuesta Jelly): +/(⍎⎕)¨⍳5.


2

Lisp común, 55 bytes

(defun f(x)#.(read))(print(+(f 1)(f 2)(f 3)(f 4)(f 5)))

Pruébalo en línea

Example input - output: 
(* x 2) - 30 
(sqrt x) - 8.382333 
(+ (/ x 2) x (expt x 2)) - 155/2 
(expt x 2) - 55

versión diferente, más larga (58 bytes): comienza a acortarse si realiza la suma de 1 a 7.

(print #.`(+,@(mapcar #'(lambda(x)#.(read))'(1 2 3 4 5))))

otro método más largo ( 65 64 bytes), no define la función, simplemente inserta su expresión en un bucle. Debería acortarse para sumas más grandes.

(setf a(read)b 0)(loop as x from 1 to 5 do(incf b #.a))(print b)

2

Swift, 202 184 bytes

import Foundation;func s(i:String){print([1,2,3,4,5].map{NSExpression(format:i.replacingOccurrences(of:"k",with:"\($0).0")).expressionValue(with:nil,context:nil)as!Float}.reduce(0,+))}

Por alguna razón, esto solo se ejecutará localmente :(.

Aquí hay una explicación de lo que estoy haciendo:

import Foundation // Import the Foundation module

func s(i:String){ // Create a function that takes in a String and returns a Float

    print( // Print the result of the follow algorithm to strdout

        [1,2,3,4,5].map{ //Conduct the follow code on numbers 1 - 5

            NSExpression(format: // Create an expression with the following String and return it 

            i.replacingOccurrences(of:"k",with:"\($0).0")) // Create a string replacing all ocurrances of 'k' in `i` with the current Float from the map

           .expressionValue(with:nil,context:nil)as!Float // Get the resulting value of the expression

       }.reduce(0,+) // Add the result of all the expressions together
    )
}

Gracias a @Mr. ¡Xcoder para guardar 15 bytes!


2

TI-Basic, 12 bytes

Σ(expr(Ans),K,1,5

Llame con "string":prgmNAME, donde stringes cualquier expresión válida de TI-Basic de K.


Solución interesante de la misma duración:Ans->u:sum(u(1,5
lirtosiast

1

Apilado , 16 bytes

5~>[@k#~]2/"!sum

Pruébalo en línea!

5~>es un rango de 1 a 5 inclusive. 2/hace una función diádica, "es por pares y !se ejecuta. Esto mapea el rango [1, 5]con la entrada, que luego se evalúa después de definir el miembro del rango que será k. Luego, se resumen los resultados.


1

dc , 31 24 bytes

?sa1k[lax+Kd1+k5>p]dspxp

La entrada debe darse en notación polaca inversa (también conocida como notación postfix) y encerrada entre corchetes ( []) con:

  • Kreemplazando kcomo el parámetro;
  • + que representa la suma;
  • -representando resta y _seguido de cualquier número que represente un número negativo;
  • * representando multiplicación;
  • / división representativa;
  • ^ representando exponenciación;
  • v representando la raíz cuadrada.

Por ejemplo, -2*k+k+3*k**2+k**0.5-k/2sería ingresado como [_2K*K+K2^3*+Kv+K2/-]. Esto aprovecha el hecho de que Kes un dccomando que devuelve la precisión actual (inicialmente establecida en 1). Por lo tanto, al final, esto devuelve la salida con una precisión de 6.

Pruébalo en línea!



Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.