Tamam, yani dün 2. Noel günü oldu ve (büyük) ailem ve ben, Hollanda'da dendiği gibi bir "sjoelen" oyunu oynadık. İç programcı bana geldi, ama cevabı aldığımda onu kaybettim. Yeniden yapmanı istiyorum.

Kurallar:

Ahşap bir tahta, bir sjoelbak , her biri kendi numarasına sahip 4 kutu var. Bir schijf (Disk benzeri bir nesne) kutulardan birine girdiğinde, bu kutunun üstündeki puanları alırsınız.

Kutuların 4'ünde bir schijf olduğunda, 10 puan alamazsınız ancak 20 puan alırsınız.

Örnek:

Soldan sağa: 3 5 4 3
Her bir kutuda en az 3 schijven (çoğul schijf ) vardır, yani 20 * 3 = 60 puan.

Sonuç değerleri: 0 2 1 0
0 * 2 + 2 * 3 + 1 * 4 + 0 * 1 = 10 puan.

Toplamda 60 + 10 = 70 puan.

Giriş: Soldan sağa schijven
miktarı , yani "4 5 4 5", [4,5,4,5], "4 \ n5 \ n4 \ n5", ne istersen.

Çıktı:
Sayı, yani 84, çıktı, değişken, geri dönüş veya yığının tepesinde, ne istersen.

Her kod golfünde olduğu gibi, dış komut dosyalarını ve en az baytlık kodu içeren kodu kullanamazsınız.

Not: Daha önce fark etmiş olabileceğiniz gibi, ben Hollandalıyım. Olası dilbilgisi hatalarını düzenlemek için çekinmeyin.

CJam, 23 21 20 bayt

q~_$0=f+1m>{X):X*+}*

Bundan bir kaç baytlık golf oynayabilirim.

Giriş gibidir

[3 5 4 3]

Çıktı skor

70

Nasıl çalışır

q~                         "Read the input and evaluate into an array";
  _$0=                     "Copy the array, sort it and get the minimum number";
                           "This minimum is the number of common schijven";
      f+                   "Increment each of the schijven by the common schijven number"; 
        1m>                "Take 1 element from the end of the array and put";
                           "it in the beginning";
           {      }*       "Reduce the elements of the array based on this block";
            X):X           "Increment and update the value of X (initially 1)";
                *          "Multiply the number of schijven with X";
                 +         "Add it to current score";

Algoritma

• Schijven sayısını doğru değiştirdiğim için, puan sırası şimdi oldu [1 2 3 4].
• Dahası, bu gerçeği kullanarak, 1 + 2 + 3 + 4 = 10ikramiye 10puanının etkisini almak için her birine minimum ortak schijven ekliyorum .
• Azalttığımda, başlangıçta yığında 2 elementi alıyorum, ilk önce görmezden geldiğim, 1her birinin puanına sahip olanı , sonra ikincisini çarpıp ilkine 2ekliyorum. Bir sonraki yinelemede, mevcut toplamı ve puanı 3schijven'i alıyorum. Ve bunun gibi.

Burada çevrimiçi deneyin

Piet, 240 (30 * 8) kodeller, 138 gerçek kod içeren

Daha iyi görünürlük için kodel boyutu 10

Test örnekleri:

D:\codegolf\npiet-1.3a-win32>npiet sjoelen_point_count_cs10.png
? 3
? 5
? 4
? 3
70
D:\codegolf\npiet-1.3a-win32>npiet sjoelen_point_count_cs10.png
? 4
? 5
? 4
? 5
84

Akış göstergesi:

Kolay kullanım ve kompakt ekran için kendi stenoyumu kullanma. Kodellerin tam yerlerini değil genel program akışını gösterir.

NOP ADD DIV GRT DUP INC END
 0   +   /   >   =   c   ~
PSH SUB MOD PTR ROL OUN
 X   -   %   #   @   N
POP MUL NOT SWI INN OUC
 ?   *   !   $   n   C

