De combien d'elfes le Père Noël a-t-il besoin pour offrir des cadeaux?

23

Le Père Noël a besoin d'aide pour déterminer le nombre d'elfes dont il aura besoin pour l'aider à offrir des cadeaux à chaque maison.

Le charbon est considérablement plus lourd que les cadeaux, donc le père Noël aura besoin de trois elfes pour chaque vilain dans la maison. Seuls deux elfes sont nécessaires pour aider le père Noël à porter des cadeaux.

Sur la carte du père Noël, une maison est représentée par un *, et chaque maison est divisée par un +.

Il y aura un numéro de chaque côté de la maison - celui de gauche représentant le nombre de vilains dans la maison, et celui de droite représentant le nombre de gentilles personnes dans la maison. S'il n'y a pas de nombre d'un côté, il est interprété comme un 0.

Le Père Noël ne rend pas visite à ceux qui ne sont pas dans l'esprit de Noël (ils ne méritent même pas le charbon), donc parfois, une maison peut ne pas avoir de numéro de chaque côté. Dans ce cas, le père Noël n'a besoin de l'aide d'aucun elfe

Par exemple, l'une des cartes du père Noël peut ressembler à ceci

1*3+2*2+1*+*2

Dans la première maison il y a 1 coquine et 3 gentilles, le père Noël aura besoin de neuf elfes. Dans le second, il y a 2 coquines et 2 gentilles, le père Noël aura besoin de dix elfes. Dans la troisième maison il y a 1 vilain et 0 gentil, le père Noël aura besoin de trois elfes, et dans la dernière maison il y a 0 vilain et 2 gentil, le père Noël aura besoin de quatre elfes.

Il s'agit cependant d'une version trop simplifiée d'une des cartes du père Noël. Normalement, les cartes du père Noël ont plusieurs lignes et sont de forme carrée pour mieux correspondre à sa liste. Une carte normale pourrait ressembler à ceci (un \nà la fin de chaque ligne)

1*2+*+*4+1*
2*4+3*+1*6+*
*+*+4*2+1*1
*4+*3+1*+2*3
3*10+2*+*5+*

Sur cette carte, le père a besoin ((1 + 0 + 0 + 1 + 2 + 3 + 1 + 0 + 0 + 0 + 4 + 1 + 0 + 0 + 1 + 2 + 3 + 2 + 0 + 0) * 3) + ((2 + 0 + 4 + 0 + 4 + 0 + 6 + 0 + 0 + 0 + 2 + 1 + 4 + 3 + 0 + 3 + 10 + 0 + 5 + 0) * 2)= 151 elfes

Défi

Aidez le père Noël à déterminer le nombre d'elfes dont il a besoin pour livrer des marchandises dans chaque maison!

Maisons

  • Une maison est représentée par un *
  • Les maisons sont divisées par +
  • Le nombre à gauche de la maison symbolise le nombre de vilains (aucun chiffre ne signifie 0)
  • Le chiffre à droite symbolise le nombre de personnes sympas (aucun chiffre ne signifie 0)
  • Il peut y avoir des sauts de ligne ( \n) en entrée, qui doivent également être traités comme un fractionnement

Elfes

  • Le père Noël a besoin de l'aide de trois elfes pour les vilains (le charbon est beaucoup plus lourd que les cadeaux)
  • Le Père Noël a besoin de l'aide de deux elfes pour des gens sympas
  • S'il n'y a pas de numéro de chaque côté, le père Noël ne visitera pas cette maison et n'a donc pas besoin d'elfes

Que faire

Imprimez le nombre d'elfes dont le père Noël a besoin pour l'aider à livrer des cadeaux aux maisons. Parce que tout ce que le Père Noël a besoin de savoir, c'est le nombre d'elfes à apporter, il vous suffit d'imprimer le nombre supplémentaire d'elfes dont il a besoin pour la liste des maisons.

Cas de test

1*1 => 5
1*2 => 7
2*1 => 8
1* => 3
*1 => 2
* => 0

1*1+1*1 => 10
1*2+2*1 => 15
1*+*1 => 5
1*1+*+1*1 => 10
*+*+*+* => 0

