Una simple: tome una lista de enteros positivos como entrada y salida, los números modulan su índice basado en 1 en la lista.

Si los enteros de entrada son {a, b, c, d, e, f, g}entonces la salida debería estar {a%1, b%2, c%3, d%4, e%5, f%6, g%7}donde %está el operador del módulo.

Casos de prueba:

10  9  8  7  6  5  4  3  2  1
 0  1  2  3  1  5  4  3  2  1

8 18  6 11 14  3 15 10  6 19 12  3  7  5  5 19 12 12 14  5
0  0  0  3  4  3  1  2  6  9  1  3  7  5  5  3 12 12 14  5

1
0

1  1
0  1

Haskell , 20 bytes

($[1..]).zipWith mod

Pruébalo en línea!

Un truco flipque aprendí del golf de Anders Kaseorg .

Lenguaje de script Operation Flashpoint , 73 bytes

f={l=_this;r=[];i=0;while{i<count l}do{r=r+[(l select i)%(i+1)];i=i+1};r}

Llamar con:

numList = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1];
hint format["%1\n%2", numList, numList call f];

Salida:

Python 2 , 35 bytes

i=1
for x in input():print x%i;i+=1

Pruébalo en línea!

Cuenta el índice manualmente, según un consejo mío .

Jalea , 2 bytes

%J

Pruébalo en línea!

Explicación:

%J
 J List 1 .. len(input). This is results in a list of the indexes.
%  Modulo.

Básicamente, el código modula la lista original por la lista de índices.

R, 24 18 bytes

pryr::f(x%%seq(x))

Evalúa la función:

function (x) 
x%%seq(x)

Que se usa seq_along()para crear un vector de la misma longitud que x, comenzando en 1, y luego %%para tomar el módulo.

El comportamiento predeterminado de seqcuando se presenta un vector seq(along.with = x)es la misma salida que seq_along(x), pero 6 bytes más corta.

R, 27 bytes

x=scan();cat(x%%1:sum(1|x))

ahorró 5 bytes gracias a @Jarko

ahorró 4 más gracias a @Giuseppe

ahorró 2 más gracias a @Taylor Scott

Ahorré 2 más gracias a @returnbull

APL (Dyalog) , 5 bytes

⍳∘≢|⊢

Pruébalo en línea!

⍳ los índices

∘ de

≢ la longitud del argumento

| ese módulo

⊢ el argumento

Cubix , 19 bytes

;ww.1I!@s%Ow;)Sow.$

Pruébalo en línea!

    ; w
    w .
1 I ! @ s % O w
; ) S o w . $ .
    . .
    . .

Míralo correr

Una implementación bastante sencilla.

• 1 empuje 1 a la pila para comenzar el índice
• I!@ obtener la entrada entera y detener si 0
• s%Ow intercambie el índice hacia arriba, mod, resultado de salida y cambie de carril
• ;) eliminar resultado e índice de incremento
• Sow empuje 32, espacio de salida y cambio de carril (hacia abajo desde o)
• $O saltar la salida
• w;wcambiar lange, eliminar 32 de la pila y cambiar de carril a la Ientrada

05AB1E , 2 bytes

ā%

Pruébalo en línea! o prueba todas las pruebas

ā  # Push the range(1, len(a) + 1)
 % # Mod each element in the input by the same one in this list

Mathematica, 22 bytes

#&@@@Mod~MapIndexed~#&

Un enfoque más de Mathematica.

Estrellado , 75 70 bytes

      +`  , + +   *    +  + +      +*   +    *  .               + + .'

Pruébalo en línea!

Explicación

Este es un bucle infinito que mantiene la lectura de números de la entrada y aumenta un contador iniciado en 1 . Para cada par de entrada y contador, el módulo se calcula e imprime.

Para finalizar el ciclo cuando la entrada se ha agotado, se utiliza el siguiente truco. Cuando no hay más entradas disponibles, al intentar leer un número más se obtiene a 0. Por lo tanto, dividimos el número de lectura por sí mismo, y si es así, 0el programa termina con un error. De lo contrario, descartamos el resultado y continuamos.

      +              Push 1. This is the initial value of the counter
`                    Mark label
  ,                  Read number from input and push it. Gives 0 if no more input
 +                   Duplicate top of the stack
 +                   Duplicate top of the stack
   *                 Pop two numbers and push their division. Error if divisor is 0
    +                Pop (discard) top of the stack
  +                  Swap top two numbers
 +                   Duplicate top of the stack
      +              Push 1
*                    Pop two numbers and push their sum. This increases the counter
   +                 Rotate stack down, to move increased counter to bottom
    *                Pop two numbers and push their modulus
  .                  Pop a number and print it as a number
               +     Push 10
 +                   Duplicate top of the stack
 .                   Pop a number (10) and print it as ASCII character (newline)
'                    If top of the stack is non-zero (it is, namely 10) go to label

MATL , 4 , 3 bytes

tf\

Pruébalo en línea!

¡Un byte guardado gracias a @LuisMendo!

Brachylog , 9 bytes

l⟦₁;?↔z%ᵐ

Pruébalo en línea!

Explicación

