একটি সহজ একটি: ইনপুট হিসাবে ইতিবাচক পূর্ণসংখ্যার একটি তালিকা নিন এবং তালিকায় তাদের 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
উত্তর:
($[1..]).zipWith modঅ্যান্ডারস ক্যাসের্গের একটি গল্ফflip থেকে আমি শিখেছি একটি কৌশল ।
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)
যা 1 থেকে শুরু seq_along()করে একই দৈর্ঘ্যের ভেক্টর তৈরি করতে xএবং তারপরে %%মডুলো নিতে ব্যবহার করে।
seqযখন কোনও ভেক্টরের সাথে উপস্থাপন করা হয় তার ডিফল্ট আচরণ seq(along.with = x)যা একই আউটপুট seq_along(x), তবে 6 বাইট সংক্ষিপ্ত হয়।
seq(x)চারপাশে রাখা একটি সহজ জিনিস, যেহেতু আমি সবসময় ব্যবহার করি 1:length(x)।
x=scan();cat(x%%1:sum(1|x))@ জারকোকে ধন্যবাদ 5 টি বাইট
@ জিউজ্পে আরও 4 টি ধন্যবাদ রক্ষা করেছে
টেলর স্কটকে আরও 2 টি ধন্যবাদ রক্ষা করা হয়েছে
@ রিটার্নবুলকে আরও 2 টি ধন্যবাদ সংরক্ষণ করা হয়েছে
' 'শেষে (স্পেস) দরকার নেই cat; এটি ডিফল্ট বিভাজক
x<-scan();cat(x%%1:length(x)," ")- ওহ এবং কয়েকটি ফর্ম্যাটিং টিপস, ১) সঠিকভাবে ইন্টেন্ট করা এবং চিহ্নিত করার জন্য আপনার কোডের বামে কেবলমাত্র 4 টি স্পেস প্রয়োজন you) আপনি একটি <!-- language-all: lang-r -->পতাকা যুক্ত করতে পারেন আপনার কোডটি হাইলাইট করার আগে (যদিও এটি এই উদাহরণে সামান্য পরিবর্তিত হয়) 3) আপনার ভাষার নামের চারপাশে আপনার ব্র্যাকেটের দরকার নেই 4) ওহ এবং কোনও পোস্টে সম্পাদনা করার সময় আপনাকে কোনও মন্তব্য করার প্রয়োজন হবে না
=পরিবর্তে ব্যবহার করতে পারেন <-। (২) স্পেসিফিকেশনটি "মুদ্রণ" এর পরিবর্তে "আউটপুট" বলে, যাতে আপনি সম্ভবত cat()5 টি বাইট সংরক্ষণ করতে পারেন । (3) এর sum(1|x)চেয়ে এক বাইট কম length(x)।
(~T∊T∘.×T)/T←1↓⍳R ⍝ primes up to Rlife←{↑1 ω∨.∧3 4=+/,¯1 0 1∘.⊖¯1 0 1∘.⌽⊂ω} ⍝ Game of Life
(⊢~∘.×⍨)1↓⍳Rপ্রাইজ টু আর: এবং জিএল (সংস্করণ ১.0.০): K∊⍨⊢∘⊂⌺3 3যেখানে কে একটি ধ্রুবক।
;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: দৈর্ঘ্য (এক্স) সম্পাদন করে।
sum(x|1)!
seq()পরিবর্তে ব্যবহার করা seq_along()একই জিনিসটি আবিষ্কার করেছে। সুতরাং এটি আবার কয়েক বাইট সংক্ষিপ্ত।
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@#&
বা 20 বাইট (মার্টিন দ্বারা)
#~Mod~Range@Tr[1^#]&
Tr[1^#]জন্য Length@#।
#আপনার প্রথম উত্তরের দ্বিতীয় শেষ চরিত্র হিসাবে মিস করছেন ।
বেনামে ভিবিই তাত্ক্ষণিক উইন্ডো ফান্ট যা একটি স্থান ( ) সীমা থেকে [A1]আউটপুট হিসাবে অ্যারের স্ট্রিং নেয় এবং আউটপুট সংখ্যার মডিউলাসকে তাদের প্রথম ভিত্তিক সূচক তালিকায় ভিবিই তাত্ক্ষণিক উইন্ডোতে আউটপুট দেয়
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রুটিন সংস্করণসাবরোটাইন যা উত্তীর্ণ অ্যারে হিসাবে ইনপুট নেয় এবং ভিবিই তাত্ক্ষণিক উইন্ডোতে আউটআউট করে।
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
>:@i.@#|[
1 ... এন | মূল তালিকা
| মোড হয়
(⍳⍴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))একটি বেনামী ফাংশন যা ইনপুট হিসাবে এন নেয় এবং 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);}
এছাড়াও প্রতিস্থাপন C # এর কাজ করে ->দিয়ে =>এবং 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।