टेक्स्ट के इस ब्लॉक को आउटपुट / प्रिंट करें:
1234567890
2468013579
3691470258
4815926037
5049382716
6172839405
7306295184
8520741963
9753108642
0987654321
स्वीकार्य प्रारूप में शामिल हैं:
हालाँकि, पूर्णांक की सूची स्वीकार्य नहीं है क्योंकि अंतिम पंक्ति पूर्णांक नहीं है।
यह कोड-गोल्फ है । बाइट्स जीत में सबसे छोटा जवाब। मानक खामियां लागू होती हैं।
जवाबों:
Mod[1##,11]~Mod~10&~Array~{10,10}
इसे ऑनलाइन आज़माएं! (गणित का उपयोग करना।)
1-आधारित इंडेक्स वाले सेल (x,y)का मूल्य है((x*y) % 11) % 10
लुइस के लिए एक बाइट धन्यवाद बचा लिया। मैं भूल रहा हूँ कि &नकल और ट्रांसपोज़िंग का एक शॉर्टकट है।
10:&*11\10\
@ मार्टिन एल्गोरिदम का उपयोग करना: x*y % 11 % 10
स्पष्टीकरण:
10 % Pust 10 to the stack. Stack: 1
: % 1-based range. Stack: [1 2 3 ... 10]
& % Duplicate range. Stack: [1 2 3 ... 10],[1 2 3 ... 10]
% Transpose last range. Stack [1 2 3 ... 10],[1;2;3 ...10]
* % Multiply with broadcasting. Stack: [1 2 3 ...;2 4 6...] (10-by-10 array)
11 % Push 11 to the stack. Stack [1 2 3 ...;2 4 6 ...], 11
\ % Modulus.
10 % Push 10 to the stack.
\ % Modulus
% Implicit display
उसी द्वारा:
10t:&*11\w\
t!*द्वारा&*
10|11|∘.×⍨⍳10मेरे गणितज्ञ उत्तर का एक बंदरगाह ।
∘.×⍨ ⍝ Multiplication table of...
⍳10 ⍝ The list from 1 to 10.
11| ⍝ mod 11.
10| ⍝ mod 10.बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।
10$*
1
,1$`
,1+
$_¶
(?<=(¶?.+)+)1
$#1$*
1{10}1?
,(1*)
$.1
एक और कार्यान्वयन ...% 11% 10 एल्गोरिथ्म। रेगेक्स के साथ करने का मज़ेदार हिस्सा यह है कि हम एक ही बार में दोनों मोडुलो कंप्यूटेशन का ध्यान रख सकते हैं।
10$*
स्ट्रिंग को प्रारंभिक रूप से दस 1एस।
1
,1$`
उनमें से प्रत्येक को अल्पविराम, एक, और उपसर्ग को उस एक के सामने बदलें। यह देता है ,1,11,...,1111111111, यानी एक unary रेंज।
,1+
$_¶
अब प्रत्येक रेंज तत्वों को एक लाइनफीड द्वारा पूरे स्ट्रिंग के साथ बदलें। यह हमें वर्तमान कॉलम को इंगित करने वाली संख्याओं का 10x10 ग्रिड देता है।
(?<=(¶?.+)+)1
$#1$*
प्रत्येक को मिलाएं 1और निर्धारित करें कि समूह एक को दोहराते हुए वह किस पंक्ति पर है। इसके 1साथ कई 1एस बदलें । यह पंक्ति के 1-आधारित सूचकांक द्वारा प्रत्येक पंक्ति में मूल्यों को गुणा करता है।
1{10}1?
अब करते हैं mod 11, mod 10 एक स्टेप में। मॉड 11 करने के लिए , हम आम तौर 1{11}पर स्ट्रिंग से बचे रहने के लिए स्ट्रिंग से सभी को हटा देंगे । और फिर हम उसके 1{10}बाद निकाल देंगे । लेकिन अगर हम 1संभव हो तो दस एस प्लस को हटा दें , रेगेक्स इंजन का लालच हमारे लिए संभव के रूप में लंबे समय तक मॉड 11 करेगा , और यदि नहीं, तो यह कम से कम 10 मॉड की कोशिश करेगा ।
,(1*)
$.1
अंत में, हम प्रत्येक संख्या को दशमलव में बदलकर उसकी लंबाई के साथ बदल देते हैं।
_=>[...1e9+''].map((_,a,b)=>b.map((_,c)=>-~a*++c%11%10))
बची हुई 4 बाइट्स शैगी की बदौलत और 8 बाइट्स अरनौलड की बदौलत।
_=>[...a=Array(10)].map((_,x)=>[...a].map((_,y)=>(x+1)*++y%11%10)):। तुम मुझे 4 बाइट्स बचाओ, मैं तुम्हें 4 बाइट्स बचा
map()और 1e9+''इसके बजाय 3 बाइट्स का उपयोग करके Array(10)। की ओर जाता है _=>[...1e9+''].map((_,x,a)=>a.map((_,y)=>-~x*++y%11%10))।
1e9ट्रिक के लिए धन्यवाद । मुझे नहीं पता था कि एक। मैंने तीसरे तर्क का उपयोग करने के बारे में सोचा था, लेकिन किसी कारण से मैंने इसका उपयोग नहीं किया।
यह पता चला है कि यह मेरा 200 (अपरिभाषित) उत्तर था :)
लगता है कि यह वही फॉर्मूला है जो मार्टिन ने देखा था ।
Aõ
£®*X%B%A
झसे आज़माओ ( -Rकेवल विज़ुअलाइज़ेशन उद्देश्यों के लिए ध्वज)
Aõ :Generate an array of integers from 1 to 10, inclusive.
£ :Map over each element in the array, returning...
® :Another map of the same array, which...
*X :Multiplies the current element of the inner function by the current element of the outer function...
%B :Modulus 11...
%A :Modulus 10.
:Implicit output of resulting 2D array
-Rध्वज का उपयोग कर सकते हैं
o->{String r="";for(int x=0,y;++x<11;r+="\n")for(y=0;++y<11;r+=x*y%11%10);return r;}@MartinEnder के गणितीय उत्तर के रूप में समान एल्गोरिथ्म का उपयोग करता है : 1-अनुक्रमित x*y%11%10।
स्पष्टीकरण:
o->{ // Unused Object parameter and String return-type
String r=""; // Result-String
for(int x=0,y;++x<11; // Loop (1) from 1 to 11 (exclusive)
r+="\n") // And append a new-line after every iteration
for(y=0;++y<11; // Inner loop (2) from 1 to 11 (exclusive)
r+=x*y%11%10 // And append the result-String with `x*y%11%10`
); // End of inner loop (2)
// End of loop (1) (implicit / single-line body)
return r; // Return result-String
} // End of method-6 बाइट्स ऑफेंशियलैम के लिए धन्यवाद।
मार्टिन के एल्गोरिथ्म का उपयोग करता है जिसके बारे में मुझे कोई समझ नहीं है कि वह इतनी तेजी से कैसे आया। o0
r=range(1,11)
print[[x*y%11%10for y in r]for x in r]r=range(1,11)6 बाइट्स बचाता है
eइसके बजाय एक बाइट % T
1:10%o%1:10%%11%%10कम से कम "R" -Loking बिट आर कोड मैंने कभी लिखा है। मार्टिन एंडर के उत्तर के रूप में एक ही एल्गोरिथ्म का उपयोग करता है (और साथ ही लगभग सभी अन्य उत्तर)। x %o% yके रूप में ही है outer(x, y)।
Ｆχ«ＦχＩ﹪﹪×⁺¹ι⁺¹κ¹¹χ⸿
मार्टिन के सूत्र का उपयोग करता है ।
»s की आवश्यकता नहीं है और जब आप ωइसके बजाय उपयोग कर सकते हैं ””तो बाइट्स के एक पूरे गुच्छा ⸿को इस प्रकार उपयोग करके बचा सकते हैं Ｆχ«ＦχＩ﹪﹪×⁺¹ι⁺¹κ¹¹χ⸿। (इससे पहले कि मैं इसके बारे में जानता था ⸿मैंने सुझाव दिया था Ｊ⁰ιजो अभी भी कई बाइट बचा सकता है।)
⸿रिवर्स ऑपरेटर है, यह आपके कोड के अंत में तर्कों के बिना क्या करता है? क्या यह प्रलेखित है?
⮌उल्टा ऑपरेटर, है ⸿है move cursor to start of next lineचरित्र (जैसे ¶, लेकिन एक अलग स्ट्रिंग में हो सकता है)।
f(x,y){for(x=0;x++<10;puts(""))for(y=0;y++<10;putchar(x*y%11%10+48));}[|?[|?a*b%11%z';
यह, निश्चित रूप से, मार्टिन की विधि का उपयोग करता है। यह इस QBasic कोड में अनुवाद करता है ।
[| FOR A = 1 to 10 ([ starts a FOR loop, | delimits the list of arguments;
a FOR loop with 0 args loops from 1 to 10 by default with increment 1.
? PRINT a newline
[| Start a second FOR loop from 1-10, iterator b
? PRINT
a*b%11%z the result of Martin's formula.
'; and suppress newlines/tabs/spaces
_=>{var r="";for(int x=0,y;++x<11;r+="\n")for(y=0;++y<11;r+=x*y%11%10);return r;}समान एल्गोरिथ्म अन्य उत्तरों में से अधिकांश के रूप में और अनिवार्य रूप से @Kevins जावा उत्तर के C # पोर्ट ।
12345678902468013579369147025848159260375049382716
.*
$&$&
O$^50>`.
.{10}
$&¶
10,{){\)*11%10%}+10,%}%`
-13 एक चतुर चाल के लिए धन्यवाद मार्टिन एंडर ने सुझाव दिया।
{-> ;, }-> `) में बदल देते हैं, तो आप कम से कम पहले छोड़ सकते हैं [।
{){\)*11%10%}+10,/n}10,/
/। ;)
int blk +-> {int space contents-of-blk}।
+चाल को लागू कर दिया है ... हालाँकि मैंने आपका कोड थोड़ा बदल दिया है
f(n,t){for(n=11;++n<121;putchar(t?t%10+48:10))t=n/11*n%11;}
10$*T
M!&`T+
m`$
;110$*T10$*
1
09876543210
m`(?<=^\1;\1{0,9}(T+))T
C
(?<!C.{108})\S
TS F~u0+*i>i%
TS - [1, 2, 3, 4, 5, 6, 7, 8, 9]
F~u0+*i>i% - for i in ^:
~u0+ - "01234567890"
* - ^ * i
i> - ^[i:]
i% - ^[::i]
for(;9>=$y++||9>=$x+=$y=print"
";)echo($x+1)*$y%11%10;for(;$x++<=9;print"
")for($y=0;$y++<=9;)echo$x*$y%11%10;()।
for(;<0>$y++||10>$x+=$y=print"\n";)echo($x+1)*$y%11%10;
for($x=1;11>++$y||11>$x+=$y=print"\n";)echo$x*$y%11%10;
1":(10|11|*&>:)"0/~@(i.@9:)
मार्टिन एंडर के गणितज्ञ उत्तर में उसी चाल का उपयोग करता है ।
1un@i/
/10<@i/01234567890/jl10<qnc0a^t>jtl%n>रॉड के पाइथन उत्तर का एक (काफी) सीधा कार्यान्वयन।
1un !initialize register n to 1!
@i/<nl>/ !insert a newline!
10< !loop for 10 rows!
@i/01234567890/ !insert the mysterious string of digits!
j !move point to start of buffer!
l !move forward past the newline!
10< !loop for 10 digits on a line!
qnc !move point forward by n characters!
0a^t !print the character at point!
> !end inner loop!
j !move point to start of buffer!
t !print (empty) line!
l !move to start of digit string!
%n !increment register n (for next line)!
> !end outer loop!<ESC> का उपयोग करके-प्रविष्ट कमांड और ^ T कमांड के लिए एक कंट्रोल कैरेक्टर दूसरे को बचाएगा तीन का उपयोग करने से पठनीयता की कीमत पर पाँच बाइट्स की ।
मार्टिन के mod-11 / mod-10 फॉर्मूले का उपयोग करना वास्तव में ^ A और ^ T के लिए नियंत्रणों का उपयोग करके 43 बाइट्स पर अधिक लंबा बनाता है, क्योंकि TECO के पास मॉड ऑपरेटर नहीं है।
0ur10<%run10<qn-10"g-11%n'qn\r0a^Tqr%n>^a
^A>जब भी यह 10. से अधिक हो, मॉड 11 को qn by -11 में संख्या बढ़ाकर एक चालू फैशन में किया जाता है qn\r0a^T क्रमबद्ध तरीके अनुक्रम एडिटिंग बफर में संख्या को दशमलव अंकों में सम्मिलित करता है, पिछले अंक को उलट देता है, इसे बफर और प्रकारों से पुनर्प्राप्त करता है, अनिवार्य रूप से mod-10 कर रहे हैं।
मुझे उम्मीद थी कि यह छोटा होगा। ओह अच्छा।