एक साधारण: इनपुट के रूप में सकारात्मक पूर्णांक की एक सूची लें और संख्याओं को सूची में उनके 1-आधारित सूचकांक को मापें।
यदि इनपुट पूर्णांक हैं, {a, b, c, d, e, f, g}तो आउटपुट होना चाहिए {a%1, b%2, c%3, d%4, e%5, f%6, g%7}जहां %मापांक ऑपरेटर है।
परीक्षण के मामलों:
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
जवाबों:
f={l=_this;r=[];i=0;while{i<count l}do{r=r+[(l select i)%(i+1)];i=i+1};r}
के साथ बुलाना:
numList = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1];
hint format["%1\n%2", numList, numList call f];
आउटपुट:
i=1
for x in input():print x%i;i+=1मेरी एक टिप के अनुसार, इंडेक्स को मैन्युअल रूप से गिनता है ।
%J
स्पष्टीकरण:
%J
J List 1 .. len(input). This is results in a list of the indexes.
% Modulo.
मूल रूप से, कोड इंडेक्स की सूची द्वारा मूल सूची को मापता है।
%Jजेली में है, मुझे आश्चर्य है कि क्या किसी ने उस उत्तर के साथ जवाब दिया है?"। मुझे लगता है कि किसी और का एक ही विचार था :-D
pryr::f(x%%seq(x))
फ़ंक्शन का मूल्यांकन:
function (x)
x%%seq(x)
जो seq_along()एक ही लंबाई का वेक्टर बनाने के लिए उपयोग करता है x, जो 1 से शुरू होता है, और फिर %%मोडुलो लेने के लिए।
seqएक वेक्टर के साथ प्रस्तुत किए जाने पर डिफ़ॉल्ट व्यवहार seq(along.with = x)जो कि आउटपुट के समान होता है seq_along(x), लेकिन 6 बाइट्स छोटे होते हैं।
seq(x)के बाद से मैं हमेशा उपयोग कर रहा हूँ के आसपास एक आसान बात है 1:length(x)।
x=scan();cat(x%%1:sum(1|x))@Jarko के लिए 5 बाइट्स धन्यवाद बचाया
@Giuseppe के लिए 4 और धन्यवाद सहेजे गए
@Taylor Scott को 2 और धन्यवाद दिए
@Returnbull को 2 और धन्यवाद दिए गए
' 'अंत में (स्थान) की आवश्यकता नहीं है cat; यह डिफ़ॉल्ट विभाजक है
x<-scan();cat(x%%1:length(x)," ")- ओह और एक जोड़ी स्वरूपण युक्तियां, 1) आपको केवल अपने कोड के बाईं ओर 4 रिक्त स्थान की आवश्यकता है इसके लिए ठीक से इंडेंट और चिह्नित 2) आप एक <!-- language-all: lang-r -->झंडा जोड़ सकते हैं इससे पहले कि आपके कोड को हाइलाइट किया जाए (हालांकि इस उदाहरण में यह थोड़ा बदल जाता है) 3) आपको अपनी भाषा के नाम के चारों ओर ब्रैकेट की आवश्यकता नहीं है 4) ओह और जब आप किसी पोस्ट में संपादन करते हैं तो आपको टिप्पणी करने की आवश्यकता नहीं है
=के <-लिए उपयोग कर सकते हैं । (2) विनिर्देश "प्रिंट" के बजाय "आउटपुट" कहता है, जिससे आप संभवतः cat()5 बाइट्स बचा सकते हैं । (3) sum(1|x)एक बाइट से छोटा है length(x)।
(~T∊T∘.×T)/T←1↓⍳R ⍝ primes up to Rयाlife←{↑1 ω∨.∧3 4=+/,¯1 0 1∘.⊖¯1 0 1∘.⌽⊂ω} ⍝ Game of Life
(⊢~∘.×⍨)1↓⍳Rऔर GoL (संस्करण 16.0 में): K∊⍨⊢∘⊂⌺3 3जहां K एक स्थिरांक है।
;ww.1I!@s%Ow;)Sow.$
; w
w .
1 I ! @ s % O w
; ) S o w . $ .
. .
. .
एक काफी सीधे आगे कार्यान्वयन।
1 इंडेक्स शुरू करने के लिए स्टैक पर 1 पुश करेंI!@ पूर्णांक इनपुट प्राप्त करें और यदि 0 रुका हुआ हैs%Ow इंडेक्स अप, मॉड, आउटपुट परिणाम और परिवर्तन लेन को स्वैप करें;) परिणाम और वेतन वृद्धि सूचकांक निकालेंSow पुश 32, आउटपुट स्पेस और चेंज लेन (ओ से नीचे जा रहा है)$O उत्पादन कूदोw;wलैंग बदलें, स्टैक से 32 निकालें और Iइनपुट पर लेन बदलेंā%
इसे ऑनलाइन आज़माएं! या सभी परीक्षणों का प्रयास करें
ā # Push the range(1, len(a) + 1)
% # Mod each element in the input by the same one in this list
DgL%अच्छा होगा।
gL%क्योंकि मैं भूल गया था ā।
āमेरे लिए थोड़ा और अधिक गहराई में जा रहा है ? मेरा मानना है कि मैंने कभी भी इसका उपयोग नहीं किया है यह सिर्फ for eachएक 1 to n+1तरह से है vy<code>})लेकिन निहित है vy<code>})?
#&@@@Mod~MapIndexed~#&
एक और गणितज्ञ दृष्टिकोण।
MapIndexed@Modहै लगभग काफी अच्छा: ( '
+` , + + * + + + +* + * . + + .'
यह एक अनंत लूप है जो इनपुट से संख्याओं को पढ़ता रहता है और काउंटर को बढ़ाता है 1। इनपुट और काउंटर के प्रत्येक जोड़े के लिए, मापांक की गणना और मुद्रित किया जाता है।
लूप को समाप्त करने के लिए जब इनपुट समाप्त हो गया है, तो निम्न चाल का उपयोग किया जाता है। जब कोई अधिक इनपुट उपलब्ध नहीं होता है, तो एक और संख्या को पढ़ने की कोशिश करना एक देता है 0। इस प्रकार, हम पढ़ी गई संख्या को अपने आप से विभाजित करते हैं, और अगर यह 0कार्यक्रम एक त्रुटि के साथ समाप्त होता है। और हम परिणाम को जारी रखते हैं और जारी रखते हैं।
+ 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(वास्तव में, Yअगर आप चाहते थे तब भी आप वहां उपयोग कर सकते हैं )
pryr::f(x%%1:sum(x|1))
मापांक करने से पहले आर 1: लंबाई (x) करता है।
sum(x|1)!
seq()बजाय का उपयोग कर seq_along()। ताकि कुछ बाइट्स फिर से कम हो।
#~Mod~Range@Length@#&
या 20 बाइट्स (मार्टिन द्वारा)
#~Mod~Range@Tr[1^#]&
Tr[1^#]के लिए Length@#।
#अपने पहले उत्तर में दूसरे अंतिम पात्र के रूप में याद कर रहे हैं ।
अनाम VBE तत्काल विंडो फ़ंक्शंस जो एक स्थान लेता है ( ) श्रेणी से इनपुट के रूप में सीमांकित सरणी स्ट्रिंग [A1]और संख्याओं को आउटपुट करता है 1-आधारित इंडेक्स को शुरुआती सूची में VBE तत्काल विंडो में मापता है
For Each n In Split([A1]):i=i+1:?n Mod i;:Nextइनपुट आउटपुट:
[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रूटीन वर्जनसबरूटीन जो इनपुट को पारित सरणी के रूप में लेता है और VBE तत्काल विंडो को आउटआउट करता है।
Sub m(n)
For Each a In n
i=i+1
Debug.?a Mod i;
Next
End Subइनपुट / ऑपुट:
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 Subइनपुट आउटपुट:
Call modIndex(10,9,8,7,6,5,4,3,2,1)
0 1 2 3 1 5 4 3 2 1 {_,,:).%}
बेनामी ब्लॉक जो स्टैक पर एक सरणी की उम्मीद करता है और इसे आउटपुट सरणी द्वारा बदल देता है।
{ } e# Define block
_ e# Duplicate
, e# Length
, e# Range, 0-based
:) e# Add 1 to each entry
.% e# Vectorized modulus
(⍳⍴R)|R←⎕
एपीएल दाएं से बाएं ओर संचालित होता है, इसलिए कोष्ठक।
R←⎕वेक्टर को उपयोगकर्ता इनपुट प्रदान करता है R।
⍴Rवेक्टर की लंबाई देता है; ⍳⍴R1 से उस लंबाई (ताकि सूचकांकों) के सभी नंबरों के साथ एक वेक्टर देता है।
|मॉड ऑपरेटर ( a|bपैदावार b%a) है। एपीएल सरणियों पर काम करता है, इसलिए कोड स्निपेट एक वेक्टर होता है जिसमें उपयोगकर्ता के इनपुट मॉड से प्रत्येक तत्व होता है।
.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))एक अनाम फ़ंक्शन जो इनपुट के रूप में n लेता है , और सूची 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);}
इसके अलावा की जगह सी # में काम करता है ->के साथ =>और lengthसाथ Length:
a=>{for(int i=0;i<a.Length;a[i]%=++i);}
स्पष्टीकरण:
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
इनपुट-सरणी को संशोधित करता है, इसलिए रिटर्न की कमी है।
->हैं =>और कैपिटलाइज़ करते हैं length।