(Spero che sia ancora il Ringraziamento per te)

Hai un tacchino per la cena del Ringraziamento ma non sai come distribuirlo uniformemente. Il problema è che alcune persone mangiano più di altre, quindi è necessario trovare una soluzione

Ingresso

Ci saranno due ingressi. Il primo sarà un'arte ascii di varie persone.

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

specifiche ascii-art

Ogni persona occupa una larghezza di 3 colonne. Ogni persona è separata da una singola colonna di spazi. Il massimo di ogni persona è un o. Al di sotto di o, offset di 1e -1in x, sono \e /, rispettivamente. Dalla oseconda all'ultima riga nell'input sono |, la quantità di questi per persona è la loro "altezza". Gli unici dati che dovrai estrarre da ogni persona sono la loro "altezza".

Ci sarà sempre almeno una persona. Ogni persona ha sempre almeno 2 altezze. L'altezza massima che il programma deve gestire è almeno un'altezza di 64.

Se desideri che l'ingresso riempito di spazi formi un rettangolo, specifica questo nella tua risposta.

Il secondo input è il tacchino. Il tacchino non è in realtà un tacchino, più delle NxMdimensioni di un tacchino. Se il secondo input è 3x2, allora il tacchino ha dimensioni di 3 * 2, con un'area totale di 6.

Produzione

L'output può essere un elenco o l'alternativa più vicina alla tua lingua (ad es. Array). È inoltre possibile generare una stringa, con i valori separati da spazi.

I valori per ogni persona dovrebbero essere emessi nell'ordine in cui sono stati inseriti.

Sfida

Il tuo obiettivo è quello di dividere l'area del tacchino tra le persone.

Uno scenario di esempio:

Supponiamo che siano due persone, rispettivamente con altezze di 3e 6. Se c'è un tacchino di 5x3. L'area totale del tacchino che dovrà essere distribuita è 15.

Ora come lo distribuiresti a tutti? Ecco come:

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

Ciò significa che per la prima persona con un'altezza di 3, otterranno la 3/9*15Turchia, o 5, la seconda persona con un'altezza di 6avranno 6/9*15o la 10Turchia.

Produzione

L'output deve essere costituito esclusivamente da cifre e ., a meno che tu non scelga di scegliere il bonus. In tal caso, può consistere solo di cifre, spazi ( ) e una barra ( /).

Esempio completo

Ingresso:

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

Produzione:

11.25 18.75

bonus

-20% di bonus: ottieni una frazione (deve essere semplificata), non importa se si tratta di una frazione mista o impropria.

punteggio

Questo è code-golf quindi vince il codice più breve in byte!

Pyth, 23 byte

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

Questo non funziona nella versione online, perché viene utilizzato evalper determinare la dimensione del tacchino.

Spiegazione:

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 byte

Sto contando ciò che ho proposto nel meta post, quindi non è stato risolto, ma sì, ecco.

è previsto un input riempito di spazi.

Sto contando le teste e ottengo le dimensioni delle persone dalla linea in cui si trovano le teste.

Japt , 49 46 byte

Japt è una versione abbreviata di Ja vaScri pt . Interprete

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

Output come un array. (Si noti che sarà necessario racchiudere tra i due input tra virgolette.)

Come funziona

            // 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 byte

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

Quindi questa è una funzione MATLAB che accetta due input, il primo è una stringa per la dimensione del tacchino (ad esempio '8x4', e la seconda è la stringa che contiene le persone. Restituisce una stringa contenente frazioni improprie per ogni persona.

Questo avrebbe potuto essere molto più piccolo, ma le nuove linee sono diventate complicate. MATLAB potrebbe facilmente convertire una stringa con ;come separatore per ogni riga, ma provare ad usare una nuova riga si è rivelato difficile, costando 25 caratteri:

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

Ottenere le dimensioni delle persone è in realtà abbastanza semplice:

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

Questo prende ogni quarta colonna a partire dalla seconda (che sarà tutte le colonne in cui saranno i corpi delle persone), quindi la converte in un array contenente 1 dove sono presenti bit di body e 0 dove non ci sono. Infine riassume la colonna che risulta nella matrice ache è una matrice 1D contenente le dimensioni di ogni persona.

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

Quindi estraiamo la dimensione del tacchino dalla stringa di input che è nella forma %dx%d, ovvero un numero quindi 'x' quindi un altro numero. L'array risultante di due numeri viene moltiplicato insieme per ottenere l'area del tacchino.

Questo è moltiplicato per l'altezza di ciascuna delle persone e anche diviso per l'altezza totale di tutte le persone per ottenere la porzione di tacchino per ogni persona come un numero decimale.

rats(...)

L'ultimo passo per qualificare il bonus: questo bit allunga il codice di 6 caratteri, ma il bonus termina ~ 22 quindi ne vale la pena. rats()è una bella funzione che converte un numero decimale in una frazione impropria semplificata (precisa a 13 dp). Inserendolo in una matrice di numeri decimali (ovvero la quantità per ogni persona) restituirà una singola stringa contenente frazioni per ogni persona a sua volta separate da spazi.

Concesso l'output di rats()aggiunge più di uno spazio, ma la domanda non dice che non può - dice solo che la stringa deve contenere solo cifre, "" e "/".

Questo è l'output dell'esempio (virgolette aggiunte da me per impedire la rimozione di spazi, non nell'output effettivo):

'     45/4          75/4     '

Esempio di utilizzo:

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

produzione:

'     45/4          75/4     '

Funziona anche (anche se con avvertimenti) sull'interprete Octave online . Puoi provarlo qui . Il collegamento è a un'area di lavoro con la ffunzione già definita in un file. Quindi dovresti essere in grado di inserire semplicemente l'esempio di utilizzo sopra al prompt.

Pyth - 25 byte

Può sicuramente giocare a golf a un paio di byte da esso. Approccio piuttosto diretto.

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

Provalo online qui .

Haskell 119 byte

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]

Esempio di utilizzo: "6x5" # " o \n | \n o \\|/\n\\|/ | \n | | \n | | \n/ \\ / \\\n"-> [11.25,18.75].

JavaScript (ES6), 131 byte

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

Restituisce una matrice di porzioni.

Spiegazione

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

Test

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 byte

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

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

Produzione: ['11.25', '18.75']