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
Respuestas:
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:
i=1
for x in input():print x%i;i+=1Cuenta el índice manualmente, según un consejo mío .
%J
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.
%Jen Jelly, me pregunto si alguien ha respondido con esa respuesta". Supongo que alguien más tuvo la misma idea :-D
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.
seq(x)Es algo muy útil, ya que siempre estoy usando 1:length(x).
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
' '(espacio) al final de cat; ese es el separador predeterminado
x<-scan();cat(x%%1:length(x)," ")- oh y un par de consejos de formato, 1) solo necesita 4 espacios a la izquierda de su código para que esté debidamente sangrado y marcado 2) puede agregar una <!-- language-all: lang-r -->bandera antes de que se resalte su código (aunque esto cambie poco en este ejemplo) 3) no necesita los corchetes alrededor del nombre de su idioma 4) ah y no necesita hacer un comentario cuando edita una publicación
=lugar de <-guardar un byte. (2) La especificación dice "salida" en lugar de "imprimir", por lo que probablemente puede soltar el cat(), ahorrando 5 bytes. (3) sum(1|x)es un byte más corto que length(x).
⍳∘≢|⊢⍳ los índices
∘ de
≢ la longitud del argumento
| ese módulo
⊢ el argumento
(~T∊T∘.×T)/T←1↓⍳R ⍝ primes up to Rolife←{↑1 ω∨.∧3 4=+/,¯1 0 1∘.⊖¯1 0 1∘.⌽⊂ω} ⍝ Game of Life
(⊢~∘.×⍨)1↓⍳Ry GoL (en la Versión 16.0): K∊⍨⊢∘⊂⌺3 3donde K es una constante.
;ww.1I!@s%Ow;)Sow.$
; w
w .
1 I ! @ s % O w
; ) S o w . $ .
. .
. .
Una implementación bastante sencilla.
1 empuje 1 a la pila para comenzar el índiceI!@ obtener la entrada entera y detener si 0s%Ow intercambie el índice hacia arriba, mod, resultado de salida y cambie de carril;) eliminar resultado e índice de incrementoSow empuje 32, espacio de salida y cambio de carril (hacia abajo desde o)$O saltar la salidaw;wcambiar lange, eliminar 32 de la pila y cambiar de carril a la Ientradaā%
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
DgL%agradable.
gL%porque me olvidé ā.
āmí? Creo que nunca lo he usado, ¿es así for eachpero de una 1 to n+1manera similar vy<code>})pero implícita vy<code>})?
#&@@@Mod~MapIndexed~#&
Un enfoque más de Mathematica.
MapIndexed@Modes casi lo suficientemente bueno: '(
+` , + + * + + + +* + * . + + .'
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
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 realidad, aún podría usarlo Yallí si lo desea)
pryr::f(x%%1:sum(x|1))
R realiza 1: longitud (x) antes de hacer el módulo.
sum(x|1)!
seq()lugar de seq_along()hace lo mismo. Entonces eso es unos bytes más cortos nuevamente.
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@#&
o 20 bytes (por Martin)
#~Mod~Range@Tr[1^#]&
Tr[1^#]para Length@#.
#como el segundo último personaje en tu primera respuesta.
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;:NextDe 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 Subversión de rutinaSubrutina 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 SubEntrada / salida:
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 SubDe 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 {_,,:).%}
Bloque anónimo que espera una matriz en la pila y la reemplaza por la matriz de salida.
{ } e# Define block
_ e# Duplicate
, e# Length
, e# Range, 0-based
:) e# Add 1 to each entry
.% e# Vectorized modulus
(⍳⍴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.
.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))An anonymous function that takes n as input, and performs element-wise modulus with the list 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);}
Also works in C# by replacing -> with => and length with Length:
a=>{for(int i=0;i<a.Length;a[i]%=++i);}
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.
-> to => and capitaliselength.