introduzione

In questa sfida, il tuo compito è simulare un certo tipo di gioco di eliminazione. Nel gioco, i partecipanti stanno in cerchio e tutti hanno un numero intero. Ad ogni round del gioco, ogni partecipante punta alla persona nche si allontana, se nè il numero che sta tenendo. Se nè positivo, contano alla loro destra, se nè negativo, contano alla loro sinistra e se nè zero, indicano se stessi. Ogni partecipante che ha qualcuno che li punta viene eliminato e lascia il cerchio; questo termina il round. I round continuano fino a quando non rimangono più partecipanti.

Ingresso

Il tuo input è un elenco non vuoto di numeri interi, in qualsiasi formato ragionevole. Rappresenta i numeri che detengono i partecipanti al gioco.

Produzione

Il tuo risultato è il numero di round necessari fino alla fine del gioco.

Esempio

Considera l'elenco di input [3,1,-2,0,8]. Al primo turno, succede quanto segue:

• La persona che detiene 3punti direttamente alla persona in possesso 0.
• La persona che detiene 1punti direttamente alla persona in possesso -2.
• La persona che detiene -2punti lasciati alla persona in possesso 3.
• La persona che si tiene 0per sé.
• La persona che tiene 8punta verso la persona in mano -2(l'elenco rappresenta un cerchio, quindi si avvolge alle estremità).

Ciò significa che 0, -2e 3vengono eliminati, quindi il secondo turno avviene con l'elenco [1,8]. Qui, 1punti 8e 8punti su se stessi, così 8viene eliminato. Il terzo round è fatto con la lista [1], dove 1indica semplicemente se stesso e viene eliminato. Ci sono voluti tre round per eliminare tutti i partecipanti, quindi l'output corretto è 3.

Regole e punteggio

È possibile scrivere un programma completo o una funzione. Vince il conteggio di byte più basso e non sono consentite scappatoie standard.

Casi test

[3] -> 1
[0,0,0] -> 1
[-2,-1,0,1,2,3,4,5,6,7] -> 2
[5,5,5,6,6,6] -> 2
[3,-7,-13,18,-10,8] -> 2
[-7,5,1,-5,-13,-10,9] -> 2
[4,20,19,16,8,-9,-14,-2,17,7,2,-2,10,0,18,-5,-5,20] -> 3
[11,2,7,-6,-15,-8,15,-12,-2,-8,-17,6,-6,-5,0,-20,-2,11,1] -> 4
[2,-12,-11,7,-16,9,15,-10,7,3,-17,18,6,6,13,0,18,10,-7,-1] -> 3
[18,-18,-16,-2,-19,1,-9,-18,2,1,6,-15,12,3,-10,8,-3,7,-4,-11,5,-15,17,17,-20,11,-13,9,15] -> 6

Pyth, 15 byte

f!=.DQ.e%+bklQQ

Test suite grazie a Kirby

Utilizza lo stesso meccanismo di iterazione di @orlp, ma rileva il numero di iterazioni utilizzando f, la funzione "Ripeti fino a falsare", per rilevare il []termine.

Matlab, 91 77 byte

function k=f(a);k=0;while a*0+1;l=numel(a);a(mod((1:l)+a-1,l)+1)=[];k=k+1;end

Vecchia versione:

function k=f(a);for k=1:numel(a);a(mod((1:l)+a-1,l)+1)=[];l=numel(a);if l==0;break;end;end

Questa è una sfida in cui brilla matlab, il cuore di questo codice è la cancellazione delle voci dell'array: a(mod((1:l)+a-1,l)+1)=[]che è abbastanza elegante, credo.

CJam, 21 byte

q~{__ee{~+0t}/0-}h],(

Suite di test.

Accetta input come un elenco di stili CJam, ma la suite di test si occupa della conversione dal formato della sfida.

Spiegazione

q~     e# Read and evaluate the input.
{      e# While the array is non-empty...
  _    e#   Copy the array. The original is left on the stack so that we can use the
       e#   stack depth to count the number of iterations later.
  _ee  e#   Make another copy and enumerate it, which means that each element is replaced
       e#   by a pair containing the element and its index in the array.
  {    e#   For each such pair...
    ~+ e#     Add the value to the index, giving the index it points at.
    0t e#     Set the value in the original array at the pointed-at index to 0.
       e#     This works without giving false positives because all 0s point to themselves.
  }/
  0-   e#   Remove all 0s from the array.
}h
],(    e# Wrap the stack in an array, get its length and decrement it to determine how
       e# many iterations this process took.

C #, 251 219 211 197 193 byte

Il linguaggio più esagerato non esoterico colpisce ancora.

using System.Linq;class X{static void Main(string[]a){int i=0,c;for(;(c=a.Length)>0;i++)a=a.Where((e,x)=>!a.Where((f,y)=>((int.Parse(f)+y)%c+c)%c==x).Any()).ToArray();System.Console.Write(i);}}

Questo programma prevede la sequenza di input come argomenti della riga di comando. Ad esempio, per inserire l'elenco [5,5,5,6,6,6], chiamarlo con argomenti da riga di comando 5 5 5 6 6 6.

Grazie a Martin Büttner per alcuni suggerimenti.

L'ho portato a 197 realizzando che posso riutilizzare l' argsarray anche se è un array di stringhe. Ho solo bisogno di analizzarli in un numero intero in un unico posto.

Giocato a 193 realizzando che .Where(...==x).Any()è più breve di .Select(...).Contains(x).

Ungolfed

using System.Linq;
class X
{
    static void Main(string[] args)
    {
        var iterations = 0, count;

        // In the golfed version, this is a `for` loop instead.
        while ((count = args.Length) > 0)
        {
            // Create a new args array containing the items to be kept.
            args = args.Where((item, index) =>
            {
                // Should the item at index `index` be deleted?
                var deleteThisIndex = args.Where((item2, index2) =>
                    // Modulo that works with negative numbers...
                    ((int.Parse(item2) + index2) % count + count) % count
                        == index);

                return !deleteThisIndex.Any();

            }).ToArray();

            iterations++;
        }

        System.Console.Write(iterations);
    }
}

Pyth, 21 byte

lt.u@LN-UlN.e%+kblNNQ

Demo live con casi di test.

R, 105 byte

codice

l=scan();o=c();z=0;while((n=length(l))>0){for(i in 1:n)o=c(o,(i+l[i]-1)%%n+1);l=l[-o];o=c();z=z+1};cat(z)

ungolfed

l <- scan()                  # get input as a 'l' vector from user
o <- c()                     # create a empty vector
z=0                          # create a counter starting at 0   
while((n=length(l))>0){      # while the length of the input is more than 0
  for(i in 1:n){             # iterate through the vector
    o=c(o,(i+l[i]-1)%%n+1)   # add the index that will be deleted to the 'o' vector
  }
  l=l[-o]                    # remove the 'o' vector indexes from 'l'
  o=c()                      # empty 'o'
  z=z+1                      # add 1 to counter
}
cat(z)                       # print the counter

Pyth, 17 byte

tl.u.DN.e%+kblNNQ

Per coincidenza, molto simile alla risposta di Kirbyfan.

Mathematica, 71 byte

Length@FixedPointList[#~Delete~Mod[Plus~MapIndexed~#,Length@#,1]&,#]-2&

STATA, 146 byte

inf a using a.
gl b=0
qui while _N>0{
g q$b=0
g c$b=mod(_n+a-1,_N)+1
forv y=1/`=_N'{
replace q$b=1 if _n==c$b[`y']
}
drop if q$b
gl b=$b+1
}
di $b

Utilizza la versione a pagamento di STATA. Presuppone che l'input sia in un file separato newline chiamato a.. Limitato a situazioni in cui non sono richiesti più di 1023 round a causa di un numero massimo di variabili consentite (può essere risolto al costo di 10 byte). Legge i dati ed esegue un ciclo fino a quando non ci sono più osservazioni. In ogni iterazione, crea una variabile con il valore dell'indice a cui punta. Per ogni osservazione, se un'altra osservazione punta ad essa, imposta un indicatore per eliminare la variabile. Quindi rilascia tutte le osservazioni con quell'indicatore e incrementa il contatore. Dopo il ciclo, stampare il contatore.

Rubino, 78 74 byte

f=->a{b,i=[],0;(a.map{|e|b<<a[(e+i)%a.size]};a-=b;i+=1)while a.size>0;p i}

awk, 66 byte

{for(;n=split($0=$0,a);++r)for(i in a)$((i+a[i]%n+n-1)%n+1)=X}$0=r

Usa semplicemente mod length arrayper tenerlo all'interno dell'array. Nell'input i numeri devono essere separati da spazi.

Esempio di utilizzo

echo "-2 -1 0 1 2 3 4 5 6 7" | awk '{for(;n=split($0=$0,a);++r)for(i in a)$((i+a[i]%n+n-1)%n+1)=X}$0=r'

Ecco tutti gli esempi di input nel formato appropriato

3
0 0 0
-2 -1 0 1 2 3 4 5 6 7
5 5 5 6 6 6
3-7-13 18-10 8
-7 5 1-5 -13-10 9
4 20 19 16 8-9-14 -2 17 7 2 -2 10 0 18-5-5 20
11 2 7 -6 -15 -8 15 -12 -2 -8 -17 6 -6 -5 0 -20 -2 11 1
2-12-11 7-16 9 15-10 7 3-17 18 6 6 13 0 18 10 -7 -1
18-18-16 -2-19 1-9-18 2 1 6-15 12 3-10 8-3 7 -4-11 5-15 17 17-20 11 -13 9 15

Python 2, 122 byte

def f(l):
 if not l:return 0
 L=len(l);x=[1]*L
 for i in range(L):x[(i+l[i])%L]=0
 return 1+e([v for i,v in zip(x,l)if i])