Sahne:

Brian aniden inhalerine çok ihtiyaç duyduğunda Peter, arkadaşı Brian'la birlikte spor salonundadır. Brian, Peter'ı yere çökmeden önce şifreli kilidine söylemeyi başarır.

Peter Brian'ın dolabına ulaştığında ve göstergenin neye işaret ettiğini gördüğü anda, Stewie onu pusuya düşürür ve yüzüne dolu bir kutu biber spreyi püskürterek Peter'ı kör eder.

Peter şimdi kilidi bakmadan açmaya çalışmalı. Kadranı sağa çevirmeye başlar, geçerken sayıları sayar. Daha sonra doğru numarada kadranı sola döndürmeye başlar, hala saymaya başlar ve son olarak kilit açılana kadar sağa döndürür.

Meydan okuma:

Brian'ın kombinasyonu ve gösterge konumu olmak üzere iki giriş alan bir işlev / program yazın. Peter'ın sayması gereken sayıları çıkar.

Kurallar:

• Kombinasyon ve gösterge konumu ayrı argümanlar olmalıdır.
• Giriş, komut isteminden veya işlev bağımsız değişkenleri olarak olabilir.
• Çıktı ekrana yazdırılmalı / başka şekilde görüntülenmeli (dosyaya değil)
• Başlangıç ​​konumunun ilk sayı ile aynı olmadığını ve kombinasyondaki her üç sayının da benzersiz olduğunu varsayalım
• Aşağıdaki resimde gösterilen kilitler, olası sayılarla: 0-39.

Talimatlar:

Aşağıdaki kilidi açmak için bir dizi talimatı izlemeniz gerekir:

1. Kodunuzu bilmelisiniz. Şimdilik (38, 16, 22) olduğunu varsayın.
2. Kadranı 3 kez sağa çevirin (başlangıç ​​numarasını üç kez geçirin), ardından ilk sayı (38) göstergeyle hizalandığında durun
3. İlk numarayı geçerek kadranı 1 tam tur sola çevirin ve ikinci sayı (16) gösterge ile hizalandığında durun.
4. Kadranı sağa çevirin ve üçüncü sayı (22) gösterge ile hizalandığında durun
5. Kilidi aşağı çekin

Örnek:

Input
38 16 22
33  

Output
33  32  31  30  29  28  27  26  25  24  23  22  21  20  19  18  17  16  15  14  13  12  11  10   9   8   7   6   5   4   3   2   1   0  39  38  37  36  35  34  33  32  31  30  29  28  27  26  25  24  23  22  21  20  19  18  17  16  15  14  13  12  11  10   9   8   7   6   5   4   3   2   1   0  39  38  37  36  35  34  33  32  31  30  29  28  27  26  25  24  23  22  21  20  19  18  17  16  15  14  13  12  11  10   9   8   7   6   5   4   3   2   1   0  39  38  37  36  35  34  33  32  31  30  29  28  27  26  25  24  23  22  21  20  19  18  17  16  15  14  13  12  11  10   9   8   7   6   5   4   3   2   1   0  39  38  39   0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20  21  22  23  24  25  26  27  28  29  30  31  32  33  34  35  36  37  38  39   0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  15  14  13  12  11  10   9   8   7   6   5   4   3   2   1   0  39  38  37  36  35  34  33  32  31  30  29  28  27  26  25  24  23  22

Standart kod golf kuralları geçerlidir.

Daha sonra gönderilen çözümler, Dennis'in cevabından daha kısasa yine de kazanabilir.

CJam, 52 39 bayt

