(Espero que ainda seja Ação de Graças para você)

Você tem um peru para o jantar de ação de graças, mas não sabe como distribuí-lo uniformemente. O problema é que algumas pessoas comem mais que outras, então você precisa encontrar uma solução

Entrada

Haverá duas entradas. O primeiro será uma arte ascii de várias pessoas.

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

especificações ascii-art

Cada pessoa ocupa uma largura de 3 colunas. Cada pessoa é separada por uma única coluna de espaços. O topo de cada pessoa é um o. Abaixo de o, deslocados por 1e -1no x, estão \e /, respectivamente. Da osegunda à última linha da entrada |, a quantidade dessas por pessoa é a sua "altura". Os únicos dados que você precisará extrair de cada pessoa são suas "alturas".

Sempre haverá pelo menos uma pessoa. Cada pessoa sempre tem pelo menos 2 alturas. A altura máxima que seu programa deve suportar é pelo menos uma altura de 64.

Se você deseja que a entrada seja preenchida com espaços para formar um retângulo, especifique isso na sua resposta.

A segunda entrada é a Turquia. O peru não é realmente um peru, mais de NxMdimensões de um peru. Se a segunda entrada for3x2 , o peru tem dimensões de 3 * 2, com uma área total de 6.

Resultado

A saída pode ser uma lista ou a alternativa mais próxima do seu idioma (por exemplo, Matriz). Você também pode gerar uma string, com os valores separados por espaços.

Os valores para cada pessoa devem ser exibidos na ordem em que foram inseridos.

Desafio

Seu objetivo é dividir a área da Turquia entre as pessoas.

Um cenário de exemplo:

Suponha que sejam duas pessoas, com alturas de 3e 6, respectivamente. Se houver um peru de 5x3. A área total do peru que precisará ser distribuída é de15 .

Agora, como você o distribuiria entre todos? Aqui está como:

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

Isso significa que, para a primeira pessoa com uma altura de 3, eles obterão 3/9*15peru ou 5a segunda pessoa com uma altura de que 6eles obterão 6/9*15ou 10peru.

Resultado

A saída deve consistir apenas de dígitos e ., a menos que você opte pelo bônus. Nesse caso, ele pode consistir apenas em dígitos, espaços ( ) e uma barra ( /).

Exemplo completo

Entrada:

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

Resultado:

11.25 18.75

Bónus

-20% Bônus: Você produz uma fração (deve ser simplificada), não importa se é uma fração mista ou imprópria.

Pontuação

Este é o código-golfe, pelo que o código mais curto em bytes vence!

Pitão, 23 bytes

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

Isso não funciona na versão online, porque usa eval para determinar o tamanho da Turquia.

Explicação:

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

Estou contando após o que eu propus no post meta, então não é fixo, mas sim, aqui vai.

entrada preenchida com espaços é esperada.

Estou contando cabeças e obtenha o tamanho das pessoas na linha em que elas estão.

Japonês , 49 46 bytes

Japt é uma versão abreviada do Ja vaScri pt . Intérprete

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

Saídas como uma matriz. (Observe que você precisará agrupar cada uma das duas entradas entre aspas.)

Como 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));

Portanto, esta é uma função do MATLAB que recebe duas entradas, a primeira é uma string para o tamanho da Turquia (por exemplo, '8x4' , e a segunda é a sequência que contém as pessoas. Ela retorna uma sequência contendo frações impróprias para cada pessoa.

Isso poderia ter sido muito menor, mas as novas linhas ficaram complicadas. O MATLAB poderia facilmente converter uma string ;como separador para cada linha, mas tentar usar uma nova linha mostrou-se difícil, custando 25 caracteres:

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

Obter o tamanho das pessoas é realmente muito fácil:

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

Isso pega todas as quarta colunas a partir da segunda (que serão todas as colunas onde estarão os corpos das pessoas) e depois as converte em uma matriz contendo 1's onde existem bits do corpo e 0's onde não existem. Finalmente, soma a coluna, o que resulta na matriz aque é uma matriz 1D contendo o tamanho de cada pessoa.

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

Em seguida, extraímos o tamanho do peru da string de entrada que está no formato %dx%d, ou seja, um número e depois 'x' e depois outro número. A matriz resultante de dois números é multiplicada para obter a área da Turquia.

Isso é multiplicado pela altura de cada um dos povos e também dividido pela altura total de todas as pessoas para obter a parte da Turquia de cada pessoa como um número decimal.

rats(...)

O passo final para qualificar o bônus - esse bit torna o código 6 caracteres mais longo, mas o bônus diminui ~ 22, então vale a pena. rats()é uma boa função que converte um número decimal em uma fração imprópria simplificada (com precisão de 13 dp). Alimentá-lo com uma matriz de números decimais (ou seja, a quantidade de cada pessoa) retornará uma única sequência contendo frações para cada pessoa, por sua vez, separadas por espaços.

A saída de rats()adiciona mais de um espaço, mas a pergunta não diz que não pode - apenas diz que a string deve conter apenas dígitos '' e '/'.

Esta é a saída do exemplo (aspas adicionadas por mim para impedir que espaços sejam removidos, não na saída real):

'     45/4          75/4     '

Exemplo de uso:

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

resultado:

'     45/4          75/4     '

Também funciona (embora com avisos) no intérprete online do Octave . Você pode tentar aqui . O link é para um espaço de trabalho com a ffunção já definida em um arquivo. Portanto, você poderá inserir o exemplo de uso acima no prompt.

Pitão - 25 bytes

Definitivamente pode jogar alguns bytes fora dele. Abordagem bastante direta.

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

Experimente online aqui .

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]

Exemplo 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)

Retorna uma matriz de partes.

Explicação

(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
  )

Teste

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'

Resultado: ['11.25', '18.75']