Um exemplo simples: pegue uma lista de números inteiros positivos como entrada e faça a saída dos números no módulo com base em 1 na lista.

Se os números inteiros de entrada estiverem {a, b, c, d, e, f, g}, a saída deve estar {a%1, b%2, c%3, d%4, e%5, f%6, g%7}onde %está o operador do módulo.

Casos de teste:

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

Experimente online!

Um truque flipque aprendi com um golfe de Anders Kaseorg .

Linguagem de script da operação 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}

Ligue para:

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

Saída:

Python 2 , 35 bytes

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

Experimente online!

Conta o índice manualmente, de acordo com uma dica minha .

Geléia , 2 bytes

%J

Experimente online!

Explicação:

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

Basicamente, o código modula a lista original pela lista de índices.

R, 24 bytes de 18

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

Avalia para a função:

function (x) 
x%%seq(x)

Que é usado seq_along()para criar um vetor do mesmo comprimento que x, iniciando em 1, e depois %%pegar o módulo.

O comportamento padrão de seqquando apresentado com um vetor seq(along.with = x)é a mesma saída que seq_along(x), mas 6 bytes mais curto.

R, 27 bytes

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

economizou 5 bytes graças a @Jarko

salvou mais 4 graças a @ Giuseppe

salvou mais 2 graças a @Taylor Scott

Guardado 2 mais graças a @returnbull

APL (Dyalog) , 5 bytes

⍳∘≢|⊢

Experimente online!

⍳ os índices

∘ do

≢ o comprimento do argumento

| esse módulo

⊢ o argumento

Cubix , 19 bytes

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

Experimente online!

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

Assista

Uma implementação bastante direta.

• 1 pressione 1 na pilha para iniciar o índice
• I!@ obter a entrada inteira e parar se 0
• s%Ow Troque o índice, modifique o resultado e altere a faixa
• ;) remover índice de resultado e incremento
• Sow pressione 32, espaço de saída e mude de faixa (descendo de o)
• $O pular a saída
• w;wtroque a faixa, remova 32 da pilha e troque a faixa na Ientrada

05AB1E , 2 bytes

ā%

Experimente online! ou Experimente todos os testes

ā  # 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~#&

Mais uma abordagem do Mathematica.

Estrelado , 75 70 bytes

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

Experimente online!

Explicação

Este é um loop infinito que mantém a leitura dos números da entrada e aumenta um contador inicializado em 1 . Para cada par de entrada e contador, o módulo é calculado e impresso.

Para finalizar o loop quando a entrada estiver esgotada, o seguinte truque é usado. Quando não há mais entrada disponível, tentar ler mais um número fornece a 0. Assim, dividimos o número de leitura por si só e, se for, 0o programa termina com um erro. Caso contrário, descartamos o resultado e 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\

Experimente online!

Um byte salvo graças ao @LuisMendo!

Braquilog , 9 bytes

l⟦₁;?↔z%ᵐ

Experimente online!

Explicação

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

Japonês, 5 4 bytes

®%°T

Tente

• -1 byte graças a ETHproductions

Explicação

     :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 executa 1: comprimento (x) antes de executar o módulo.

Python 2 , 42 bytes

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

Experimente online!

Haskell, 22 bytes

zipWith(flip mod)[1..]

Experimente online!

Também: flip(zipWith mod)[1..].

Mathematica, 21 bytes

#~Mod~Range@Length@#&

Experimente online!

ou 20 bytes (por Martin)

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

Excel VBA, 59 46 bytes

Golfe

VBE anônimo Função imediata da janela que pega uma string de matriz delimitada por espaço ( ) como entrada do intervalo [A1]e gera o módulo de números em seu índice baseado em 1 na lista inicial para a janela imediata do VBE

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

Entrada / Saída:

[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 

SubVersão antiga de rotina

Sub-rotina que recebe a entrada como uma matriz passada e sai para a janela imediata do VBE.

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

Entrada / Saída:

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

Ungolfed

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

Entrada / Saída:

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

{_,,:).%}

Bloco anônimo que espera uma matriz na pilha e a substitui pela matriz de saída.

Experimente online!

Explicação

{       }    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

| é mod

JavaScript (ES6), 22 bytes

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

AWK, 13

{print $1%NR}

Experimente online .

tcl, 35

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

demonstração

GNU APL 1.2, 9 bytes

(⍳⍴R)|R←⎕

O APL opera da direita para a esquerda, daí os parênteses.

R←⎕atribui entrada do usuário ao vetor R.

⍴Rfornece o comprimento do vetor; ⍳⍴Rfornece um vetor com todos os números de 1 a esse comprimento (portanto, os índices).

|é o operador mod ( a|byields b%a). O APL opera em matrizes; portanto, o trecho de código de um vetor contendo cada elemento da entrada do usuário modifica seu índice.

Pari / GP , 22 bytes

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

Experimente online!

Pitão, 5

.e%bh

Teste online .

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

Oitava , 19 bytes

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

Experimente online!

Uma função anônima que recebe n como entrada e executa o módulo em elementos com a lista 1, 2, 3 .

Braingolf , 18 bytes

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

Experimente online!

Explicação

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);}

Experimente aqui.

Também funciona em C # substituindo ->por =>e lengthpor Length:

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

Experimente aqui.

Explicação:

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

Modifica a matriz de entrada, daí a falta de retorno.