1X!nnnn=5X2X@=5X2X@=5X2X@=5X1X@**
       0                        *
       0       @+5X1X@1X-4X1X@  !
       0       -             0  !
       0       X1!X1X6+*==X40000#  <--pointer if top of stack=1 (all boxes full,
       0                     0  2      add 20 points, decrement count for all boxes)
       0000-X1@X1X2-X1@X1X3-X1  X  |  pointer if top of stack=0 (not all boxes full,
                                *  V   add 2a+3b+4c+d)
           ~N++++*X4@X2X3*X3@X1X2

Tam açıklama:

      (score=0)  a   b   c   d
      1 PSH NOT INN INN INN INN

      ..... sort and duplicate the numbers .....
**1** DUP 5 PSH 2 PSH ROL DUP 5 PSH 2 PSH ROL DUP 5 PSH 2 PSH ROL DUP 5 PSH 1 PSH ROL

      ( a*b*c*d ) (convert to boolean) 1 if all boxes are full, 0 if at least one box is empty
      MUL MUL MUL NOT NOT

      change direction if 1 (**2**)
      go straight ahead if 0 (**3**)
      PTR

      ( compress 20=4*4+4 )       (0-1=-1/ neg. roll) score+20
**2** 4 PSH DUP DUP MUL ADD 6 PSH 1 PSH NOT 1 PSH SUB ROL ADD

      (put score back to bottom of stack) ... a=a-1, b=b-1, c=c-1, d=d-1 ...
      5 PSH 1 PSH ROL 1 PSH SUB 4 PSH 1 PSH ROL 1 PSH SUB 3 PSH
      1 PSH ROL 1 PSH SUB 2 PSH 1 PSH ROL 1 PSH SUB

      loop to **1**

      (   a*2   )               (   b*3   )               (  c*4  )
**3** 2 PSH MUL 2 PSH 1 PSH ROL 3 PSH MUL 3 PSH 2 PSH ROL 4 PSH MUL

      +2a +3b +d +score
      ADD ADD ADD ADD

      output score
      OUN

Resmi kaydedin ve bu çevrimiçi Piet tercümanında deneyin:

PietDev çevrimiçi Piet tercüman

APL (Dyalog Klasik) , 16 13 12 bayt

-3 @ Adám sayesinde

(+/+\)1⌽⌽+⌊/

Çevrimiçi deneyin!

⌽+⌊/ reverse (arg) + dak (arg)

1⌽ 1 sola döndür

+\ kısmi miktarlar

+/ toplam

Mathematica, 38 32 23 20 bayt

