Birkaç yıl önce Hot Wheels, "Formula Fuelers Racers" * adlı basit bir flash oyunu yaptı . Oyunu oynamak için, aracınıza koymak üzere buzdolabından üç malzemeyi seçersiniz, bu daha sonra bilgisayarın rasgele üretilen arabasına karşı yarışır. Görünüşe göre bu oyunun mekaniği oldukça basit. Öncelikle, arabanızın gerçek ırkı "zamanı" rastgele oluşturulur ve yarışı kazanıp kazanmamanız üzerinde hiçbir etkisi yoktur. İkincisi, yarışın kazananı seçilen malzemelerden hesaplanan bir puanla belirlenir (iki bileşenlere izin verilir ve sipariş önemlidir). Her bileşen, aşağıdaki tabloda gösterildiği gibi ilişkili bir "değer" e ve ilişkili bir "işlem" e sahiptir:

#   ingredient     val  op
1   Hot Salsa       2   +
2   Root Beer       1   +
3   Milk            1   +
4   Pickle Juice    2   +
5   Mystery Lunch   -3  *
6   BBQ Sauce       2   +
7   Egg             1   +
8   Ketchup         2   +
9   Mustard         -1  *
10  Melon           1   +
11  Chocolate Milk  1   +
12  Mayonnaise      -2  *
13  Baby Food       0   +
14  Pepper          1   +
15  Salt            2   +
16  Syrup           -1  *
17  Salad Dressing  2   +
18  Orange Juice    1   +
19  Soy Sauce       2   +

Kolaylık sağlamak için bu zorluk, adlarına değil, adlarına göre malzemelere atıfta bulunacaktır. İşte bir puan hesaplamak için adımlar:

1. İlk önce skoru ilk bileşenin değeriyle başlat.
2. Ardından, geçerli puanı ve ikinci bileşenin değerini güncel bir puan almak için birleştirmek için ikinci bileşenin işlemini kullanın.
3. Son olarak, mevcut puanı ve üçüncü bileşenin değerini nihai puanı almak için birleştirmek için üçüncü bileşenin işlemini kullanın.

Yüksek puanlar daha iyidir ve daima düşük puanları atar.

Örneğin, bileşenlerin 1 2 3bir puanı var (2+1)+1 = 4. Malzemelerin 7 5 6bir puanı var (1*-3)+2 = -1. Bu nedenle, 1 2 3atıyor 7 5 6.

Meydan okuma

Bu zorluğa göre, sıralanan 3 tamsayı listesini alan ve karşılık gelen puanı veren bir program yazmalısınız.

Giriş

Programınız en uygun biçimde üç tamsayının listesini kabul edebilir. İçerik adları için 1 dizini kullanma (yukarıdaki gibi) veya 0 dizini oluşturma (yukarıdaki her dizinden 1 çıkarma) kullanmanıza izin verilir.

Çıkışı

Programınız puanı belirten tek bir tamsayı çıkarmalıdır.

Test Kılıfları

4 5 5  =>  18 // max score
5 5 5  =>  -27 // min score
13 13 13  =>  0
1 2 3  =>  4
7 5 6  =>  -1
16 2 19  =>  2
19 7 12  =>  -6

* Bu sayfa oldukça eski ve bazı tarayıcılarda çalışmaz, ancak bu zorluk için oyunu oynamanız gerekmez.

Jöle , 24 bayt

“zẈ€$ụ¤’b6’ị@µỊị⁾+׿CFḊV

0 indeksli içeriklerin bir listesini alır.

Çevrimiçi deneyin! veya bir test odasına bakın

Nasıl?

Değerleri baz-6 sayısı olarak sıkıştırmak için hafif kıvrımlı bir form ve çarpımsal girişlerin negatif olanlar olduğu gerçeğini kullanır. Baz-6 rakamlarını elde etmek için sadece 3 ile yukarı kaydırmak yerine, artan tamamlanmış değerler kullanılır - bu, Ịatomun tamamlayıcı adımdan önce negatif girişleri seçmesine izin vererek, aynı zamanda baz-250'de bir byte tasarrufu sağlayarak byte tasarrufu sağlar. sıkıştırma.

“zẈ€$ụ¤’b6’ị@µỊị⁾+׿CFḊV - Main link: 0-based ingredient list  e.g. [6,4,5]
“zẈ€$ụ¤’                 - base 250 compressed number: 120851767994004
        b6               - convert to base 6: [1,1,0,5,0,1,0,3,1,1,4,2,1,0,3,0,1,0,0]
          ’              - decrement: [0,0,-1,4,-1,0,-1,2,0,0,3,1,0,-1,2,-1,0,-1,-1]
           ị@            - index into [reversed @rguments]          [0,4,-1]
             µ           - monadic chain separation (call that x)
              Ị          - insignificant(x)? (abs(x)<=1)            [1,0,1]
                ⁾+×      - ['+','×']
               ị         - index into                               ['+','×','+']
                    C    - complement(x) (1-x)                      [1,-3,2]
                   ż     - zip                                      [['+',1],['×',-3],['+',2]]
                     F   - flatten                                  ['+',1,'×',-3,'+',2]
                      Ḋ  - dequeue                                  [1,'×',-3,'+',2]
                       V - evaluate as Jelly code                   -1

