Wie viele Elfen braucht der Weihnachtsmann, um Geschenke zu bringen?

23

Der Weihnachtsmann braucht Hilfe, um festzustellen, wie viele Elfen er benötigt, um jedem Haus Geschenke zukommen zu lassen.

Kohle ist erheblich schwerer als Geschenke, daher braucht der Weihnachtsmann drei Elfen für jede ungezogene Person im Haus. Es werden nur zwei Elfen benötigt, um dem Weihnachtsmann beim Tragen von Geschenken zu helfen.

Auf der Santa-Karte wird ein Haus durch a dargestellt *, und jedes Haus wird durch a geteilt +.

Zu beiden Seiten des Hauses befindet sich eine Zahl - die linke für die Anzahl der ungezogenen Personen im Haus und die rechte für die Anzahl der netten Personen im Haus. Wenn auf einer Seite keine Zahl steht, wird sie als 0 interpretiert.

Der Weihnachtsmann besucht nicht diejenigen, die nicht in Weihnachtsstimmung sind (sie verdienen nicht einmal Kohle), daher kann es vorkommen, dass ein Haus auf keiner Seite eine Nummer hat. In diesem Fall braucht der Weihnachtsmann keine Hilfe von Elfen

Zum Beispiel könnte eine von Santas Karten so aussehen

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

Im ersten Haus gibt es 1 freche und 3 nette, der Weihnachtsmann braucht neun Elfen. Im zweiten gibt es 2 freche und 2 nette, der Weihnachtsmann braucht zehn Elfen. Im dritten Haus gibt es 1 frechen und 0 netten, der Weihnachtsmann braucht drei Elfen, und im letzten Haus gibt es 0 frechen und 2 netten, der Weihnachtsmann braucht vier Elfen.

Dies ist jedoch eine stark vereinfachte Version einer der Santa-Karten. Normalerweise bestehen Santas Karten aus mehreren Zeilen und sind quadratisch, um besser auf seine Liste zu passen. Eine normale Karte könnte ungefähr so ​​aussehen (a \nam Ende jeder Zeile)

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

In dieser Karte braucht der Weihnachtsmann ((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 Elfen

Herausforderung

Hilf dem Weihnachtsmann herauszufinden, wie viele Elfen er benötigt, um Waren an jedes Haus zu liefern!

Häuser

  • Ein Haus wird durch a dargestellt *
  • Häuser werden durch geteilt +
  • Die Zahl auf der linken Seite des Hauses symbolisiert die Anzahl der ungezogenen Personen (keine Zahl bedeutet 0)
  • Die Zahl rechts symbolisiert die Anzahl der netten Leute (keine Zahl bedeutet 0)
  • Möglicherweise enthält \ndie Eingabe Zeilenumbrüche ( ), die ebenfalls als Teilung behandelt werden sollten

Elfen

  • Der Weihnachtsmann braucht Hilfe von drei Elfen für ungezogene Menschen (Kohle ist viel schwerer als Geschenke)
  • Santa braucht Hilfe von zwei Elfen für nette Leute
  • Wenn es auf beiden Seiten keine Nummer gibt, wird der Weihnachtsmann dieses Haus nicht besuchen und braucht daher keine Elfen

Was ist zu tun

Drucken Sie die Anzahl der Elfen aus, die der Weihnachtsmann benötigt, um ihm zu helfen, Geschenke in die Häuser zu bringen. Da der Weihnachtsmann nur wissen muss, wie viele Elfen er mitbringen muss, muss nur die Anzahl der Elfen gedruckt werden, die er für die Liste der Häuser benötigt

Testfälle

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

Regeln

  • Die Eingabe kann entweder als Argument in einer Funktion oder von STDIN oder einer entsprechenden Quelle übernommen werden
  • Die Ausgabe kann entweder der Rückgabewert einer Funktion sein oder auf STDOUT oder ein gleichwertiges Format gedruckt werden
  • Die Eingabe enthält nur Zahlen, +, *, und Zeilenumbrüche\n
  • Die Ausgabe sollte nur die Gesamtzahl der Elfen sein, von denen der Weihnachtsmann Hilfe benötigt, um an Weihnachten zu liefern
  • Es gelten Standardlücken

Wertung

Der Schlitten des Weihnachtsmanns ist voller Geschenke, die ihm weniger Platz zum Ausführen von Code geben. Deshalb benötigt er den kürzesten Code, den er bekommen kann ). Aufgrund der RICHTIGEN Überlegung des Weihnachtsmanns gewinnt die kürzeste Übermittlung in Bytes!

Bestenliste

Dies ist ein Stack-Snippet, das sowohl eine Rangliste als auch eine Übersicht der Gewinner nach Sprache generiert.

Um sicherzustellen, dass Ihre Antwort angezeigt wird, beginnen Sie Ihre Antwort mit einer Überschrift unter Verwendung der folgenden Markdown-Vorlage

## Language Name, N bytes

Wobei N die Größe Ihrer Übermittlung in Byte ist

Wenn Sie mehrere Zahlen in Ihre Kopfzeile aufnehmen möchten (z. B. alte Punkte durchstreichen oder Flags in die Byteanzahl aufnehmen möchten), stellen Sie sicher, dass die tatsächliche Punktzahl die letzte Zahl in Ihrer Kopfzeile ist

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

Code-Snippet anzeigen

code-golf string Jojodmo
quelle
1
Ich frage mich, wie der Weihnachtsmann bei jedem Haus vorbeischauen wird, würde er nicht einfach maximal max(naughty) + max(nice)Elfen für die gesamte Strecke brauchen ? Ich dachte, er hat ein paar Elfen, die mit ihm fliegen, aber vielleicht hast du Insider-Informationen dazu und ich muss dieses Jahr genauer hinschauen. :)
insertusernamehere
8
@insertusernamehere Ich arbeite derzeit bei Santa Inc. und kann Ihnen sagen, dass unsere Infrastruktur stark asynchron arbeitet. Er möchte nicht, dass seine Ressourcen aushungern, deshalb stellen wir so viele Mitarbeiter wie nötig zur Verfügung. Falls wir einen zusätzlichen ELF benötigen, können wir in wenigen Sekunden einen kompilieren hello-world.c. Arbeiterelfen werden eifrig Zielen zugewiesen, wie Jojodmo sagte (ich bin sicher, dass ich Jojodmo kenne, er muss unser Systemadministrator sein) und dann einen Rückruf verwenden, um zu benachrichtigen, wann es Zeit ist, wieder in den Schlittenpool eingesetzt zu werden oder wenn ein Kind sie gesehen hat.
Stefano Sanfilippo
2
@StefanoSanfilippo Ah, ich verstehe. Vielen Dank für alle detaillierten Einblicke in diese Verschlusssachen. Und frohe Weihnachten. :)
insertusernamehere
Das macht total Sinn. Der Weihnachtsmann braucht den kürzesten Code, weil er jedes Zeichen des Codes mit einem Drucker ausgibt und sie dann auf seinen Schlitten legt, bevor er sie ausführt.
A