(#+Min@#).{2,3,4,1}&

( Swish'in yardımı ile )

Girişi sonuna kadar dokunarak kullanın:

(#+Min@#).{2,3,4,1}&@{3,5,4,3}

70

Alternatif (36 bayt):

20*Min@#+Total[(#-Min@#)*{2,3,4,1}]&

R, 41 40 karakter

b=min(a<-scan());sum(5*b+(a-b)*c(2:4,1))

Kullanımı:

> b=min(a<-scan());sum(5*b+(a-b)*c(2:4,1))
1: 4 5 4 5
5: 
Read 4 items
[1] 84
> b=min(a<-scan());sum(5*b+(a-b)*c(2:4,1))
1: 3 5 4 3
5: 
Read 4 items
[1] 70

Son örnekte, avektör 3 5 4 3, a-bbir 0 2 1 0, ki biz çarpma vektör ile 2 3 4 1bağlanabilir, böylece 0 6 4 0biz ek getiren 5*bveren 15 21 19 15( 5*bbu nedenle etkin bir şekilde ilave edilmesi, ilave vektörün her üyesi için geri dönüştürülerek 4*5*bböylece, sonunda toplamı olan) elde 70.

JavaScript (ES6), 93 47 bayt

s=(a,b,c,d)=>10*Math.min(a,b,c,d)+a*2+b*3+c*4+d

Kullanımı: s(1, 2, 3, 4)

Nasıl çalışır: işlev, argümanlarda en küçük sayıyı arar ve bunu 10(ile değil) ile çarparak 20puanın geri kalanını ekler. 20Hesaplamaya devam etmek için puanları çarpıp puandan çıkarmak gerekmez .

Paylaşım geliştirmeleri için edc65'e teşekkürler!

Un-golfed:

function score(a, b, c, d) {
    return 10 * Math.min(a, b, c, d) + a * 2 + b * 3 + c * 4 + d;
}

Pyth , 15

sm*hd+@QtdhSQUQ

Girdi, STDIN'de örneğin virgülle ayrılmış olarak verilmelidir, örneğin

3,5,4,3

Bu, bonusu hesaba katmak için her bir öğeye minimum ekleyerek, birçok başka çözümün kullandığı hileyi kullanır. Asgari hSQyukarıdaki kodda. 2, 3, 4 ve 1 ile çarpımı hesaba katmak için, d'yi [0,1,2,3] listesinin üzerinde eşlerim ve girişin (dl) th elemanını d + 1 ile çarparım. Böylece, -1. Eleman 1 ile, sıfırla 2 ile, ilki 3 ile ve ikincisi 4 ile çarpılır. Sonra toplarım.

J, 23 22 karakter

   (+/ .*&2 3 4 1@(+<./))

Örnek:

   test =. 3 5 4 3
   (+/ .*&2 3 4 1@(+<./)) test
70

Burada dene.

(23 uzun açık fonksiyon tanımlama: v=:3 :'+/+/\.3|.y+<./y')

Devekuşu v0.1.0 , 48 41 karakter _{^{(çok uzun)}}

.$0={}/:n;{n-}%)\+1:i;{i*i):i;}%{+}*20n*+

Bu, @tüm yığını döndürmek yerine kullanmak yerine )\+(right uncons) kullanılması dışında, aşağıdaki eski sürümle aynıdır .

Eski versiyon:

.$0={}/:n;{n-}%{}/{4@}3*1:i;]{i*i):i;}%{+}*20n*+

