(Espero que todavía sea Acción de Gracias para ti)

Tienes un pavo para tu cena de acción de gracias, pero no sabes cómo distribuirlo de manera uniforme. El problema es que algunas personas comen más que otras, por lo que debe encontrar una solución

Entrada

Habrá dos entradas. El primero será un arte ascii de varias personas.

     o
 o  \|/
\|/  |
 |   |
/ \ / \

especificaciones de arte ascii

Cada persona ocupa un ancho de 3 columnas. Cada persona está separada por una sola columna de espacios. La parte superior de cada persona es un o. Debajo de o, desplazado por 1y -1en la x, están \y /, respectivamente. Desde la osegunda hasta la última fila en la entrada |, la cantidad de estos por persona es su "altura". Los únicos datos que necesitará extraer de cada persona es su "altura".

Siempre habrá al menos una persona. Cada persona siempre tiene al menos 2 alturas. La altura máxima que debe manejar su programa es al menos una altura de 64.

Si desea que la entrada se rellene con espacios para formar un rectángulo, especifique esto en su respuesta.

La segunda entrada es el pavo. El pavo no es realmente un pavo, sino más bien las NxMdimensiones de un pavo. Si la segunda entrada es 3x2, entonces el pavo tiene dimensiones de 3 * 2, con un área total de 6.

Salida

El resultado puede ser una lista o la alternativa más cercana a su idioma (por ejemplo, Array). También puede generar una cadena, con los valores separados por espacios.

Los valores para cada persona deben aparecer en el orden en que fueron ingresados.

Desafío

Su objetivo es dividir el área del pavo entre la gente.

Un ejemplo de escenario:

Supongamos que son dos personas, con alturas de 3y 6, respectivamente. Si hay un pavo de 5x3. El área total del pavo que deberá distribuirse es 15.

Ahora, ¿cómo lo distribuirías entre todos? Así es cómo:

                    the_persons_height
TurkeyForAPerson = -------------------- * turkey_area
                    sum_of_all_heights

Esto significa que, para la primera persona con una altura de 3, obtendrán 3/9*15pavo, o 5, la segunda persona con una altura de 6ellos obtendrán 6/9*15o 10pavo.

Salida

La salida debe consistir únicamente en dígitos y ., a menos que elija optar por la bonificación. En ese caso, solo puede consistir en dígitos, espacios ( ) y una barra inclinada ( /).

Ejemplo completo

Entrada:

6x5
     o 
     | 
 o  \|/
\|/  | 
 |   | 
 |   | 
/ \ / \

Salida:

11.25 18.75

Bonos

-20% de bonificación: genera una fracción (debe simplificarse), no importa si es una fracción mixta o impropia.

Puntuación

Este es el código de golf, ¡el código más corto en bytes gana!

Pyth, 23 bytes

mc*vXzG\*dsN=N-/R\|C.z0

Esto no funciona en la versión en línea, porque se usa evalpara determinar el tamaño del pavo.

Explicación:

mc*vXzG\*dsN=N-/R\|C.z0   implicit: z = first input line
                    .z    read all other lines
                   C      transpose them
               /R\|       count the "|"s in each column
              -       0   remove 0s in this list (columns with no "|"s)
            =N            assign the resulting list to N
m                         map each value d in N to:
    XzG\*                    replace every letter in z with a "*"
   v                         evaluate the result (does the multiplication)
  *      d                   multiply with d
 c        sN                 divide by sum(N)

LabVIEW, 67 Bytes

Estoy contando después de lo que propuse en la meta publicación, por lo que no está solucionado, pero sí, aquí va.

Se espera una entrada rellenada con espacios.

Estoy contando cabezas y obtengo el tamaño de las personas de la línea donde están las cabezas.

Japt , 49 46 bytes

Japt es una versión abreviada de Ja vaScri pt . Interprete

W=UqR y f@Y%4¥1 £Xq'| l -1)£Vq'x r@X*Y,1 *X/Wx

Salidas como una matriz. (Tenga en cuenta que deberá ajustar cada una de las dos entradas entre comillas).

Cómo funciona

            // Implicit: U = stick-figures, V = turkey size
W=UqR y     // Assign variable W to: split U at newlines, transpose rows with columns,
f@Y%4==1    // take each stick-figure body,
m@Xq'| l -1 // and count the number of "|"s.
)m@Vq'x     // Now map each item X in W to: V split at "x",
r@X*Y,1     // reduced by multiplication, starting at 1,
*X/Wx       // multiplied by X and divided by the total of W.
            // Implicit: output last expression

MATLAB 109 * 80% = 87.2 bytes

function o=f(t,p);p=char(strsplit(p,'\n'));a=sum(p(:,2:4:end)=='|');o=rats(prod(sscanf(t,'%dx%d'))*a/sum(a));

