Sie sollten ein Programm oder eine Funktion schreiben, die eine Startreihenfolge von eindeutigen positiven Ganzzahlen mit einer Ziffer und die Länge der Spur als Eingabe ausgibt oder die Endreihenfolge der Zahlen zurückgibt.

Die Eingabe [5,1,2,6,7] and 14definiert die folgende Rasse:

--------------
76215 ->
--------------

Regeln des Rennens

• Die Strecke wird umbrochen und die Ziffern können mehrere Runden lang sein.
• Die Reihenfolge der Schritte ist zyklisch und basiert auf der Startposition. In unserem Beispiel 5 1 2 6 7 5 1 2 ....
• Es können nicht mehrere Ziffern an derselben Position stehen.

• Jede Ziffer hat eine Geschwindigkeit von digit_valueZelle pro Schritt. Das Überholen einer Ziffer oder eines fortlaufenden Ziffernblocks kostet einen zusätzlichen Schritt. Wenn die Ziffer nicht die dafür erforderliche Geschwindigkeit hat, stoppt sie vor der (dem) Ziffernblock (en). Beispiele:

  [41   ] => [ 1 4 ]  4 overtakes 1
  
  [2 1  ] => [ 21  ]  2 can only move 1 as it can't move 3 to overtake 1
  
  [4 12 ] => [ 412 ]  4 can only move 1 as it can't move 5 to overtake 12     
  
  [   3 ] => [ 3   ]  3 starting a new lap
  

• Jede Ziffer muss digit_valueRunden drehen, bevor sie endet. Eine Runde ist beendet, wenn die letzte Zelle der Strecke verlassen wurde. Eine fertige Ziffer wird aus der Spur entfernt.

• Beachten Sie, dass eine Ziffer in einem Schritt möglicherweise mehrmals ihre Startposition erreicht und mehrere Runden absolviert.

Eingang

• Eine Liste eindeutiger positiver Ganzzahlen ( 1..9) mit mindestens einem Element und einer einzelnen positiven Ganzzahl, die größer als die Länge der Liste und die Länge der Spur ist.

Ausgabe

• Eine Liste der Ziffern in der Reihenfolge, in der sie in einem eindeutigen Format abgeschlossen wurden.

Beispiele

Ein visuelles Schritt-für-Schritt-Beispiel für die Eingabe starting_order = [5,9,2] and length = 6

295   | Start position
29   5| digit 5 moves
2  9 5| digit 9 moves, finishing lap #1
  29 5| digit 2 moves
 529  | digit 5 moves, finishing lap #1
 52  9| digit 9 moves, finishing lap #2
 5  29| digit 2 moves
   529| digit 5 moves
 9 52 | digit 9 moves, finishing laps #3 and #4
29 5  | digit 2 moves, finishing lap #1
29   5| digit 5 moves
2  9 5| digit 9 moves, finishing lap #5
  29 5| digit 2 moves
 529  | digit 5 moves, finishing lap #2
 52  9| digit 9 moves, finishing lap #6
 5  29| digit 2 moves
   529| digit 5 moves
 9 52 | digit 9 moves, finishing laps #7 and #8
 9 5  | digit 2 moves, finishing lap #2 --> remove 2 from the track
59    | digit 5 moves, finishing lap #3
5     | digit 9 moves, finishing lap #9 --> remove 9 from the track
     5| digit 5 moves
    5 | digit 5 moves, finishing lap #4
      | digit 5 moves, finishing lap #5 --> remove 5 from the track
------
Finish order: 2 9 5

Beispiele im Format Input => Output

[3], 2  =>  [3]

[9, 5], 3  =>  [9, 5]

[5, 9, 2], 6  =>  [2, 9, 5]

[5, 9, 2], 10  =>  [5, 9, 2]

[5, 7, 8, 1, 2], 10  =>  [1, 5, 7, 8, 2]

[5, 1, 6, 8, 3, 2], 17  =>  [1, 6, 8, 2, 3, 5]

[1, 2, 3, 7, 8, 9], 15  =>  [1, 7, 8, 9, 2, 3]

[9, 8, 7, 3, 2, 1], 15  =>  [8, 7, 9, 1, 2, 3]