Yeni açıkladığım dilde, aşağıdaki açıklamaya eklenmiş iki hata keşfettim. (Dil şu anda Golfscript'e çok benzer, bu nedenle Golfscript'i biliyorsanız, okuması oldukça kolay olmalıdır.

.$0=   get min value (for the *20 thingy)
{}/    *actually* get min value (BUG: `array number =' returns a single-element array...)
:n;    store as n
{n-}%  subtract this value from all array elements
{}/    dump array onto stack
{4@}3* rotate stack so that instead of 2 3 4 1, multipliers are 1 2 3 4
       (BUG: negative rotations don't work)
1:i;   set i (the multiplier) to 1
]{i*   multiply each array element by i
i):i;  increment i
}%     (do the previous 2 lines over each array element)
{+}*   add up all the array elements
20n*+  add 20*n (the min value we got in line 1)

Girişin STDIN'de bir dizi olmasını bekliyor, çünkü ben bir kapı tokmağım ve v0.1.0'da G / Ç'yi uygulamayı unuttum.

Gerçek bir problemi devekuşu içinde çözmek çok güzel, çünkü bana dile nasıl daha fazla şey eklemem gerektiğini gösteriyor: D

Python 2, 43 bayt

lambda i:i[1]-i[3]+2*(sum(i)+i[2]+5*min(i))

@ User2487951 adlı kullanıcının yanıtından ilham aldı.

Jagl Alpha 1,2 - 20 bayt

Girdi biçiminde stdin biçiminde (3 4 5 6), çıktı yığında bırakılmıştır:

T~dqZ*S1 5r]%{U*}/b+

Orijinal posterden çıktı formatı hakkında bir cevap bekliyorum. Girdi "ne istersen" olarak belirtildiğinden , girişimin yığının en üstünde bir dizi olabileceğini farz edeceğim. Şimdi stdin ile ilgili girdi alıyor.

Açıklama:

T~                            Get input from stdin and evaluate
  dqZ*                      Duplicate, get minimum, and multiply that by 10
      S1 5r]                Swap (so array is on top), push range 1-5 exclusive, and rotate
            %{U*}/          Zip arrays together, and multiply each pair
                  b+P       Get the sum of that, add the common minimum, and print

Haskell, 40

g l@[a,b,c,d]=2*a+3*b+4*c+d+10*minimum l

minimum sayıyı diğerlerinden kaldırmak ve ek 20s eklemek yerine , bu 10minimum sayı için ekler .

Matlab, 27

Tek oyunculu oyun olduğunu anlamam biraz zaman aldı. Anonim işlev yardımı ile

f=@(N)N*[2;3;4;1]+10*min(N)

satır vektörü ile çağrılan

f([3 5 4 3]) == 70
f([7 7 9 7]) == 148

Java, 84 bayt

int A(int[]a){int m=9;for(int i:a)m=i<m?i:m;return 10*m+a[3]+2*a[0]+3*a[1]+4*a[2];}

Bunun daha fazla golf oynayabileceği fikrine sahibim ama bu şimdilik.

Çağrılarla A(new int[]{3,5,4,3})çıkış int olarak döndürülür (çünkü System.out.println()baytları iki katına çıkarır)

Ungolfed

int getScore(int[] input){
    int min=9;

    for(int x:input) {
        if(x<min){
            min=x;
        }
    }

    return 10*min + 2*input[0] + 3*input[1] + 4*input[2] + 1*input[3];
}

GolfScript, 22 bayt

~3,{1$>~;}%+$(11*+{+}*

Stdin'den girdi biçiminde okur [3 5 4 3]. Çıkışı stdout'a yazar. (Girdiyi yığında bir dizi olarak almak izin verilirse, öncü ~toplam 21 bayt atlanabilir.)

Bu, CJam / Pyth / etc. çözümlerinden biraz farklı bir strateji kullanıyor: İlk önce ilk giriş değerinin 2 kopyasını, ikincisinin 3'ünü, üçüncüsünün 4'ünü ve dördüncüsünü içeren bir dizi oluşturdum. Sonra bu diziyi sıralarım, en küçük elemanı çıkartın, 11 ile çarpın ve diğer elemanlarla toplayın.

Python 2, 51

Yetersiz, ancak kısa:

l=input()
print l[0]*2+l[1]*3+l[2]*4+l[3]+10*min(l)

Daha pitonik:

l=input()
print sum(map(lambda x,y:x*y,l,[2,3,4,1]))+10*min(l)

Julia 48 35 karakter

function p(m);sum([2 3 4 1].*m)+10minimum(m);end

Kompakt atama şeklinde:

p(m)=sum([2 3 4 1].*m)+10minimum(m)

Örnek:

julia> p([3 5 4 3])
70

Javascript, 97 bayt

a=prompt().split(" "),b=Math.min.apply(1,a);alert(20*b+2*(a[0]-b)+3*(a[1]-b)+4*(a[2]-b)+(a[3]-b))

Javascript, ES6, 57

f=(a,b,c,d)=>a*b*c*d?20+f(--a,--b,--c,--d):a*2+b*3+c*4+d

Özyinelemenin nasıl sonuçlanacağını görmek istedim ve kesinlikle en kısa cevap olmasa da iyi sonuçlandığını hissettim.

a*b*c*d: Girdi değerlerini alır ve hepsinin ürününü bulur ve bunu bir satır içi if ifadesi için bir Boole ifadesi olarak değerlendirir. Değerlerden biri veya daha fazlası 0 ise, false döndürür ve diğer değerler için true olur.

20+f(--a,--b,--c,--d): Doğru dönerse, işlev 20 ( schijven kümesi için) artı işlevin özyinelemeli çağrısını eksi bir değer için döndürür (bu schijven kümesini kaldırmak için ). Bu şekilde, kutulardan en az biri boş kalana kadar tekrarlı bir şekilde tekrar eder.

a*2+b*3+c*4+dEn az bir kutu boş bıraktıktan sonra, ifade çalıştırılacaksa satır içi kısmının diğer kısmı. Sadece kutularda kalan schijven puanını döndürür .

Böylece sonuçta, 20 nokta schijven setinin tamamı ve kalan nokta toplanır ve fonksiyondan döndürülerek cevap üretilir.

Haskell 42 karakter

f l=10*minimum l+sum(zipWith(*)[2,3,4,1]l)

HPPPL (HP Prime Programlama Dili), 58 57 bayt

* 10 ile min arasındaki değerler gerekli değil, ben de kaldırdım.

EXPORT s(m)
BEGIN
return sum([2,3,4,1].*m)+10min(m);
END;

HPPPL, HP Prime renkli grafik hesap makinesi / CAS'ın programlama dilidir.

Örnek çalıştırır:

Bir program olmak zorunda değilse, o zaman bir programda gerçekleştirilebilir 40 39 bayt bir liner:

m:=[3,5,4,3];sum([2,3,4,1].*m)+10min(m)

Staq, 72 karakter

't't't't{aii*XX}$&iia$&ia$&a+XX+XX+|{mxx}{lxX}{k>?m!l}kkk&iiqi&ii*s*t|+:

Örnek çalışma:

Executing D:\codegolf\Staq\sjoelen codegolf.txt

3
5
4
3
70

Execution complete.
>

Staq'ın biri aktif, biri pasif olmak üzere iki yığını vardır. |Komut pasif ve tersi aktif yığın geçer.

Kıvrımlı ayraçlar arasındaki her şey bir işlevi tanımlar; açılış ayracından sonraki ilk harf, işlev adıdır, geri kalan kısmı da fonksiyonun kendisidir. Geçersiz kılma fonksiyonları, özyineleme ve iç içe geçmiş fonksiyonlar mümkündür. {aii}Bir fonksiyon tanımlamak a iki yığının üst artırmak olacaktır. aKodun her bir aşağıdaki örneği değiştirilecektir ii.

Staq prorams içindeki yorumlar : &yığının üstüne bir sıfır ekler, yığının tepesi sıfır [ise işaretçiye karşılık gelen zıplamayı söyler ], yığındaki xen üst değeri siler. Böylece, yorumlar şeklinde kod içine yazılabilir&[here is a comment]x

Açıklama (ayrıca çalıştırılabilir):

'                                      &[input number]x
 t                                     &[copy top of active stack to passive stack]x
  t't't                                &[input next three numbers and copy them to the passive stack]x
       {aii*XX}                        &[define function a (increment twice, multiply the two topmost values, then delete the second value on the stack twice)]x
               $                       &[move top value to the bottom of the stack]x
                &ii                    &[put zero on top of the stack, incremment twice]x
                   a                   &[function a]x
                    $&ia$&a
                           +           &[put sum of the two topmost values on top of the stack]x
                            XX         &[delete second stack value, twice]x
                              +XX+
                                  |    &[switch active/passive stack]x
{mxx}                                  &[define function m: delete two topmost stack values]x
     {lxX}                             &[define function l: delete topmost stack value, then delete second value of remaining stack]x
          {k>?m!l}                     &[define function k: boolean top > second value? put result on top of the stack, if top>0 then execute m, if top = 0 then execute l]x
                  kkk&ii
                        q              &[put square of top value on top of the stack]x
                         i&ii
                             *         &[multiply two topmost values and put result on top of the stack]x
                              s        &[move bottom stack value to the top]x
                               *t|+
                                   :   &[output result]x

https://esolangs.org/wiki/Staq

Program, 2a + 3b + 4c + d'yi hesaplamak için bir yığını (başlangıçta aktif) ve ikinci değeri (başlangıçta pasif) giriş değerlerinin minimumunun 10 katını hesaplamak için kullanır. Sonra her iki sonuç da toplanır ve gösterilir.

PowerShell for Windows , 48 47 bayt

^{Mazzy sayesinde -1 bayt}

$args|%{$a+=++$i%4*$_+$_}
$a+10*($args|sort)[0]

Çevrimiçi deneyin!