Ile elfów potrzebuje Święty Mikołaj, aby dostarczyć prezenty?

23

Święty Mikołaj potrzebuje pomocy w określeniu, ilu elfów będzie potrzebował, aby pomóc mu dostarczyć prezenty do każdego domu.

Węgiel jest znacznie cięższy niż prezenty, więc Święty będzie potrzebował trzech elfów na każdą niegrzeczną osobę w domu. Potrzebne są tylko dwa elfy, aby pomóc Mikołajowi nosić prezenty.

Na mapie Świętego Mikołaja dom jest reprezentowany przez *, a każdy dom jest podzielony przez +.

Po obu stronach domu będzie liczba - ta po lewej reprezentująca liczbę niegrzecznych ludzi w domu, a ta po prawej reprezentująca liczbę miłych ludzi w domu. Jeśli po jednej stronie nie ma numeru, jest interpretowane jako 0.

Święty Mikołaj nie odwiedza tych, którzy nie są w świątecznym nastroju (nawet nie zasługują na węgiel), więc czasami dom może nie mieć numeru po obu stronach. W tym przypadku Święty Mikołaj nie potrzebuje pomocy od elfów

Na przykład jedna z map Świętego Mikołaja może wyglądać tak

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

W pierwszym domu jest 1 niegrzeczny i 3 miłych, Mikołaj będzie potrzebował dziewięciu elfów. W drugim są 2 niegrzeczne i 2 ładne, Mikołaj będzie potrzebował dziesięciu elfów. W trzecim domu jest 1 niegrzeczny i 0 fajnych, Święty będzie potrzebował trzech elfów, aw ostatnim domu jest 0 niegrzecznych i 2 fajnych, Święty będzie potrzebował czterech elfów.

Jest to jednak zbyt uproszczona wersja jednej z map Świętego Mikołaja. Zwykle mapy Świętego Mikołaja mają wiele linii i mają kwadratowy kształt, aby lepiej pasowały do ​​jego listy. Normalna mapa może wyglądać \nmniej więcej tak (a na końcu każdej linii)

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

Na tej mapie Święty potrzebuje ((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 elfów

Wyzwanie

Pomóż Mikołajowi ustalić, ilu elfów musi dostarczyć towary do każdego domu!

Domy

  • Dom jest reprezentowany przez *
  • Domy są podzielone według +
  • Liczba po lewej stronie domu symbolizuje liczbę niegrzecznych ludzi (brak liczby oznacza 0)
  • Liczba po prawej stronie symbolizuje liczbę miłych ludzi (brak liczby oznacza 0)
  • Na \nwejściu mogą znajdować się znaki nowej linii ( ), które również należy traktować jako podział

Elfy

  • Święty Mikołaj potrzebuje pomocy trzech elfów dla niegrzecznych ludzi (węgiel jest znacznie cięższy niż prezenty)
  • Święty Mikołaj potrzebuje pomocy od dwóch elfów dla miłych ludzi
  • Jeśli po obu stronach nie będzie numeru, Mikołaj nie odwiedzi tego domu i dlatego nie potrzebuje żadnych elfów

Co robić

Wydrukuj liczbę elfów, których potrzebuje Święty Mikołaj, aby pomóc mu dostarczyć prezenty do domów. Ponieważ wszystko, co Mikołaj musi wiedzieć, to ile elfów ma przynieść, wystarczy wydrukować tylko dodatkową liczbę elfów, której potrzebuje na liście domów

Przypadki testowe

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

Zasady

  • Dane wejściowe mogą być pobierane jako argument funkcji lub STDIN lub równoważny
  • Dane wyjściowe mogą być albo wartością zwracaną przez funkcję, albo drukowane do STDOUT lub równoważne
  • Wejście będzie zawierać tylko liczby, +, *, i nowe linie\n
  • Wynik powinien być tylko całkowitą liczbą elfów, których Święty Mikołaj potrzebuje pomocy, aby dostarczyć w Boże Narodzenie
  • Standardowe luki zastosowanie

Punktacja

Sanie Świętego Mikołaja są pełne prezentów, co daje mu mniej miejsca na uruchomienie kodu, więc potrzebuje najkrótszego kodu, jaki może dostać (nie martw się, jeśli to nie ma sensu. Jeśli kwestionujesz logikę Świętego Mikołaja, trafisz na niegrzeczną listę ). Ze względu na PRAWIDŁOWE rozumowanie Świętego Mikołaja wygrywa najkrótsze przesłanie w bajtach!

Tabela liderów

To jest fragment kodu, który generuje zarówno tabelę wyników, jak i przegląd zwycięzców według języka.

Aby mieć pewność, że Twoja odpowiedź się pojawi, zacznij od nagłówka, korzystając z następującego szablonu Markdown

## Language Name, N bytes

Gdzie N jest rozmiarem twojego przesłania w bajtach

Jeśli chcesz dołączyć wiele liczb do nagłówka (na przykład przekreślając stare wyniki lub włączając flagi w liczbie bajtów), po prostu upewnij się, że rzeczywisty wynik jest ostatnią liczbą w nagłówku

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

Pokaż fragment kodu

code-golf string Jojodmo
źródło
1
Zastanawiam się, skoro Święty Mikołaj zatrzyma się w jakimkolwiek domu, czy nie potrzebowałby maksymalnie max(naughty) + max(nice)elfów na całą trasę? Myślałem, że ma przy sobie grupę elfów, ale może masz na ten temat poufne informacje i muszę w tym roku przyjrzeć się bliżej. :)
inserttusernamehere
8
@insertusernamethere Obecnie pracuję w Santa Inc. i mogę powiedzieć, że nasza infrastruktura działa w bardzo asynchroniczny sposób. Nie chce, aby jego zasoby głodowały, więc przydzielamy tyle pracowników, ile potrzeba. Jeśli potrzebujemy dodatkowego ELF, możemy go skompilować w ciągu kilku sekund hello-world.c. Elfy robotnicze są chętnie przydzielane do celów, jak powiedział Jojodmo (jestem pewien, że znam Jojodmo, to on musi być naszym sysadmem), a następnie używają oddzwaniania, aby powiadomić, kiedy nadszedł czas, aby ponownie założyć sanie lub kiedy dziecko je zobaczyło.
Stefano Sanfilippo
2
@StefanoSanfilippo Ach, rozumiem. Dziękujemy za wszystkie szczegółowe informacje na temat tych informacji niejawnych. I wesołych świąt. :)
inserttusernamehere
To całkowicie ma sens. Święty Mikołaj potrzebuje najkrótszego kodu, ponieważ drukuje każdy znak kodu za pomocą drukarki, a następnie kładzie je na saniach przed ich wykonaniem.
A̲̲

