A list of number modulus their indices in the list

Question

A simple one: Take a list of positive integers as input and output the numbers modulus their 1-based index in the list.

If the input integers are {a, b, c, d, e, f, g} then the output should be {a%1, b%2, c%3, d%4, e%5, f%6, g%7} where % is the modulus operator.

---

Test cases:

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

Answer 1

Haskell, 20 bytes

($[1..]).zipWith mod

Try it online!

A trick to flip I learned from a golf of Anders Kaseorg.

Answer 2

Operation Flashpoint scripting language, 73 bytes

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

Call with:

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

Output:

Answer 3

Python 2, 35 bytes

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

Try it online!

Counts the index up manually, as per a tip of mine.

Answer 4

Jelly, 2 bytes

%J

Try it online!

Explanation:

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

Basically, the code modulos the original list by the list of indexes.

Answer 5

R, 27 bytes

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

saved 5 bytes thanks to @Jarko

saved 4 more thanks to @Giuseppe

saved 2 more thanks to @Taylor Scott

Saved 2 more thanks to @returnbull

Answer 6

R, 24 18 bytes

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

Evaluates to the function:

function (x) 
x%%seq(x)

Which uses seq_along() to create a vector of the same length as x, starting at 1, and then %% to take the modulo.

Default behaviour of seq when presented with a vector is seq(along.with = x) which is the same output as seq_along(x), but 6 bytes shorter.

Answer 7

05AB1E, 2 bytes

ā%

Try it online! or Try all tests

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

Answer 8

APL (Dyalog), 5 bytes

⍳∘≢|⊢

Try it online!

⍳ the indices

∘ of

≢ the length of the argument

| that modulus

⊢ the argument

Answer 9

Cubix, 19 bytes

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

Try it online!

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

Watch It Run

A fairly straight forward implementation.

• 1 push 1 to the stack to start the index
• I!@ get the integer input and halt if 0
• s%Ow swap the index up, mod, output result and change lane
• ;) remove result and increment index
• Sow push 32, output space and change lane (heading down from o)
• $O jump the output
• w;w change lange, remove 32 from stack and change lane onto the I input

Answer 10

Mathematica, 22 bytes

#&@@@Mod~MapIndexed~#&

One more Mathematica approach.

Answer 11

MATL, 4, 3 bytes

tf\

Try it online!

One byte saved thanks to @LuisMendo!

Answer 12

Starry, 75 70 bytes

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

Try it online!

Explanation

This is an infinite loop that keeps reading numbers from the input and increasing a counter initiallized at 1. For each pair of input and counter, the modulus is computed and printed.

To end the loop when input has been exhausted, the following trick is used. When no more input is available, trying to read one more number gives a 0. Thus, we divide the read number by itself, and if it is 0 the program ends with an error. Else we discard the result and continue.

      +              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

Answer 13

Brachylog, 9 bytes

l⟦₁;?↔z%ᵐ

Try it online!

Explanation

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

Answer 14

Japt, 5 4 bytes

®%°T

Try it

• -1 byte thanks to ETHproductions

---

Explanation

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

Answer 15

R, 22 bytes

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

R performs 1:length(x) before doing the modulus.

Answer 16

Python 2, 42 bytes

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

Try it online!

Answer 17

Mathematica, 21 bytes

#~Mod~Range@Length@#&

Try it online!

or 20 bytes (by Martin)

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

Answer 18

Haskell, 22 bytes

zipWith(flip mod)[1..]

Try it online!

Also: flip(zipWith mod)[1..].

Answer 19

Excel VBA, 59 46 Bytes

Golfed

Anonymous VBE Immediate window funtion that takes a space ( ) delimited array string as input from range [A1] and output the numbers modulus their 1-based index in the starting list to the VBE immediate window

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

Input / Output:

[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 

Old Subroutine version

Subroutine that takes input as a passed array and outouts to the VBE immediate window.

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

Input / Ouput:

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

Input / Output:

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

Answer 20

CJam, 9 bytes

{_,,:).%}

Anonymous block that expects an array on the stack and replaces it by the output array.

Try it online!

Explanation

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

Answer 21

J, 9 bytes

>:@i.@#|[

1 ... n | original list

| is mod

Answer 22

C, 52 bytes

i;f(n,l)int*l;{for(i=0;i++<n;)printf("%d ",*l++%i);}

Try it online!

Answer 23

JavaScript (ES6), 22 bytes

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

Answer 24

AWK, 13

{print $1%NR}

Try it online.

Answer 25

