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
Réponses:
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:
i=1
for x in input():print x%i;i+=1Compte l'index manuellement, selon un de mes conseils .
%J
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.
%Jdans Jelly, je me demande si quelqu'un a répondu avec cette réponse?". Je suppose que quelqu'un d'autre a eu la même idée :-D
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.
seq(x)est une chose pratique à avoir, car j'utilise toujours 1:length(x).
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
' '(l'espace) à la fin de cat; c'est le séparateur par défaut
x<-scan();cat(x%%1:length(x)," ")- oh et quelques conseils de mise en forme, 1) vous n'avez besoin que de 4 espaces à gauche de votre code pour qu'il soit correctement mis en retrait et marqué 2) vous pouvez ajouter un <!-- language-all: lang-r -->indicateur avant votre code pour le mettre en surbrillance (bien que cela change peu dans cet exemple) 3) vous n'avez pas besoin des crochets autour du nom de votre langue 4) oh et vous n'avez pas besoin de faire de commentaire lorsque vous apportez des modifications à un message
=au lieu de <-pour enregistrer un octet. (2) La spécification dit "sortie" plutôt que "impression", vous pouvez donc probablement supprimer le cat(), économisant 5 octets. (3) sum(1|x)est un octet plus court que length(x).
⍳∘≢|⊢⍳ les indices
∘ de
≢ la longueur de l'argument
| ce module
⊢ l'argument
(~T∊T∘.×T)/T←1↓⍳R ⍝ primes up to Roulife←{↑1 ω∨.∧3 4=+/,¯1 0 1∘.⊖¯1 0 1∘.⌽⊂ω} ⍝ Game of Life
(⊢~∘.×⍨)1↓⍳Rand GoL (dans la version 16.0): K∊⍨⊢∘⊂⌺3 3où K est une constante.
;ww.1I!@s%Ow;)Sow.$
; w
w .
1 I ! @ s % O w
; ) S o w . $ .
. .
. .
Une implémentation assez simple.
1 poussez 1 vers la pile pour démarrer l'indexI!@ obtenir l'entrée entière et arrêter si 0s%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'indexSow pousser 32, sortir l'espace et changer de voie (en descendant de o)$O sauter la sortiew;wchanger de lange, retirer 32 de la pile et changer de voie sur l' Ientréeā%
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
DgL%, sympa.
gL%parce que j'avais oublié ā.
āpour moi? Je crois que je ne l'ai jamais utilisé est-ce juste for eachmais d'une 1 to n+1manière similaire vy<code>})mais implicite vy<code>})?
#&@@@Mod~MapIndexed~#&
Encore une approche Mathematica.
MapIndexed@Modest presque assez bon: '(
+` , + + * + + + +* + * . + + .'
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
l⟦₁;?↔z%ᵐ
l⟦₁ [1, ..., length(Input)]
;?↔z Zip the Input with that range
%ᵐ Map mod
®%°T
:Implicit input of array U
® :Map over the array
% :Modulo of the current element
°T :T (0, initially) incremented by 1
®%°T(en fait, vous pouvez toujours l'utiliser Ysi vous le souhaitez)
pryr::f(x%%1:sum(x|1))
R effectue 1: longueur (x) avant de faire le module.
sum(x|1)!
seq()au lieu de seq_along()fait la même chose. C'est donc encore quelques octets plus court.
for
lambda l:[v%-~i for i,v in enumerate(l)]
lambda l:[v%i for i,v in enumerate(l,1)].
#~Mod~Range@Length@#&
ou 20 octets (par Martin)
#~Mod~Range@Tr[1^#]&
Tr[1^#]pour Length@#.
#avant-dernier caractère dans votre première réponse.
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;:NextEntré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 Sub version de routineSous-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 SubEntrée / sortie:
m Array(10,9,8,7,6,5,4,3,2,1)
0 1 2 3 1 5 4 3 2 1 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 SubEntrée sortie:
Call modIndex(10,9,8,7,6,5,4,3,2,1)
0 1 2 3 1 5 4 3 2 1 {_,,:).%}
Bloc anonyme qui attend un tableau sur la pile et le remplace par le tableau de sortie.
{ } e# Define block
_ e# Duplicate
, e# Length
, e# Range, 0-based
:) e# Add 1 to each entry
.% e# Vectorized modulus
(⍳⍴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.
.e%bh
hk # 1-based index of (implicit) lambda variable
b # element
% # element mod (1-based index)
.e Q # enumerated map over (implicit) input
@(n)mod(n,1:nnz(n))Une fonction anonyme qui prend n en entrée et effectue un module par élément avec la liste 1, 2, 3 .
V1R&,{v.m1+v%}&,=;
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
a->{for(int i=0;i<a.length;a[i]%=++i);}
Fonctionne également en C # en remplaçant ->par =>et lengthpar Length:
a=>{for(int i=0;i<a.Length;a[i]%=++i);}
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.
->de =>et capitalisez length.