Odpowiedzi:

2

Pyth, 21 bajtów

ssMs*VCcR\*scR\+.z_S3

Przykład wieloliniowy

Jednowierszowy pakiet testowy

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
źródło
Poważnie ... Czy jest coś, czego Pyth nie mógłby zrobić w mniej niż 30 bajtach?
Jojodmo,
2
@Jojodmo Nie, jeśli mogę pomóc ...
isaacg
13

JavaScript (ES6), 52 bajty

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

Wyjaśnienie

Konwertuje dane wejściowe na prawidłową instrukcję JavaScript. Zastępuje wszystkie *z .0*3+, a wszystkie inne (nie-cyfrowy), z symboli .0*2+. Na przykład 8*9+*10staje się 8.0*3+9.0*2+.0*3+10. Na koniec dołącza .0*2się do końca dla ostatniej miłej liczby. Działa to, ponieważ n.0= ni .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 "+"
  )

Test

Pokaż fragment kodu

użytkownik 81655
źródło
9
+1 za .0pomysł.
nimi
3

Flex + C, 112 90 bajtów

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

Pierwsza postać to spacja. Połącz z:

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

Czyta ze STDIN, pisze do STDOUT. Wejście jest zakończone przez EOF (Ctrl + D w konsoli).

Stefano Sanfilippo
źródło
2

Mathematica, 70 bajtów

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

Używa StringExtractdo wyodrębnienia poszczególnych liczb.

LegionMammal978
źródło
2

CJam, 23 bajty

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

Sprawdź to tutaj.

Wyjaśnienie

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
źródło
2

Poważnie, 38 30 bajtów

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

Hex Dump:

272a57736027302b272a407327f79c4d3472522a604de42b272b2c575858

Ta nowa wersja psuje interpretera online, ale działa dobrze lokalnie. Oto przykładowy przebieg:

$ 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

Wyjaśnienie:

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

Stara wersja:

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

Hex Dump:

272bee272a602b272b2b2c60ce587360f760bb6027302b272a4073bd4d5b332c325d2a604de4

Wypróbuj online

Wyjaśnienie:

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

Może to być krótsze, gdybym po prostu przekształcił każdą linię osobno i zsumował je wszystkie na końcu. Zajmę się tym później.

kwintopia
źródło
2

PowerShell, 52 bajty

Korzystanie odmianę user81655 „s .0trik

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

Wersja bez golfa

$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

Przykład użycia

$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
źródło
1

Swift 2, 283 211 bajtów

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}

Można to przetestować tutaj w SwiftStub

Bez golfa

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
źródło
1

Python 3, 141 114 112 bajtów

Przyjmuje wejścia wieloliniowe w ten sposób 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("*")))

Nie golfowany:

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
źródło
1

Jestem bardzo spóźniony, ale i tak chciałem spróbować.

Rubin , 84 55 bajtów

Znalazłem to pytanie ponownie po tylu latach i zastanawiałem się nad nową odpowiedzią, zanim zdałem sobie sprawę, że już na nie odpowiedziałem. Ups! Tak czy inaczej, oto drastycznie poprawiona odpowiedź.

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

Wypróbuj online!

Stara 84-bajtowa odpowiedź z pierwszej odpowiedzi 2 lata temu:

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

Wypróbuj online!

Wartość tuszu
źródło
1

Python 3 , 96 bajtów

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

Wypróbuj online!

101 bajtów bez wyrażenia regularnego

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

Wypróbuj online!

Matthew Jensen
źródło