l⟦₁          [1, ..., length(Input)]
   ;?↔z      Zip the Input with that range
       %ᵐ    Map mod

Japt, 5 4 bytes

®%°T

Intentalo

• -1 byte gracias a ETHproductions

Explicación

     :Implicit input of array U
®    :Map over the array
%    :Modulo of the current element
°T   :T (0, initially) incremented by 1

R, 22 bytes

pryr::f(x%%1:sum(x|1))

R realiza 1: longitud (x) antes de hacer el módulo.

Python 2 , 42 bytes

lambda l:[v%(i+1) for i,v in enumerate(l)]

Pruébalo en línea!

Haskell, 22 bytes

zipWith(flip mod)[1..]

Pruébalo en línea!

También: flip(zipWith mod)[1..].

Mathematica, 21 bytes

#~Mod~Range@Length@#&

Pruébalo en línea!

o 20 bytes (por Martin)

#~Mod~Range@Tr[1^#]&

Excel VBA, 59 46 bytes

Golfed

Función anónima de ventana VBE Inmediata que toma una cadena de matriz delimitada por espacios ( ) como entrada del rango [A1]y salida del módulo de números de su índice basado en 1 en la lista inicial a la ventana inmediata de VBE

For Each n In Split([A1]):i=i+1:?n Mod i;:Next

De entrada y salida:

[A1]="10 9 8 7 6 5 4 3 2 1" ''# or manually set the value
For Each n In Split([A1]):i=i+1:?n Mod i;:Next
 0  1  2  3  1  5  4  3  2  1 

Antigua Subversión de rutina

Subrutina que toma la entrada como una matriz pasada y salidas a la ventana inmediata de VBE.

Sub m(n)
For Each a In n
i=i+1
Debug.?a Mod i;
Next
End Sub

Entrada / salida:

m Array(10,9,8,7,6,5,4,3,2,1)
 0  1  2  3  1  5  4  3  2  1 

Sin golf

Option Private Module
Option Compare Binary
Option Explicit
Option Base 0 ''# apparently Option Base 1 does not work with ParamArrays

Public Sub modIndex(ParamArray n() As Variant)
    Dim index As Integer
    For index = LBound(n) To UBound(n)
        Debug.Print n(index) Mod (index + 1);
    Next index
End Sub

De entrada y salida:

Call modIndex(10,9,8,7,6,5,4,3,2,1)
 0  1  2  3  1  5  4  3  2  1 

CJam , 9 bytes

{_,,:).%}

Bloque anónimo que espera una matriz en la pila y la reemplaza por la matriz de salida.

Pruébalo en línea!

Explicación

{       }    e# Define block
 _           e# Duplicate
  ,          e# Length
   ,         e# Range, 0-based
    :)       e# Add 1 to each entry
      .%     e# Vectorized modulus

J, 9 bytes

>:@i.@#|[

1 ... n | lista original

| es mod

JavaScript (ES6), 22 bytes

a=>a.map((x,y)=>x%++y)

AWK, 13

{print $1%NR}

Pruébalo en línea .

tcl, 35

lmap l $L {puts [expr $l%[incr i]]}

demo

GNU APL 1.2, 9 bytes

(⍳⍴R)|R←⎕

APL operates from right to left, hence the parentheses.

R←⎕ assigns user input to vector R.

⍴R gives the length of the vector; ⍳⍴R gives a vector with all numbers from 1 to that length (so the indices).

| is the mod operator (a|b yields b%a). APL operates on arrays, so the code snippet a vector containing each element from the user's input mod its index.

Pari/GP, 22 bytes

a->[a[n]%n|n<-[1..#a]]

Try it online!

Pyth, 5

.e%bh

Online test.

    hk     # 1-based index of (implicit) lambda variable
   b       # element
  %        # element mod (1-based index)
.e    Q    # enumerated map over (implicit) input

Octave, 19 bytes

@(n)mod(n,1:nnz(n))

Try it online!

An anonymous function that takes n as input, and performs element-wise modulus with the list 1, 2, 3.

Braingolf, 18 bytes

V1R&,{v.m1+v%}&,=;

Try it online!

Explanation

V1R&,{v.m1+v%}&,=;  Implicit input from commandline args
V1R                 Create stack2, push 1 to it, and return to stack1
   &,               Reverse stack1
     {.......}      Foreach loop, runs for each item in stack1
      v             Switch to stack2
       .m           Duplicate last item on stack and move duplicate to stack1
         1+         Increment last item on stack
           v%       Return to stack1, pop last 2 items and push modulus result
              &,    Reverse stack1
                =   Output stack1
                 ;  Suppress implicit output

Java 8 / C#, 39 bytes

a->{for(int i=0;i<a.length;a[i]%=++i);}

Try it here.

Also works in C# by replacing -> with => and length with Length:

a=>{for(int i=0;i<a.Length;a[i]%=++i);}

Try it here.

Explanation:

a->{                       // Method with integer-array parameter and no return-type
  for(int i=0;i<a.length;  //  Loop over the indexes of the array (0-indexed)
      a[i]%=++i            //   And replace every integer with itself mod (1+i)
  );                       //  End of loop
}                          // End of method

Modifies the input-array, hence the lack of a return.