(J'espère que c'est toujours Thanksgiving pour vous)

Vous avez obtenu une dinde pour votre dîner d'action de grâces mais vous ne savez pas comment la distribuer uniformément. Le problème est que certaines personnes mangent plus que d'autres, vous devez donc trouver une solution

Contribution

Il y aura deux entrées. Le premier sera un art ascii de diverses personnes.

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

Spécifications ascii-art

Chaque personne occupe une largeur de 3 colonnes. Chaque personne est séparée par une seule colonne d'espaces. Le sommet de chaque personne est un o. Ci - dessous la o, compensée par 1et -1dans le x, sont \et /, respectivement. De l' oavant-dernière à la dernière ligne de l'entrée |, le montant de ces derniers par personne est leur "taille". Les seules données que vous devrez extraire de chaque personne sont leur "taille".

Il y aura toujours au moins une personne. Chaque personne a toujours au moins 2 hauteurs. La hauteur maximale que votre programme doit gérer est d'au moins 64.

Si vous souhaitez que l'entrée remplie d'espaces forme un rectangle, veuillez le préciser dans votre réponse.

La deuxième entrée est la dinde. La dinde n'est pas vraiment une dinde, plus des NxMdimensions d'une dinde. Si la deuxième entrée est 3x2, alors la dinde a des dimensions de 3 * 2, avec une superficie totale de 6.

Production

La sortie peut être une liste ou l'alternative la plus proche de votre langue (par exemple Array). Vous pouvez également produire une chaîne, avec les valeurs séparées par des espaces.

Les valeurs pour chaque personne doivent être sorties dans l'ordre dans lequel elles ont été entrées.

Défi

Votre objectif est de diviser la zone de la dinde entre les gens.

Un exemple de scénario:

Supposons qu'ils soient deux personnes, avec des hauteurs de 3et 6, respectivement. S'il y a une dinde de 5x3. La superficie totale de la dinde qui devra être distribuée est de 15.

Maintenant, comment le répartiriez-vous entre tous? Voici comment:

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

Cela signifie que pour la première personne avec une hauteur de 3, ils obtiendront de la 3/9*15dinde, ou 5, la deuxième personne avec une hauteur de 6ils obtiendront 6/9*15ou de la 10dinde.

Production

La sortie doit uniquement être composée de chiffres et ., à moins que vous ne choisissiez de choisir le bonus. Dans ce cas, il ne peut être composé que de chiffres, d'espaces ( ) et d'une barre oblique ( /).

Exemple complet

Contribution:

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

Production:

11.25 18.75

Bonus

-20% Bonus: Vous sortez une fraction (doit être simplifiée), peu importe si c'est une fraction mixte ou incorrecte.

Notation

C'est le code-golf donc le code le plus court en octets gagne!

Pyth, 23 octets

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

Cela ne fonctionne pas dans la version en ligne, car il permet evalde déterminer la taille de la dinde.

Explication:

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 octets

Je compte après ce que j'ai proposé dans le meta post, donc ce n'est pas fixe, mais oui, c'est parti.

une entrée remplie d'espaces est attendue.

Je compte les têtes et j'obtiens la taille des gens de la ligne où se trouvent les têtes.

Japt , 49 46 octets

Japt est une version abrégée de Ja vaScri pt . Interprète

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

Sorties sous forme de tableau. (Notez que vous devrez mettre chacune des deux entrées entre guillemets.)

Comment ça fonctionne

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

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

Il s'agit donc d'une fonction MATLAB qui prend deux entrées, la première est une chaîne pour la taille de la dinde (par exemple '8x4', et la seconde est la chaîne contenant les personnes. Elle renvoie une chaîne contenant des fractions impropres pour chaque personne.

Cela aurait pu être beaucoup plus petit, mais les nouvelles lignes sont devenues délicates. MATLAB pouvait facilement convertir une chaîne avec ;comme séparateur pour chaque ligne, mais essayer d'utiliser une nouvelle ligne s'est avéré difficile, coûtant 25 caractères:

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

Obtenir la taille des personnes est en fait assez simple:

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

Cela prend toutes les quatre colonnes à partir de la seconde (qui sera toutes les colonnes où se trouvent les corps des personnes), puis les convertit en un tableau contenant des 1 où il y a des bits de corps et des 0 où il n'y en a pas. Enfin, il résume les colonnes, ce qui donne le tableau aqui est un tableau 1D contenant la taille de chaque personne.

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

Ensuite, nous extrayons la taille de la dinde de la chaîne d'entrée qui est sous la forme %dx%d, c'est-à-dire un nombre puis 'x' puis un autre nombre. Le tableau résultant de deux nombres est multiplié pour obtenir la superficie de la dinde.

Ceci est multiplié par la hauteur de chacun des peuples, et également divisé par la hauteur totale de toutes les personnes pour obtenir la portion de dinde pour chaque personne sous forme de nombre décimal.

rats(...)

La dernière étape pour qualifier le bonus - ce bit rallonge le code de 6 caractères, mais le bonus fait tomber ~ 22, donc ça vaut le coup. rats()est une fonction intéressante qui convertit un nombre décimal en une fraction impropre simplifiée (précise à 13 dp). En lui fournissant un tableau de nombres décimaux (c'est-à-dire le montant pour chaque personne), une seule chaîne contenant des fractions pour chaque personne sera à son tour séparée par des espaces.

Accordé la sortie de rats()ajoute plus d'un espace, mais la question ne dit pas qu'il ne peut pas - dit simplement que la chaîne ne doit contenir que des chiffres, '' et '/'.

Voici la sortie de l'exemple (les guillemets ajoutés par moi pour empêcher la suppression des espaces, pas dans la sortie réelle):

'     45/4          75/4     '

Exemple d'utilisation:

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

production:

'     45/4          75/4     '

Il fonctionne également (bien qu'avec des avertissements) sur l' interpréteur d' Octave en ligne . Vous pouvez l'essayer ici . Le lien est vers un espace de travail avec la ffonction déjà définie dans un fichier. Vous devriez donc pouvoir simplement saisir l'exemple d'utilisation ci-dessus à l'invite.

Pyth - 25 octets

Peut certainement jouer au golf à quelques octets. Approche assez simple.

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

Essayez-le en ligne ici .

Haskell 119 octets

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]

Exemple d'utilisation: "6x5" # " o \n | \n o \\|/\n\\|/ | \n | | \n | | \n/ \\ / \\\n"-> [11.25,18.75].

JavaScript (ES6), 131 octets

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

Renvoie un tableau de portions.

Explication

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

Tester

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 octets

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

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

Production: ['11.25', '18.75']