introduzione

Un array di puntatori è un array Ldi numeri interi diversi da zero in cui 0 ≤ L[i]+i < len(L)vale per tutti gli indici i(presupponendo l'indicizzazione basata su 0). Diciamo che l'indice i punta all'indice L[i]+i. Un array di puntatori è un ciclo se gli indici formano un singolo ciclo di lunghezza len(L). Ecco alcuni esempi:

• [1,2,-1,3]non è un array di puntatori, poiché 3non punta a un indice.
• [1,2,-1,-3]è un array di puntatori, ma non un ciclo, perché nessun indice punta a -1.
• [2,2,-2,-2] è un array di puntatori, ma non un ciclo, poiché gli indici formano due cicli.
• [2,2,-1,-3] è un ciclo.

Ingresso

Il tuo input è un elenco non vuoto di numeri interi diversi da zero, in qualsiasi formato ragionevole. Può essere non ordinato e / o contenere duplicati.

Produzione

L'output deve essere un ciclo che contiene tutti gli interi nell'elenco di input (e possibilmente anche altri numeri interi), contando le molteplicità. Non è necessario che si verifichino nello stesso ordine dell'input e che l'output non deve essere minimo in alcun senso.

Esempio

Per l'input [2,-4,2], un output accettabile sarebbe [2,2,-1,1,-4].

Regole e punteggio

È possibile scrivere un programma completo o una funzione. Vince il conteggio di byte più basso e non sono consentite scappatoie standard . Includere un paio di esempi di input e output nella tua risposta è apprezzato.

Casi test

Questi sono indicati nel formato input -> some possible output(s).

[1] -> [1,-1] or [1,1,1,-3]
[2] -> [2,-1,-1] or [1,2,-2,-1]
[-2] -> [1,1,-2] or [3,1,2,-2,-4]
[2,-2] -> [2,-1,1,-2] or [2,-1,2,-2,-1]
[2,2,2] -> [2,-1,2,-2,2,-2,-1] or [2,2,2,2,-3,-5]
[2,-4,2] -> [2,2,-1,1,-4] or [2,5,1,1,1,-4,2,-7,-1]
[3,-1,2,-2,-1,-5] -> [2,3,-1,2,-1,-5] or [3,3,-1,-1,2,2,-1,6,1,1,1,1,-12,-5]
[-2,-2,10,-2,-2,-2] -> [10,-1,1,-2,-2,1,-2,-2,1,-2,-2]
[-15,15,-15] -> [15,-1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,-15,-15]
[1,2,3,4,5] -> [1,2,3,-1,4,-1,5,-1,-1,-9,-1,-1]

Gelatina, 12 byte

ż~Ṣ€FxA$;L$U

Provalo online!

sfondo

Considera la coppia di numeri interi n, ~ n , dove n ≥ 0 e ~ indica NOT bit a bit, ovvero ~ n = - (n + 1) .

Posizionando n copie di n a sinistra di n + 1 copie di ~ n , se iniziamo a attraversare l'array di puntatori dall'estrema destra ~ n , attraverseremo tutti gli elementi 2n + 1 e ci troveremo alla sinistra dell'estrema sinistra n .

Ad esempio, se n = 4 :

X  4  4  4  4  -5 -5 -5 -5 -5
                            ^
            ^
                         ^
         ^
                      ^
      ^
                   ^
   ^
                ^
^

Per il caso speciale n = 0 , l'elemento n stesso viene ripetuto 0 volte, lasciando questo:

X -1
   ^
^

Per ogni intero k nell'input, possiamo formare una coppia n, ~ n che contiene k impostando n = k se k> 0 e n = ~ k se k <0 . Questo funziona perché ~ è un'involuzione, cioè ~~ k = k .

Tutto ciò che resta da fare è concatenare le tuple generate e anteporre le loro lunghezze combinate, quindi l'elemento più a sinistra ci riporta a quella più a destra.

Esempi

[1] -> [3, 1, -2, -2]
[2] -> [5, 2, 2, -3, -3, -3]
[-2] -> [3, 1, -2, -2]
[2, -2] -> [8, 1, -2, -2, 2, 2, -3, -3, -3]
[2, 2, 2] -> [15, 2, 2, -3, -3, -3, 2, 2, -3, -3, -3, 2, 2, -3, -3, -3]
[2, -4, 2] -> [17, 2, 2, -3, -3, -3, 3, 3, 3, -4, -4, -4, -4, 2, 2, -3, -3, -3]
[3, -1, 2, -2, -1, -5] -> [26, 4, 4, 4, 4, -5, -5, -5, -5, -5, -1, 1, -2, -2, 2, 2, -3, -3, -3, -1, 3, 3, 3, -4, -4, -4, -4]
[-2, -2, 10, -2, -2, -2] -> [36, 1, -2, -2, 1, -2, -2, 1, -2, -2, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, 1, -2, -2, 1, -2, -2]
[-15, 15, -15] -> [89, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15]
[1, 2, 3, 4, 5] -> [35, 5, 5, 5, 5, 5, -6, -6, -6, -6, -6, -6, 4, 4, 4, 4, -5, -5, -5, -5, -5, 3, 3, 3, -4, -4, -4, -4, 2, 2, -3, -3, -3, 1, -2, -2]

Come funziona

ż~Ṣ€FxA$;L$U  Main link. Argument: A (list of integers)

 ~            Yield the bitwise not of each k in A.
ż             Zipwith; pair each k in A with ~k.
  Ṣ€          Sort each pair, yielding [~n, n] with n ≥ 0.
    F         Flatten the list of pairs.
       $      Combine the previous two links into a monadic chain:
      A         Yield the absolute values of all integers in the list.
                |n| = n and |~n| = |-(n + 1)| = n + 1
     x          Repeat each integer m a total of |m| times.
          $   Combine the previous two links into a monadic chain:
         L      Yield the length of the generated list.
        ;       Append the length to the list.
           U  Upend; reverse the generated list.