Antworten:

2

Pyth, 21 Bytes

ssMs*VCcR\*scR\+.z_S3

Mehrzeiliges Beispiel

Einzeilige Testsuite

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
quelle
Ernsthaft ... Gibt es etwas, was Pyth in weniger als 30 Bytes nicht kann?
Jojodmo
2
@Jojodmo Nicht, wenn ich es helfen kann ...
Isaacg
13

JavaScript (ES6), 52 Byte

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

Erläuterung

Konvertiert die Eingabe in eine gültige JavaScript-Anweisung. Ersetzt alle *mit .0*3+und alle anderen (nicht stelligen) Symbole mit .0*2+. Zum Beispiel 8*9+*10wird 8.0*3+9.0*2+.0*3+10. Schließlich wird es .0*2an das Ende der letzten schönen Zählung angehängt . Das funktioniert, weil n.0= nund .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 "+"
  )

Prüfung

Code-Snippet anzeigen

user81655
quelle
9
+1 für die .0Idee.
nimi
3

Flex + C, 112 90 Bytes

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

Das erste Zeichen ist ein Leerzeichen. Kompilieren mit:

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

Liest aus STDIN, schreibt nach STDOUT. Die Eingabe wird durch EOF (Strg + D in der Konsole) beendet.

Stefano Sanfilippo
quelle
2

Mathematica, 70 Bytes

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

Dient StringExtractzum Extrahieren der einzelnen Zahlen.

LegionMammal978
quelle
2

CJam, 23 Bytes

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

Teste es hier.

Erläuterung

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
quelle
2

Im Ernst, 38 30 Bytes

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

Hex Dump:

272a57736027302b272a407327f79c4d3472522a604de42b272b2c575858

Diese neue Version unterbricht den Online-Interpreter, funktioniert aber lokal einwandfrei. Hier ist ein Beispiellauf:

$ 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

Erläuterung:

'*                              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.

Alte Version:

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

Hex Dump:

272bee272a602b272b2b2c60ce587360f760bb6027302b272a4073bd4d5b332c325d2a604de4

Probieren Sie es online

Erläuterung:

  ε'*                                   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

Dies könnte kürzer sein, wenn ich nur jede Zeile einzeln konvertiert und am Ende alle aufsummiert hätte. Ich werde es später untersuchen.

Quintopie
quelle
2

PowerShell, 52 Byte

Mit Variation von user81655 ‚s .0Trick

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

Ungolfed-Version

$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

Anwendungsbeispiel

$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
quelle
1

Swift 2, 283 211 Bytes

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}

Dies kann auf SwiftStub hier getestet werden

Ungolfed

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
quelle
1

Python 3, 141 114 112 Bytes

Nimmt mehrzeilige Eingänge wie diesen auf 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("*")))

Ungolfed:

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
quelle
1

Ich bin super spät dran, aber ich wollte es trotzdem versuchen.

Ruby , 84 55 Bytes

Nach so vielen Jahren fand ich diese Frage wieder und überlegte mir eine neue Antwort, bevor mir klar wurde, dass ich sie bereits beantwortet hatte. Hoppla! Wie auch immer, hier ist eine drastisch verbesserte Antwort.

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

Probieren Sie es online!

Alte 84-Byte-Antwort von der ersten Antwort vor 2 Jahren:

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

Probieren Sie es online!

Wert Tinte
quelle
1

Python 3 , 96 Bytes

lambda s:sum(int('0'+n)*(3-i%2)for i,n in enumerate(re.sub('[*\s]','+',s).split('+')));import re

Probieren Sie es online!

101 Bytes ohne Regex

lambda s:sum(int('0'+n)*(3-i%2)for i,n in enumerate(s.replace('*','+').replace('\n','+').split('+')))

Probieren Sie es online!

Matthew Jensen
quelle