tcl, 35

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

demo

Answer 26

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.

Answer 27

Pari/GP, 22 bytes

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

Try it online!

Answer 28

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

Answer 29

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.

Answer 30

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

Answer 31

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.

Answer 32

Ruby, 25 bytes

->x{x.map{|y|$.+=1;y%$.}}

Try it online!

Answer 33

Common Lisp, 57 bytes

(defun m(l &aux(i 0))(mapcar(lambda(x)(mod x(incf i)))l))

Try it online!

Answer 34

Perl 6, 7 bytes

*Z%1..*

Test it

Expanded:

*      # WhateverCode lambda (this is the parameter)
Z[%]   # zipped using infix modulus operator (&infix:«%»)
1 .. * # Range starting from 1 (doesn't stop)

Answer 35

Python 3, 46 bytes

lambda x:[0]+[x[i]%i for i in range(1,len(x))]

Simples ;)

Answer 36

Go, 68 bytes

Go isn't hopelessly defeated (kinda is, but nvm that) because it has that nice range which is the equivalent of Python's enumerate().

func f(l[]int)(r[]int){for i,v:=range l{r=append(r,v%(i+1))};return}

Try it online!

Answer 37

PHP, 37 bytes

<?foreach($_GET as$v)echo$v%++$k." ";

Try it online!

Output separeted by an underscore

PHP, 35 bytes

<?foreach($_GET as$v)echo$v%++$k,_;

Try it online!

Answer 38

Python, 41 bytes

f=lambda l,i=1:l and[l[0]%i]+f(l[1:],i+1)

Try it online!

A recursive solution. One byte longer than using enumerate. Other attempts:

f=lambda l,i=1:l and[l.pop(0)%i]+f(l,i+1)
f=lambda l,i=0:l[i:]and[l[i]%-~i]+f(l,i+1)
f=lambda l:l and f(l[:-1])+[l[-1]%len(l)]

The last one really wants to use pop but the order of evaluation is wrong.

Answer 39

Perl 6, 18 bytes

{map (*+1)R%*,.kv}

Accepts the list as its sole argument.

Answer 40

Perl6, 22 21 bytes

say $_%++$ for @*ARGS

And a more readable version:

# Store initial index state
# The "++$" in the golf version increments an anonymous state variable for this.
my $index = 0;
# Iterate over the command-line arguments
for @*ARGS -> $number {
    # Increment the current index
    $index++;
    # Print out the result for this element
    say $number % $index;
}

Usage:

perl6 whatever-you-named-it.p6 [space-separated numbers go here]

Note that if we don't need to actually print the output, we can remove the initial say, saving 4 bytes to bring the total down to 17.

Answer 41

k, 12 bytes

{(1+!#x)!'x}

Try it online.

Answer 42

Aceto, 12 bytes

%pLI
ILOM
ri

It's a bit hard to see because there's no line break after the result is printed. Input is taken one number at a time, seperated by linebreaks.

Explanation:

Read a line and cast it to an integer:

ri

Load quick storage (initially an empty string) and increment it (autocasts to int; --> 1)

IL

Calculate and print modulo, load quick storage again, increment and save it:

%pLI
   M

Go back to the start:

  O

Example in- and output:

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

For one byte the output can look nicer:

%pLI
ILnM
riO

Answer 43

Actually, 6 bytes

;ru@♀%

Try it online!

Explanation:

;ru@♀%
;ru     push [1, len(L)]
   @♀%  modulo of pairs from each list ([L[0]%1, L[1]%2, ...])

Answer 44

Ruby, 40 bytes

->q{q.each_with_index.map{|n,i|n%(i+1)}}

Answer 45

Swift 4, 18 bytes

zip(a,1...).map(%)

Answer 46

Clojure, 25 bytes

#(map mod %(rest(range)))

(range) generates an infinite sequence of integers starting from 0, rest drops the first, and mapping with multiple sequences applies the operation to corresponding elements (and stops with the shorter sequence).

Answer 47

jq, 28 characters

to_entries[]|.value%(.key+1)

Sample run:

bash-4.4$ jq 'to_entries[]|.value%(.key+1)' <<< '[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]'
0
1
2
3
1
5
4
3
2
1

Try in jq‣play

For +5 characters you can enclose all the code in brackets and ask for compact output to get JSON output. But that not seems to be required.

Answer 48

NewStack, 3 bytes

ᵢ%ṅ

The breakdown:

ᵢ    Append user's input to the stack
 %ṅ  Mod stack by 1-based index of each element