Règles

  • L'entrée peut être soit prise comme argument dans une fonction, soit depuis STDIN ou équivalent
  • La sortie peut être soit la valeur de retour d'une fonction, soit imprimée sur STDOUT ou équivalent
  • L'entrée ne contient que des chiffres, +, *, et retour à la ligne\n
  • La sortie ne devrait être que le nombre total d'elfes dont le Père Noël a besoin d'aide pour livrer à Noël
  • Des échappatoires standard s'appliquent

Notation

Le traîneau du Père Noël est plein de cadeaux lui donnant moins d'espace pour exécuter du code, donc il a besoin du code le plus court qu'il puisse obtenir (ne vous inquiétez pas si cela n'a pas de sens. Si vous remettez en question la logique du Père Noël, vous vous retrouverez sur la liste coquine ). En raison du raisonnement CORRECT du Père Noël , la soumission la plus courte en octets gagne!

Classement

Il s'agit d'un extrait de pile qui génère à la fois un classement et un aperçu des gagnants par langue.

Pour vous assurer que votre réponse s'affiche, veuillez commencer votre réponse avec un titre en utilisant le modèle Markdown suivant

## Language Name, N bytes

Où N est la taille, en octets, de votre soumission

Si vous souhaitez inclure plusieurs nombres dans votre en-tête (par exemple, en supprimant les anciens scores ou en incluant des indicateurs dans le nombre d'octets), assurez-vous simplement que le score réel est le dernier numéro de votre en-tête

## Language Name, <s>K</s> X + 2 = N bytes

Afficher l'extrait de code

code-golf  string 
— Jojodmo
source
1
Je me demande, comme le Père Noël s'arrêtera dans n'importe quelle maison, n'aurait-il pas simplement besoin d'un maximum d' max(naughty) + max(nice)elfes pour tout le trajet? Je pensais qu'il avait un tas d'elfes volant avec lui, mais peut-être avez-vous des informations privilégiées à ce sujet et je dois regarder de plus près cette année. :)
— insertusernamehere
8
@insertusernamehere Je travaille actuellement chez Santa Inc. et je peux vous dire que notre infrastructure fonctionne de manière fortement asynchrone. Il ne veut pas que ses ressources meurent de faim, alors nous affectons autant de travailleurs que nécessaire. Si nous avons besoin d'un ELF supplémentaire, nous pouvons en compiler un en quelques secondes hello-world.c. Les elfes ouvriers sont alloués avec impatience aux cibles, comme l'a dit Jojodmo (je suis sûr que je connais Jojodmo, il doit être notre administrateur système), puis ils utilisent un rappel pour indiquer quand il est temps de réinsérer dans la piscine de traîneau ou quand un enfant les a vus.
— Stefano Sanfilippo
2
@StefanoSanfilippo Ah, je vois. Merci pour toutes les informations détaillées de ces informations classifiées. Et joyeux Noël. :)
— insertusernamehere
C'est tout à fait logique. Le Père Noël a besoin du code le plus court, car il imprime chaque caractère du code avec une imprimante, puis les met sur son traîneau avant de les exécuter.
— A

Réponses:

2

Pyth, 21 octets

ssMs*VCcR\*scR\+.z_S3

Exemple multiligne

Suite de tests sur une seule ligne

ssMs*VCcR\*scR\+.z_S3
                .z        Take a input, as a list of lines.
            cR\+          Chop each line on '+'.
           s              Flatten into list of strings.
       cR\*               Chop each line on '*'.
      C                   Transpose, into a list of naughty and nice.
    *V            _S3     Vectorized multiplication with [3, 2, 1]. This replicates
                          the naughty list 3 times and the nice list 2 times.
   s                      Flatten.
 sM                       Convert each string to an int.
s                         Sum.
— isaacg
source
Sérieusement ... Y a-t-il quelque chose que Pyth ne peut pas faire en moins de 30 octets?
— Jojodmo
2
@Jojodmo Pas si je peux l'aider ...
— isaacg
13

JavaScript (ES6), 52 octets

s=>eval(s.replace(/\D|$/g,m=>`.0*${m=="*"?3:2}+`)+0)

Explication

Convertit l'entrée en une instruction JavaScript valide. Remplace tous *par .0*3+et tous les autres symboles (non numériques) par .0*2+. Par exemple 8*9+*10devient 8.0*3+9.0*2+.0*3+10. Enfin, il s'ajoute .0*2à la fin pour le dernier joli décompte. Cela fonctionne parce que n.0= net .0= 0.

s=>
  eval(                      // execute the formed equation
    s.replace(/\D|$/g,       // replace each symbol (and also add to the end) with:
      m=>`.0*${m=="*"?3:2}+` // case * = ".0*3+", else replace with ".0*2+"
    )
    +0                       // add "0" to the end for the trailing "+"
  )

Tester

Afficher l'extrait de code

— user81655
source
9
+1 pour l' .0idée.
— nimi
3

Flex + C, 112 90 octets

 m=3,t;
%%
[0-9]+ t+=m*atoi(yytext);
\* m=2;
[+\n] m=3;
%%
main(){yylex();printf("%d",t);}

Le premier caractère est un espace. Compiler avec:

flex -o santa.c santa.l
cc santa.c -o santa -ll

Lit depuis STDIN, écrit dans STDOUT. L'entrée est terminée par EOF (Ctrl + D dans la console).

— Stefano Sanfilippo
source
2

Mathematica, 70 octets

a=Tr[FromDigits/@StringExtract[#,"
"|"+"->;;,"*"->#2]]&;3#~a~1+2#~a~2&

Utilise StringExtractpour extraire les numéros individuels.

— LegionMammal978
source
2

CJam, 23 octets

q'+NerN/{'*/3*5<:~~}%1b

Testez-le ici.

Explication

q      e# Read all input.
'+Ner  e# Replaces all "+" with linefeeds.
N/     e# Split the string around linefeeds (i.e. into houses).
{      e# Map this block over the list of house...
  '*/  e#   Split the string around the "*".
  3*   e#   Repeat the times.
  5<   e#   Truncate to 5 elements, keeping 3 copies of the naughty number and 2 copies of
       e#   the nice number.
  :~   e#   Evaluate each number (which may be an empty string which pushes nothing).
  ~    e#   Dump the list of numbers on the stack.
}%
1b     e# Sum all the numbers.
— Martin Ender
source
2

Sérieusement, 38 30 octets

'*Ws`'0+'*@s'≈£M4rR*`MΣ+'+,WXX

Vidage hexadécimal:

272a57736027302b272a407327f79c4d3472522a604de42b272b2c575858

Cette nouvelle version casse l'interpréteur en ligne, mais fonctionne bien localement. Voici un exemple d'exécution:

$ python2 seriously.py -f elves.srs
1*2+*+*4+1*
2*4+3*+1*6+*
*+*+4*2+1*1
*4+*3+1*+2*3
3*10+2*+*5+*

151

Explication:

'*                              Push a "*" to make the stack truthy
  W                        W    Repeat while the top of stack is truthy
                                  (A whole bunch of instructions just turn the "*" into a
                                  zero on the first pass, so I'll list them here in the
                                  order they actually accomplish useful things:)
                          ,     Read in a line of input
   s                    '+      Split it on occurrence of "+"
    `               `M          Map this function over the list of strings.
     '0+                        Prepend a "0" to ensure a naughty number exists
        '*@s                    Split the string on "*"
            '≈£M                Map over the string with int() to convert it to int
                4rR             Push [3,2,1,0]
                   *            Dot product
                      Σ+        Sum all the houses, and add it to the results
                                  from the previous line of input
                            XX  Pop the "" and '+ from the stack, leaving only the
                                result to be implicitly output.

Ancienne version:

'+ε'*`+'++,`╬Xs`≈`╗`'0+'*@s╜M[3,2]*`MΣ

Vidage hexadécimal:

272bee272a602b272b2b2c60ce587360f760bb6027302b272a4073bd4d5b332c325d2a604de4

Essayez-le en ligne

Explication:

  ε'*                                   Initialize with two strings so the first + works
     `+'++,`╬                           Read in strings and compile them until "" is read
             X                          Throw away the ""
'+            s                         Split on +
               `≈`╗                     Chuck int function into reg0 to use within function
                   `               `M   Map this function over the list of houses
                    '0+                 Prepend a "0" to ensure a naughty number exists
                       '*@s             Split on *
                           ╜M           Convert the resulting list to ints with stored func
                             [3,2]*     Dot product with [3,2]
                                     Σ  Sum all houses

Cela pourrait être plus court si je convertissais chaque ligne séparément et les additionnais toutes à la fin. J'y reviendrai plus tard.

— quintopie
source
2

PowerShell, 52 octets

En utilisant la variation de user81655 de » .0trick

$OFS='+';"$("$args"-replace'\*','.0*3+2*0'|iex)"|iex

Version non golfée

$OFS='+' # Set Output Field Separator to '+'
         # So if $arr = 1,2,3 then "$arr" will output 1+2+3

" # Cast result of subexpression to string using $OFS

    $( # Subexpression

        "$args" # Input is an array of arguments. Casting it to string using "$args"
                # is shorter then acessing the first element using $args[0]
                # $OFS wouldn't affect this, because input has only 1 element.

        -replace '\*' , '.0*3+2*0' # Replace every * with .0*3+2*0
                                   # Example: 1*+*1 becomes 1.0*3+2*0+.0*3+2*01

    ) | Invoke-Expression # Execute a result of subexpression as PS code.
                          # This will execute resulting multiline string line-by line
                          # and return an array of values, e.g.: 18,38,21,29,45

" Cast the aray above to string using '+' as Output Field Separator, e.g: 18+38+21+29+45

| Invoke-Expression # Execute the string above as PS code to get final result.
                    # E.g.: 18+38+21+29+45 = 151

Exemple d'utilisation

$Map = @'
1*2+*+*4+1*
2*4+3*+1*6+*
*+*+4*2+1*1
*4+*3+1*+2*3
3*10+2*+*5+*
'@

PS > .\SantaMap.ps1 $Map
151
— beatcracker
source
1

Swift 2, 283 211 octets

func f(s:String)->Int{var r=0;for p in(s.characters.split{$0=="\n"}.map(String.init)){for v in p.utf8.split(43){let k="0\(v)".utf8.split(42);r+=(Int("\(k[0])")!)*3;r+=(k.count<2 ?0:Int("\(k[1])")!)*2}};return r}

Cela peut être testé sur SwiftStub, ici

Non golfé

func f(s: String) -> Int{
    var r = 0

    //for every value in the input, split every "\n" and mapped
    //to a String array
    for p in (s.characters.split{$0=="\n"}.map(String.init)){

        //for every value in the split input, split again at every + (Decimal 43)
        for v in p.utf8.split(43){
            //change the value to "0" + v, which doesn't change the
            //input, but in the event that there is no input on the
            //left side, a "0" will be used
            //
            //then split on every * (Decimal 42)
            let k = "0\(v)".utf8.split(42)

           //add to the total count of elves the number on the left * 3
            r+=(Int("\(k[0])")!) * 3

            //add to the total count of elves the number on the left * 2
            r+=(k.count < 2 ? 0 : Int("\(k[1])")!) * 2
        }

        //return the number of elves
        return r
    }
}
— Jojodmo
source
1

Python 3, 141 114 112 112 octets

Prend des entrées multi-lignes comme celle-ci c("1*2+*+*4+1*\n2*4+3*+1*6+*\n*+*+4*2+1*1\n*4+*3+1*+2*3\n3*10+2*+*5+*")

lambda s:sum(a and(3-z)*int(a)or 0for j in s.split("\n")for i in j.split("+")for z,a in enumerate(i.split("*")))

Non golfé:

def c(s):
    t = 0
    for j in s.split("\n"):
        for i in j.split("+"):
            for z,a in enumerate(i.split("*"))
                if a == "":
                    a = 0
                else:
                    a = int(a)
                t += (3-z) * a  # alternate a*3 and a*2
    return t
— Sherlock9
source
1

Je suis super en retard, mais je voulais quand même essayer.

Rubis , 84 55 octets

J'ai retrouvé cette question après tant d'années et réfléchissais à une nouvelle réponse avant de réaliser que j'avais déjà répondu à cette question auparavant. Oups! Quoi qu'il en soit, voici une réponse considérablement améliorée.

->m{m.scan(/(\d*)\*(\d*)/).sum{|a,b|3*a.to_i+2*b.to_i}}

Essayez-le en ligne!

Ancienne réponse de 84 octets de ma première réponse il y a 2 ans:

->m{m.split(/[+\n]/).map{|h|b,g=h.split(?*).map &:to_i
3*(b||0)+2*(g||0)}.inject :+}

Essayez-le en ligne!

— Encre de valeur
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.