JavaScript (ES6), 89 84 82 78 73 bayt

0 indeksleme kullanarak girdiyi 3 tam sayı dizisi olarak alır.

a=>(o=a=>F()<0?a*n:a+n)(o((F=_=>n='5445054524413452545'[a.shift()]-3)()))

Test durumları

let f =

a=>(o=a=>F()<0?a*n:a+n)(o((F=_=>n='5445054524413452545'[a.shift()]-3)()))

console.log(f([3, 4, 4]))     // =>  18
console.log(f([4, 4, 4]))     // =>  -27
console.log(f([12, 12, 12]))  // =>  0
console.log(f([0, 1, 2]))     // =>  4
console.log(f([6, 4, 5]))     // =>  -1
console.log(f([15, 1, 18]))   // =>  2
console.log(f([18, 6, 11]))   // =>  -6

Önceki sürüm, 78 bayt

Körleme sözdizimindeki 3 tam sayıyı (a)(b)(c)0 indeksleme kullanarak alır.

a=>b=>(o=a=>b=>(n=F(b))<0?a*n:a+n)(o((F=n=>'5445054524413452545'[n]-3)(a))(b))

Nasıl çalışır

Bu kodla ilgili sıra dışı bir şey, "genel" körleme sözdiziminde sadece 2 argüman alması a => b =>ve en sonunda 3. kodu alan bir işlev döndürmesidir.

Yıkmak

F = n => '5445054524413452545'[n] - 3
o = a => b => (n = F(b)) < 0 ? a * n : a + n
f = a => b => o(o(F(a))(b))

f(a)(b)(c)
  |  |  |
  |  |  +-- 'b' argument of the function returned by the outer call to 'o'
  |  +----- 'b' argument of the function returned by 'f'
  +-------- 'a' argument of 'f'

Test durumları

let f =

a=>b=>(o=a=>b=>(n=F(b))<0?a*n:a+n)(o((F=n=>'5445054524413452545'[n]-3)(a))(b))

console.log(f(3)(4)(4))     // =>  18
console.log(f(4)(4)(4))     // =>  -27
console.log(f(12)(12)(12))  // =>  0
console.log(f(0)(1)(2))     // =>  4
console.log(f(6)(4)(5))     // =>  -1
console.log(f(15)(1)(18))   // =>  2
console.log(f(18)(6)(11))   // =>  -6

Befunge, 74 73 bayt

>&:0`!#^_1g68*-^:0`!#v_+
^2112-212/11.012/212 >*
^   @.$<       >">"35*0p

Burada dene! Kodumun sadece bu tercüman üzerinde çalışması garip.

İkinci satır temelde tablodaki tüm değerleri içerir. Sayısal olmayan değerler, ASCII tablosundaki basamaklardan önce gelen negatif değerlerdir. Sayının negatif olup olmadığını belirleyen bir miktar mantık var ve öyleyse bu sayı sonuçla çarpılır.

Üçüncü satırın sağ tarafı ilk sayıyı başlatır. Bunu yapmak zorunda olmasaydım, çok fazla bayt kurtarabilirdim.

PHP, 128 Bayt

$i="5445054524413452545";[,$a,$b,$c]=$argv;echo(bc.($i[$c]-3<0?mul:add))((bc.($i[$b]-3<0?mul:add))($i[$a]-3,$i[$b]-3),$i[$c]-3);

PHP, 138 Bayt

$d=decbin(506743);$i="5445054524413452545";[,$a,$b,$c]=$argv;echo(bc.($d[$c]?add:mul))((bc.($d[$b]?add:mul))($i[$a]-3,$i[$b]-3),$i[$c]-3);

Çevrimiçi sürüm

Expanded

$d=decbin(506743);
$i="5445054524413452545";
[,$a,$b,$c]=$argv;
echo(bc.($d[$c]?add:mul))((bc.($d[$b]?add:mul))($i[$a]-3,$i[$b]-3),$i[$c]-3);

Python 2 , 123 110 107 bayt

a,b,c=input()
s=[int(i)-3for i in'05445054524413452545']
n=s[a]
for i in s[b],s[c]:n=[n*i,n+i][n>0]
print n

