Dada una cadena con datos de inversión de varias personas, averigüe cuánta ganancia / pérdida registraron.

La cadena solo contiene letras mayúsculas y minúsculas, como esta:

AABaBbba

Cada letra representa a una persona: una letra mayúscula significa comprar, una letra minúscula significa vender. El precio de las acciones en las que están invirtiendo (CGLF) comienza en $ 50. Después de que alguien compra, el precio sube un 5%. Después de que alguien vende, el precio baja un 5%. Necesita calcular cuánto dinero ganó / perdió cada persona que participó.

Notas:

• La cadena siempre será válida, no se venderá sin comprar primero. Además, todos los que compren una acción la venderán eventualmente.
• Sus cálculos deben tener una precisión de al menos 6 decimales. Sin embargo, las respuestas finales deben redondearse a dos decimales.

Casos de prueba:

Entrada: AABaBbba

• A: Comprar - $ 50
• A: Comprar - $ 52.50
• B: Comprar - $ 55.125
• a: Venta - $ 57.88125
• B: Comprar - $ 54.9871875
• b: Venta - $ 57.736546875
• b: Venta - $ 54.8497195313
• a: Venta - $ 52.1072335547

• 57.88125+52.1072335547-50-52.50=Beneficio de la persona A: 7.4884835547
• 57.736546875+54.8497195313-55.125-54.9871875=Beneficio de persona B: 2.4740789063

Salida: A:7.49,B:2.47 (el orden no importa, no se requieren separadores)

Entrada: DGdg

• D: Comprar - $ 50
• G: Comprar - $ 52.50
• d: Venta - $ 55.125
• g: Venta - $ 52.36875

• 55.125-50=Beneficio de la persona D: 5.125
• 52.36875-52.50=Beneficio de la persona G: -0.13125

Salida: D:5.13,G:-.13

Entrada: ADJdja

• A: Comprar - $ 50
• D: Comprar - $ 52.50
• J: Comprar - $ 55.125
• d: Venta - $ 57.88125
• j: Venta - $ 54.9871875
• a: Venta - $ 52.237828125

• 52.237828125-50=Beneficio de persona A: 2.237828125
• 57.88125-52.50=Beneficio de la persona D: 5.38125
• Persona J beneficio: 54.9871875-55.125=-0.1378125

Salida: A:2.24,D:5.38,J:-.14

Japt, 91 84 bytes

A=[]J=50¡AhD=Xc %H(X<'_?[AgD ª0 -JJ*=1.05]:[AgD +JJ*=.95] g};A£X©[Y+I d X*L r /L]} f

Basado en mi respuesta JS. Pruébalo en línea!

Java, 277 bytes

class c{public static void main(String[]a){double[]m=new double[26];double s=50;for(byte b:a[0].getBytes()){if(b>=97){m[b-97]+=s;s*=.95;}else{m[b-65]-=s;s*=1.05;}}char g=65;for(double k:m){if(k!=0){System.out.println(g+String.format(java.util.Locale.ENGLISH,"%.2f",k));}g++;}}}

Sin golf:

class c {
    public static void main(String[]a) {
        double[] m = new double[26];
        double s = 50;
        for(byte b : a[0].getBytes()) {
            if(b>=97) {
                m[b-97]+=s;  
                s*=.95;
            } else {
                m[b-65]-=s;
                s*=1.05;
            }
        }
        char g=65;
        for(double k:m) {
            if(k!=0) {
                System.out.println(g+String.format(java.util.Locale.ENGLISH,"%.2f",k));
            }
            g++;
        }
    }
}

JavaScript (ES7), 145 142 bytes

No puedo encontrar una forma más corta de redondear los resultados ...

x=>[for(c of(i=50,a={},x))(a[d=c.toUpperCase()]=a[d]||0,c<"["?(a[d]-=i,i*=1.05):(a[d]+=i,i*=.95))]&&Object.keys(a).map(k=>[k,a[k].toFixed(2)])

Dato curioso: esto solo sería de 101 bytes si no fuera por el requisito de redondeo:

x=>[for(c of(i=50,a={},x))(a[d=c.toUpperCase()]=a[d]||0,c<"["?(a[d]-=i,i*=1.05):(a[d]+=i,i*=.95))]&&a

Python 3, 116 bytes

P=50
M={}
for c in input():C=c.upper();u=c>C;u+=~-u;M[C]=M.get(C,0)+P*u;P*=1-u*.05
for k in M:print(k,round(M[k],2))

Sin golf

price = 50
profits = {}
for char in input():
    upper = char.upper()
    direction = 2 * (char > upper) - 1
    profits[upper] = profits.get(upper, 0) + price * direction
    price *= 1 - direction * .05
for key in profits:
    print(key, round(profits[key], 2))