Entonces, esta es una función MATLAB que toma dos entradas, la primera es una cadena para el tamaño del pavo (por ejemplo '8x4', y la segunda es la cadena que contiene las personas. Devuelve una cadena que contiene fracciones impropias para cada persona.

Esto podría haber sido mucho más pequeño, pero las nuevas líneas se complicaron. MATLAB podría convertir fácilmente una cadena ;como separador para cada línea, pero tratar de usar una nueva línea resultó difícil, con un costo de 25 caracteres:

p=char(strsplit(p,'\n')); % Converts the input person string to a 2D array

Obtener el tamaño de las personas es bastante fácil:

a=sum(p(:,2:4:end)=='|');

Esto toma cada cuarta columna a partir de la segunda (que serán todas las columnas donde estarán los cuerpos de las personas), luego la convierte en una matriz que contiene 1 donde hay bits corporales y 0 donde no los hay. Finalmente, se resume en columnas, lo que da como resultado la matriz aque es una matriz 1D que contiene el tamaño de cada persona.

prod(sscanf(t,'%dx%d'))*a/sum(a)

A continuación, extraemos el tamaño del pavo de la cadena de entrada que está en la forma %dx%d, es decir, un número, luego 'x' y luego otro número. La matriz resultante de dos números se multiplica para obtener el área de Turquía.

Esto se multiplica por la altura de cada una de las personas, y también se divide por la altura total de todas las personas para obtener la porción de pavo para cada persona como un número decimal.

rats(...)

El último paso para calificar la bonificación: este bit hace que el código tenga 6 caracteres más, pero la bonificación elimina ~ 22, por lo que vale la pena. rats()es una buena función que convierte un número decimal en una fracción impropia simplificada (con precisión de 13 dp). Al alimentarlo con una matriz de números decimales (es decir, la cantidad para cada persona) devolverá una sola cadena que contiene fracciones para cada persona a su vez separadas por espacios.

Por supuesto, la salida de rats()agrega más de un espacio, pero la pregunta no dice que no puede, solo dice que la cadena debe contener solo dígitos '' y '/'.

Este es el resultado del ejemplo (comillas agregadas por mí para evitar que se eliminen espacios, no en el resultado real):

'     45/4          75/4     '

Ejemplo de uso:

f('6x5',['     o ' 10 '     | ' 10 ' o  \|/' 10 '\|/  | ' 10 ' |   | ' 10 ' |   | ' 10 '/ \ / \'])

salida:

'     45/4          75/4     '

También funciona (aunque con advertencias) en el intérprete de octava en línea . Puedes probarlo aquí . El enlace es a un espacio de trabajo con la ffunción definida en un archivo ya. Por lo tanto, debería poder ingresar el ejemplo de uso anterior en el indicador.

Pyth - 25 bytes

Definitivamente puede jugar un par de bytes. Enfoque bastante sencillo.

KfT/R\|C.z*R*FsMcz\xcRsKK

Pruébelo en línea aquí .

Haskell 119 bytes

import Data.List
g x=sum[1|y<-x,y>'{']
s#p|(h,_:t)<-span(<'x')s=[g x*read h*read t/g p|x<-transpose$lines p,any(>'{')x]

Ejemplo de uso: "6x5" # " o \n | \n o \\|/\n\\|/ | \n | | \n | | \n/ \\ / \\\n"-> [11.25,18.75].

JavaScript (ES6), 131 bytes

(t,p)=>eval(`h=[];for(s=0;m=r.exec(p);s++)h[i=m.index%l/4|0]=~~h[i]+1;h.map(v=>v/s*${t.replace("x","*")})`,l=p.search`
`+1,r=/\|/g)

Devuelve una matriz de porciones.

Explicación

(t,p)=>                      // t = turkey equation, p = ASCII art of people
  eval(`                     // use eval to enable for loop without {} or return
    h=[];                    // h = array of each person's height
    for(s=0;m=r.exec(p);s++) // for each match of "|", s = sum of all heights
      h[i=m.index%l/4|0]=    // i = person index of this match
        ~~h[i]+1;            // increment person's height (~~ casts undefined to 0)
    h.map(v=>v/s*            // divide each height by the sum and multiply by turkey area
      ${t.replace("x","*")}  // since this is inside an eval just convert t to an equation
    )`,                      // implicit: return array of each person's portion

    // These are executed BEFORE the eval (escaping characters would mean more bytes)
    l=p.search`
`+1,                         // l = line length
    r=/\|/g                  // r = regex to match height markers
  )

Prueba

var solution = (t,p)=>eval(`h=[];for(s=0;m=r.exec(p);s++)h[i=m.index%l/4|0]=~~h[i]+1;h.map(v=>v/s*${t.replace("x","*")})`,l=p.search`
`+1,r=/\|/g)

Turkey = <input type="text" id="turkey" value="6x5" /><br />
<textarea id="people" rows="8" cols="40">     o 
     | 
 o  \|/
\|/  | 
 |   | 
 |   | 
/ \ / \</textarea><br />
<button onclick="result.textContent=solution(turkey.value,people.value)">Go</button>
<pre id="result"></pre>

Python 99 bytes

lambda a,b: [`(''.join(i)).count('|')*1.0/a.count('|')*eval(b)` for i in zip(*a.split('\n'))[1::4]]

Entrada:' o \n | \n o \\|/\n\\|/ | \n | | \n | | \n/ \\ / \\','6*5'

Salida: ['11.25', '18.75']