Çevrimiçi deneyin!

@ Mathjunkie sayesinde -3 bayt

05AB1E , 29 bayt

•6SÚ²ÄOÕ6BS3-©¹è|v®yèD0‹i*ë+

Çevrimiçi deneyin!

•6SÚ²ÄOÕ6BS3-©               # Push [2, 1, 1, 2, -3, 2, 1, 2, -1, 1, 1, -2, 0, 1, 2, -1, 2, 1, 2] and store.
               ¹è             # Get first score.
                 |v           # Iterate through remaining scores.
                   ®yèD0‹i*ë+ # Push score list, grab relevant score.
                              # If negative, multiply, else add.

Bu aslında istediğiniz kadar çok veya az girdi için çalışır, bu nedenle 4 veya daha fazla özelliği olan veya sadece 2 olan arabalara sahip olabilirsiniz.

CJam , 43 38 bayt

q~[YXXY-3YXYWXX-2TXYWYXY]f={_W>42+c~}*

Listeyi daha fazla sıkıştırmanın bir yolu olabilir ...

0 tabanlı endeksleme kullanır.

Çevrimiçi deneyin!

açıklama

Bu program, bir değerin, yalnızca negatifse eklenirse, katkı maddesi yerine çarpımcı olduğu gerçeğinden faydalanır.

q~                     e# Get the list from input
  [...]                e# Push the list of values for each ingredient. T=0, W=-1, 
                       e#   X=1, Y=2. 
       f=              e# Get the elements at the given indices 
         {             e# Reduce over this block:
          _W>          e#  Check if the second number is > -1 (returning 0 or 1)
             42+c      e#  Add the result to 42 and cast to a char. 
                       e#    (ASCII 42 is * and 43 is +)
                 ~     e#  Eval the char (* is multiply, + is add)
                  }*   e# (end block)

Lua, 140 131 bayt

i={2,1,1,2,-3,2,1,2,-1,1,1,-2,0,1,2,-1,2,1,2}function f(a,b,c)loadstring(("print("..i[a].."+"..i[b].."+"..i[c]..")"):gsub('%+%-','*-'))()end

i={2,1,1,2,-3,2,1,2,-1,1,1,-2,0,1,2,-1,2,1,2}function f(a,b,c)x,y,z=i[a],i[b],i[c]v=y>0 and x+y or x*y;print(z>0 and v+z or v*z)end

JavaScript, 85 72 bayt

a=a=>eval(a.map(x=>(b="5445054524413452545"[x]-3,b<0?"*":"+")+b).join``)

[a,b,c]
ETHproductions sayesinde -13 byte formatında girdi aldı

R, 125 123 bayt

function(a,b,c){v=c(5,4,4,5,0,5,4,5,2,4,4,1,3,4,5,2,5,4,5)-3
o=rep("+",19)
o[v<0]="*"
get(o[c])(get(o[b])(v[a],v[b]),v[c])}

Girdi olarak üç tamsayı alan adsız işlev. Değerlerin ve işlemlerin bir listesini tanımlar ve ardından sadece girdi tarafından adlandırılanları değerlendirir o3(o2(v1,v2),v3). Bunu yapmanın neredeyse kesin bir yolu var!

Güncelleme: bazı yeniden çalıştıktan sonra, bir alternatif var, ayrıca 123 byte . Yine anonim bir işlev, ancak girişi üç değerden oluşan tek bir vektör olarak alır. Aynı yaklaşımı kullanır, değer ve işlemlerin bir listesini tanımlar ve değerlendirir.

function(x,f=c(sum,prod)[x[-1]%in%c(5,9,12,16)+1],s=c(5,4,4,5,0,5,4,5,2,4,4,1,3,4,5,2,5,4,5)[x]-3)f[[2]](el(f)(s[-3]),s[3])

Haskell, 186 116 112 108 bayt

o x|x<0=(*)|0<1=(+)
v=(map((-51+).fromEnum)"95445054524413452545"!!)
w [x,y,z]=(o z)((o y)x y)z
k=w.map v

Ana işlevi k. Code Golf'te yeni olanlara göre, $operatöre parantez kullanma konusunda zekice kullanıldığında tıraş olabileceğim birkaç bayt olduğundan eminim . İyileştirmeler bulmaya devam ederken muhtemelen cevabı güncelleyeceğim.

Temel olarak program şu şekilde bozulabilir:

• v, 1 tabanlı bir dizin alan ve o gıda kimliğinin değerini döndüren bir işlevdir.
• o, yiyecek değerini alan ve uygun operatörü veren bir fonksiyondur (Örneğin, negatif değerler her zaman *pozitif değerlerin olduğu yerlerdir +)
• w, vgiriş tam sayılarına eşlenen 3 kısmi fonksiyonun bir Listesini alan ve her birinden uygun işlemleri ve değerleri alan ve uygun çıktıyı döndüren bir fonksiyondur.
• k, giriş için v'yi eşleyen ve çıktısını geri döndürmek için bu listeyi oluşturan nokta serbest stildeki ana işlevdir.