[1, 2, 3, 4, 5, 6, 7, 8, 9], 20  =>  [1, 2, 3, 4, 5, 6, 7, 8, 9]

[9, 8, 7, 6, 5, 4, 3, 2, 1], 20  =>  [8, 7, 5, 9, 6, 1, 2, 4, 3]

Dies ist Code-Golf, also gewinnt der kürzeste Eintrag.

Ruby 229 236

Dies ist eine Funktion, die zwei Parameter akzeptiert: Ein Array, das die Ziffern darstellt, und ein Int, das die Länge der Spur darstellt. Es wird ein Array zurückgegeben, das die Reihenfolge angibt, in der die Ziffern das Rennen beenden.

F=->d,l{
i=0
t=d.map{|x|[x,d.size-(i+=1)]}
r=[]
d.cycle.map{|n|
t==[]&&break
(c=t.find{|x,_|x==n})&&(s=n
w=c[1]
o=p
(a=(t-[c]).map{|_,p|p%l}
s-=1;w+=1
a&[w%l]==[]?(o=p;c[1]=w):o||s-=o=1)while s>0
c[1]>=n*l&&(t.delete c;r<<n))}
r}

Testen Sie es online: http://ideone.com/KyX5Yu

Bearbeiten: Einige Tricks herausgefunden , um mehr Zeichen zu sparen.

Ungolfed-Version:

F=->digits,length{
  digit_positions = digits.map.with_index{|d,i|[d,digits.size-i-1] }

  result = []

  digits.cycle.map{|n|
    break if digit_positions==[]
    crt = digit_positions.find{|x,_|x==n}
    next unless crt

    steps_left = n
    pos = crt[1]
    taking_over = false

    while steps_left > 0
      other_pos = (digit_positions-[crt]).map{|_,p|p%length}

      steps_left-=1
      pos += 1

      if other_pos.include? (pos%length)
        steps_left -= 1 unless taking_over
        taking_over = true
      else
        taking_over = false
        crt[1] = pos
      end
    end

    if crt[1] >= n*length
      digit_positions.delete(crt)
      result<<n
    end
  }
  result
}

Python 2, 345 Bytes

Schade, es ist nicht kürzer als @ w0lfs, aber was auch immer. (Beachten Sie, dass es sich bei den großen Einzügen um Tabulatoren handelt, die beim Posten 4 Leerzeichen enthalten.)

def r(o,l):
 n=len(o);s,t,a,d=dict(zip(o,range(n)[::-1])),-1,{_:0 for _ in o},[]     
 while len(s):
    t+=1;g=o[t%n]
    if g in d:continue
    y,k=s[g],1;i=z=w=0
    for _ in[0]*g:
     i+=1;m=y+i;e,p=m%l,m/l
     if-~a[g]+w>=g<d>m>=l:a[g]+=1;del s[g];d+=[g];break
     if e in s.values()and e!=y:i-=k;k=0
     else:k,s[g],(w,z)=1,e,[(w,z),(z,p)][z<p]
    a[g]+=z
 print d

Hier ist mein magischer gepolsterter Code

C (457 430b)

int v(int*M,int m){
int i,n,c,d,e=32,f=48,u=0,g=10,h,k,r,l=m,j;char a,*b=&a,*B,V[m];
for (i=0;u<m*m*m;i=(++u%m),*B=*b=(u<=l)?*b:e,b=B=&a)
printf("%c%c",0*(V[i]=(u<l?u>=(r=l-sizeof(M)/4)?M[u-r]+f:e:V[i])),((((V[c=(((V[i]=u<l?e:V[i])-f)/10<u/m)?j>=0&h<i|((h=(j=strchr(V+((k=(m+(d=(i-(V[i]-f)%g+1)))%m)),e)-V)<0?(int)(strchr(V,e)-V):(int)j)>=k)*(k>i)?h:m :m])=((V[c]==e)?(*(b=V+i)+(d<0)*g):V[c])))-f)%11==0?(*(B=V+c)-f)%g+f:0);
getch();
}

Hinweis : Es muss noch verbessert werden ...

BEARBEITEN: Code verkürzt ... - sizeof (int) = 4, function = v, bleibt noch eine Variable zu ersetzen.