Semplice: prendi un elenco di numeri interi positivi come input e invia i moduli numerici al loro indice basato su 1 nell'elenco.
Se gli interi di input sono {a, b, c, d, e, f, g}allora l'output dovrebbe essere {a%1, b%2, c%3, d%4, e%5, f%6, g%7}dove si %trova l'operatore del modulo.
Casi 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
Risposte:
f={l=_this;r=[];i=0;while{i<count l}do{r=r+[(l select i)%(i+1)];i=i+1};r}
Chiama con:
numList = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1];
hint format["%1\n%2", numList, numList call f];
Produzione:
i=1
for x in input():print x%i;i+=1Conta l'indice manualmente, secondo una mia punta .
%J
Spiegazione:
%J
J List 1 .. len(input). This is results in a list of the indexes.
% Modulo.
Fondamentalmente, il codice modula l'elenco originale dall'elenco degli indici.
%Jin Jelly, mi chiedo se qualcuno abbia risposto con quella risposta?". Immagino che qualcun altro abbia avuto la stessa idea :-D
pryr::f(x%%seq(x))
Valuta la funzione:
function (x)
x%%seq(x)
Che utilizza seq_along()per creare un vettore della stessa lunghezza di x, a partire da 1, e quindi %%per prendere il modulo.
Il comportamento predefinito di seqquando presentato con un vettore seq(along.with = x)è lo stesso output di seq_along(x), ma più corto di 6 byte.
seq(x)è una cosa utile avere in giro, dato che lo uso sempre 1:length(x).
x=scan();cat(x%%1:sum(1|x))salvato 5 byte grazie a @Jarko
salvato altri 4 grazie a @Giuseppe
risparmiato altri 2 grazie a @Taylor Scott
Ne ho salvati altri 2 grazie a @returnbull
' '(spazio) alla fine di cat; questo è il separatore predefinito
x<-scan();cat(x%%1:length(x)," ")- oh e un paio di suggerimenti per la formattazione, 1) hai solo bisogno di 4 spazi a sinistra del codice per essere correttamente rientrato e contrassegnato 2) puoi aggiungere un <!-- language-all: lang-r -->flag prima che il tuo codice sia evidenziato (anche se questo cambia poco in questo esempio) 3) non hai bisogno delle parentesi attorno al nome della tua lingua 4) oh e non devi fare un commento quando modifichi un post
=invece di <-salvare un byte. (2) La specifica dice "output" piuttosto che "print", quindi probabilmente puoi rilasciare il cat(), risparmiando 5 byte. (3) sum(1|x)è più corto di un byte di length(x).
⍳∘≢|⊢⍳ gli indici
∘ di
≢ la lunghezza dell'argomento
| quel modulo
⊢ l'argomento
(~T∊T∘.×T)/T←1↓⍳R ⍝ primes up to Roppurelife←{↑1 ω∨.∧3 4=+/,¯1 0 1∘.⊖¯1 0 1∘.⌽⊂ω} ⍝ Game of Life
(⊢~∘.×⍨)1↓⍳Rand GoL (nella versione 16.0): K∊⍨⊢∘⊂⌺3 3dove K è una costante.
;ww.1I!@s%Ow;)Sow.$
; w
w .
1 I ! @ s % O w
; ) S o w . $ .
. .
. .
Un'attuazione abbastanza semplice.
1 spingere 1 nello stack per avviare l'indiceI!@ ottiene l'input intero e si ferma se 0s%Ow scambia l'indice su, mod, risultato di uscita e cambia corsia;) rimuove il risultato e incrementa l'indiceSow premere 32, spazio di uscita e cambiare corsia (andando verso il basso da o)$O salta l'uscitaw;wcambia lingua, rimuovi 32 dallo stack e cambia corsia Isull'ingressoā%
Provalo online! oppure prova tutti i test
ā # Push the range(1, len(a) + 1)
% # Mod each element in the input by the same one in this list
DgL%carino.
gL%perché mi ero dimenticato ā.
āper me? Credo di non averlo mai usato, è proprio come for eachma in 1 to n+1modo simile vy<code>})ma implicito vy<code>})?
#&@@@Mod~MapIndexed~#&
Un altro approccio Mathematica.
MapIndexed@Modè quasi abbastanza buono: '(
+` , + + * + + + +* + * . + + .'
Questo è un ciclo infinito che continua a leggere i numeri dall'ingresso e ad aumentare un contatore inizializzato su 1 . Per ogni coppia di input e counter, il modulo viene calcolato e stampato.
Per terminare il loop quando l'input è stato esaurito, viene utilizzato il seguente trucco. Quando non è più disponibile alcun input, provare a leggere un altro numero dà a 0. Quindi, dividiamo il numero letto da solo, e se è 0il programma termina con un errore. Altrimenti scartiamo il risultato e continuiamo.
+ 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(in realtà, potresti ancora usarlo Yse volessi)
pryr::f(x%%1:sum(x|1))
R esegue 1: lunghezza (x) prima di eseguire il modulo.
sum(x|1)!
seq()invece di seq_along()fare la stessa cosa. Quindi di nuovo qualche byte in meno.
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 byte (di Martin)
#~Mod~Range@Tr[1^#]&
Tr[1^#]per Length@#.
#come ultimo carattere nella tua prima risposta.
VBE anonimo Funzione immediata della finestra che accetta una stringa di matrice delimitata da spazio ( ) come input dall'intervallo [A1]e genera i moduli numerici il loro indice basato su 1 nell'elenco iniziale nella finestra immediata di VBE
For Each n In Split([A1]):i=i+1:?n Mod i;:NextInput 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 Subversione di routineSubroutine che accetta input come array passato e ritagli nella finestra immediata di VBE.
Sub m(n)
For Each a In n
i=i+1
Debug.?a Mod i;
Next
End SubIngresso / Uscita:
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 SubInput Output:
Call modIndex(10,9,8,7,6,5,4,3,2,1)
0 1 2 3 1 5 4 3 2 1 {_,,:).%}
Blocco anonimo che prevede un array nello stack e lo sostituisce con l'array di output.
{ } e# Define block
_ e# Duplicate
, e# Length
, e# Range, 0-based
:) e# Add 1 to each entry
.% e# Vectorized modulus
(⍳⍴R)|R←⎕
APL opera da destra a sinistra, quindi le parentesi.
R←⎕assegna l'input dell'utente al vettore R.
⍴R indica la lunghezza del vettore; ⍳⍴Rdà un vettore con tutti i numeri da 1 a quella lunghezza (quindi gli indici).
|è l'operatore mod ( a|brendimenti b%a). APL opera su array, quindi il codice snippet un vettore contenente ogni elemento dall'input dell'utente mod il suo indice.
.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))Una funzione anonima che accetta n come input ed esegue il modulo in base all'elemento con l'elenco 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);}
Funziona anche in C # sostituendo ->con =>e lengthcon Length:
a=>{for(int i=0;i<a.Length;a[i]%=++i);}
Spiegazione:
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 l'input-array, quindi la mancanza di un ritorno.
->per =>e capitalizzare length.