GÜNCELLEŞTİRME

FromEnum numarasına dikkat çektiğiniz için özel teşekkürler! Bu güzel çalıştı. Ayrıca kabul edilebilir bir çözümün tamsayıların listesini alan bir işlev olabileceğini belirttiği kurallardaki kısmı kaçırdım. Bu muazzam miktarda iş kurtardı.

GÜNCELLEME 2

Diğer önerilere göre, işlemleri yeniden sıralayarak bir avuç bayt'ı traş ederek, her zaman Doğru olarak değerlendiren başka bir koruma ve W ile eşleşen bir öğeyi 3 öğenin bir Listesinde eşleşen bir desen oluşturarak tıraşla. Önerileriniz için teşekkürler!

GÜNCELLEME 3

Laikoni'ye bilmediğim daha fazla kod golf kurallarına işaret ettiği için bir kez daha teşekkürler. Ayrıca kısmen uygulanan fonksiyonların bir listesini oluşturmak için girişimi v ile eşleştirmek olağanüstü bir fikirdi ve bana 4 ek bayt kazandırdı!

Haskell, 92 87 bayt

x#y|x<0=(y*)|0<1=(y+)
k[x,y,z]=z#z$y#x$y
k.map([read[q]-3|q<-"95445054524413452545"]!!)

Çevrimiçi deneyin!

@ Maple_shaft'ın cevabına göre, ben sadece onu biraz faktörledim.

5 byte için @Likonikoni'ye teşekkürler!

C, 171 161 bayt

#include<stdio.h>
r,z[3],*a=z,i;f(x){i?x<0?r*=x:(r+=x):(r=x);}main(){scanf("%d %d %d",a,a+1,a+2);for(;i++<3;f("05445054524413452545"[*a++]-51));printf("%d",r);}

8086 makine kodu, 62 bayt

00000000  be 3b 01 31 c0 86 c4 ac  e8 0a 00 81 fe 3e 01 72  |.;.1.........>.r|
00000010  f4 b4 4c cd 21 bb 32 01  d0 e8 d7 73 03 c0 e0 04  |..L.!.2....s....|
00000020  c0 f8 04 e3 05 31 c9 c3  86 c4 78 03 00 e0 c3 f6  |.....1....x.....|
00000030  ec c3 21 12 d2 12 f1 1e  01 2f 12 00 00 00        |..!....../....|
0000003e

Son üç bayt (sıfır dizine alınmış) girişi içerir. Hey, bana en uygun giriş formatını kullanabileceğimi söyledin. Bu durumda, bu kodlama!
Çıktı, kabuğa döndürülen hata kodudur.

Nasıl çalışır:

            |   org 0x100
            |   use16
be 3b 01    |       mov si, input   ; source = input
31 c0       |       xor ax, ax      ; clear ax
86 c4       |   @@: xchg al, ah     ; swap al/ah (ah = total value)
ac          |       lodsb           ; al = *si++
e8 0a 00    |       call fn
81 fe 3e 01 |       cmp si, input+3 ; end of input?
72 f4       |       jb @b           ; repeat if not
b4 4c       |       mov ah, 0x4c    ; dos function: exit with al=error code
cd 21       |       int 0x21        ; syscall
            |
bb 32 01    |   fn: mov bx, table   ; pointer to lookup table
d0 e8       |       shr al, 1       ; divide input by 2
d7          |       xlatb           ; al = *(bx + al)
73 03       |       jnc @f          ; skip next instruction if input was odd
c0 e0 04    |       shl al, 4       ; shift low nibble to high nibble
c0 f8 04    |   @@: sar al, 4       ; shift high nibble to low nibble with sign-extension
e3 05       |       jcxz @f         ; return if cx is non-zero (only happens for the first input)
31 c9       |       xor cx, cx      ; clear cx
c3          |       ret
86 c4       |       xchg al, ah     ; swap al/ah (al = total value)
78 03       |   @@: js @f           ; multiply if negative, add if positive
00 e0       |       add al, ah      ; al = al+ah
c3          |       ret
f6 ec       |   @@: imul ah         ; ax = al*ah
c3          |       ret
21 12 d2 12 |   table db 0x21, 0x12, 0xd2, 0x12, 0xf1, 0x1e, 0x01, 0x2f, 0x12
f1 1e 01 2f |                       ; each value is stored in a 4-bit nibble
12          |
00 00 00    |   input db 3 dup(0)