q~[3X0].{@40,m<1$({(+W%}&:T*T@#)T<)}e_p

CJam yorumlayıcısında çevrimiçi deneyin .

Nasıl çalışır

q~      e# Read and evaluate all input. This pushes the initial position
        e# as an integer and the combination as an array.
[3X0]   e# Push [3 1 0]. This encodes the respective numbers of full turns
.{      e# For each number in the combination (N) and the corresponding 
        e# number of full turns (F):
  @     e#   Rotate the initial position on top of the stack.
  40,m< e#   Push [0 ... 39] and rotate it that many units to the left.
        e#   For position P, this pushes [P P+1 ... 39 0 ... P-2 P-1].
  1$(   e#   Copy F and subtract 1.
  {     e#   If the result is non-zero:
    (+  e#     Rotate the array of length 40 one unit to the left.
    W%  e#     Reverse it.
  }&    e#   For position P, this pushes [P P-1 ... 0 39 ... P+2 P+1].
  :T*   e#   Save in T and repeat the array F.
  T@    e#   Push T. Rotate N on top of the stack.
  #)    e#   Find the index of N in T and add 1 to it.
  T<    e#   Keep that many elements from the beginning of T.
  )     e#   Pop the last element of the result (N).
}       e# N is the new initial position.
e_p     e# Flatten the resulting array and print it.

Groovy, 189175 bayt

Göstergenin arg0 olarak iletildiğini ve combo'nun komut satırında arg1, arg2 ve arg3 olarak iletildiğini varsayar ...

i=(args[0]as int)+1
r={i--;i=i<0?39:i;print"$i "}
l={i=++i%40;print"$i "} 
M={j,c->while(i!=j as int){c()}}
120.times{r()}
M(args[1],r)
40.times{l()}
M(args[2],l)
M(args[3],r)

Perl 5 , 129 + 1 (-a) = 130 bayt

sub c{$f=pop;do{say$f;$f+=$_[0];$f=$f==-1?39:$f==40?0:$f}while$f-$_[1]}$p=3;c(2*!$p-1,@F[$_,$p]),$p=$_ for 3,3,3,0,0,1,2;say$F[2]

Çevrimiçi deneyin!

Nasıl?

sub c{                       # Takes 3 parameters: increment, ending position, starting position
  $f=pop;                    # first place to start counting
  do{
    say$f;                   # output current position
    $f+=$_[0];               # move position
    $f=$f==-1?39:$f==40?0:$f # roll over when passing zero
  }while$f-$_[1]             # stop when ending positition reached
}

# @F gets defined by the -a command line option
# @F holds the combination followed by the starting position

$p=3;                       # starting position is in array index 3, this variable will track the array index of
                            # the current position on the dial

c(2*!$p-1,@F[$_,$p]),$p=$_  # call the movement function (c), setting direction to the left (1) or right (-1) as needed
                            # based on the array index of the previous position (go left when moving from array index 0)
for 3,3,3,0,0,1,2;          # list of the array index of the next position

say$F[2]                    # output final position

Python 2, 262 bayt

Çok uzun hissettiriyor. Ama aynı zamanda bir sürü dönüş var.

def f(l,s):
 r=lambda a,b,c=1:range(a,b,c)
 a=r(39,l[0],-1);b=r(l[0],-1,-1)
 c=r(l[1],l[2]-1,-1)if l[2]<l[1]else r(l[1],-1,-1);c.extend(r(39,l[2]-1,-1))
 return'  '.join(`x`for x in sum([r(s,-1,-1),a,b,a,b,a,b,r(39,l[0],-1),r(l[0],40),r(0,40),r(0,l[1]+1),c],[]))

Çevrimiçi deneyin!

Ben son satırda bazı parçaları daha iyi birleştirebilirsiniz düşünüyorum ama ben hala golf kod yeni ve ben kısa bir şekilde bu liste kombinasyonu ele nasıl bilmiyorum.

Bunu geliştirmek için herhangi bir fikir var mı?

Haskell , 135111 bayt

s!t=[s..39]++[0..mod(t-1)40]
s#t=[s,s-1..0]++[39,38..mod(t+1)40]
(a%b)c s=[s#s,s#s,s#s,s#a,a!a,a!b,b#c,[c]]>>=id

Çevrimiçi deneyin!

Laikoni sayesinde 23 bayt kurtardı