Un simple: prenez une liste d'entiers positifs en entrée et sortez les nombres module leur index basé sur 1 dans la liste.

Si les entiers d'entrée sont {a, b, c, d, e, f, g}alors la sortie doit être {a%1, b%2, c%3, d%4, e%5, f%6, g%7}où %est l'opérateur de module.

Cas de test:

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 octets

($[1..]).zipWith mod

Essayez-le en ligne!

Un truc que flipj'ai appris d' un golf d'Anders Kaseorg .

Fonctionnement du langage de script Flashpoint , 73 octets

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

Appeler avec:

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

Sortie:

Python 2 , 35 octets

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

Essayez-le en ligne!

Compte l'index manuellement, selon un de mes conseils .

Gelée , 2 octets

%J

Essayez-le en ligne!

Explication:

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

Fondamentalement, le code module la liste d'origine par la liste des index.

R, 24 18 octets

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

Évalue la fonction:

function (x) 
x%%seq(x)

Ce qui permet seq_along()de créer un vecteur de la même longueur que x, à partir de 1, puis %%de prendre le modulo.

Le comportement par défaut seqlorsqu'il est présenté avec un vecteur est celui seq(along.with = x)qui est la même sortie que seq_along(x), mais 6 octets plus court.

R, 27 octets

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

économisé 5 octets grâce à @Jarko

économisé 4 de plus grâce à @Giuseppe

enregistré 2 de plus grâce à @Taylor Scott

Enregistré 2 de plus grâce à @returnbull

APL (Dyalog) , 5 octets

⍳∘≢|⊢

Essayez-le en ligne!

⍳ les indices

∘ de

≢ la longueur de l'argument

| ce module

⊢ l'argument

Cubix , 19 octets

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

Essayez-le en ligne!

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

Regardez-le courir

Une implémentation assez simple.

• 1 poussez 1 vers la pile pour démarrer l'index
• I!@ obtenir l'entrée entière et arrêter si 0
• s%Ow échanger l'index vers le haut, le mod, le résultat de sortie et changer de voie
• ;) supprimer le résultat et incrémenter l'index
• Sow pousser 32, sortir l'espace et changer de voie (en descendant de o)
• $O sauter la sortie
• w;wchanger de lange, retirer 32 de la pile et changer de voie sur l' Ientrée

05AB1E , 2 octets

ā%

Essayez-le en ligne! ou essayez tous les tests

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

Mathematica, 22 octets

#&@@@Mod~MapIndexed~#&

Encore une approche Mathematica.

Étoilé , 75 70 octets

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

Essayez-le en ligne!

Explication

Il s'agit d'une boucle infinie qui continue à lire les nombres de l'entrée et à augmenter un compteur initialisé à 1. Pour chaque paire d'entrée et de compteur, le module est calculé et imprimé.

Pour terminer la boucle lorsque l'entrée a été épuisée, l'astuce suivante est utilisée. Lorsqu'aucune entrée n'est disponible, essayer de lire un autre chiffre donne a 0. Ainsi, nous divisons le nombre lu par lui-même, et s'il l'est, 0le programme se termine par une erreur. Sinon, nous rejetons le résultat et continuons.

      +              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 octets

tf\

Essayez-le en ligne!

Un octet enregistré grâce à @LuisMendo!

Brachylog , 9 octets

l⟦₁;?↔z%ᵐ

Essayez-le en ligne!

Explication

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

Japt, 5 4 octets

®%°T

Essayez-le

• -1 octet grâce à ETHproductions

Explication

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

R, 22 octets

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

R effectue 1: longueur (x) avant de faire le module.

Python 2 , 42 octets

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

Essayez-le en ligne!

Haskell, 22 octets

zipWith(flip mod)[1..]

Essayez-le en ligne!

En outre: flip(zipWith mod)[1..].

Mathematica, 21 octets

#~Mod~Range@Length@#&

Essayez-le en ligne!

ou 20 octets (par Martin)

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

Excel VBA, 59 46 octets

Golfé

Fonction de fenêtre immédiate VBE anonyme qui prend une chaîne de tableau délimitée par un espace ( ) comme entrée de la plage [A1]et affiche le module de nombres de leur index basé sur 1 dans la liste de départ vers la fenêtre immédiate VBE

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

Entrée sortie:

[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 

Vieux Sub version de routine

Sous-programme qui prend les entrées en tant que tableau transmis et les sorties dans la fenêtre immédiate VBE.

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

Entrée / sortie:

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

Non 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

Entrée sortie:

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

CJam , 9 octets

{_,,:).%}

Bloc anonyme qui attend un tableau sur la pile et le remplace par le tableau de sortie.

Essayez-le en ligne!

Explication

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

J, 9 octets

>:@i.@#|[

1 ... n | liste originale

| est mod

JavaScript (ES6), 22 octets

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

AWK, 13

{print $1%NR}

Essayez-le en ligne .

tcl, 35

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

démo

GNU APL 1.2, 9 octets

(⍳⍴R)|R←⎕

APL fonctionne de droite à gauche, d'où les parenthèses.

R←⎕affecte l'entrée utilisateur au vecteur R.

⍴Rdonne la longueur du vecteur; ⍳⍴Rdonne un vecteur avec tous les nombres de 1 à cette longueur (donc les indices).

|est l'opérateur de mod ( a|brendements b%a). APL fonctionne sur des tableaux, de sorte que le code extrait un vecteur contenant chaque élément de l'entrée de l'utilisateur modifie son index.

Pari / GP , 22 octets

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

Essayez-le en ligne!

Pyth, 5

.e%bh

Test en ligne .

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

Octave , 19 octets

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

Essayez-le en ligne!

Une fonction anonyme qui prend n en entrée et effectue un module par élément avec la liste 1, 2, 3 .

Braingolf , 18 octets

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

Essayez-le en ligne!

Explication

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 octets

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

Essayez-le ici.

Fonctionne également en C # en remplaçant ->par =>et lengthpar Length:

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

Essayez-le ici.

Explication:

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

Modifie le tableau d'entrée, d'où l'absence de retour.