เอาท์พุท / พิมพ์บล็อกข้อความนี้:
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
บันทึกเป็นไบต์ขอบคุณ Luis ฉันลืมไป&เรื่อย ๆ ว่าเป็นทางลัดสำหรับการทำซ้ำและการส่งผ่านข้อมูล
10:&*11\10\
ใช้อัลกอริทึมของ @ Martin: 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พอร์ตของคำตอบ Mathematica ของฉัน
∘.×⍨ ⍝ Multiplication table of...
⍳10 ⍝ The list from 1 to 10.
11| ⍝ mod 11.
10| ⍝ mod 10.จำนวนไบต์ถือว่าการเข้ารหัส ISO 8859-1
10$*
1
,1$`
,1+
$_¶
(?<=(¶?.+)+)1
$#1$*
1{10}1?
,(1*)
$.1
การติดตั้งอัลกอริธึมอื่น... % 11% 10 ส่วนที่สนุกของการทำกับ regex คือเราสามารถดูแลการคำนวณแบบโมดูโลทั้งสองได้ในครั้งเดียว
10$*
เริ่มต้นสายถึงสิบ1s
1
,1$`
แทนที่แต่ละรายการเหล่านั้นด้วยเครื่องหมายจุลภาคหนึ่งและคำนำหน้าหน้าหนึ่ง สิ่งนี้จะให้,1,11,...,1111111111นั่นคือช่วงยูนารี
,1+
$_¶
ตอนนี้แทนที่องค์ประกอบแต่ละช่วงด้วยสตริงทั้งหมดตามด้วยตัวป้อนบรรทัด สิ่งนี้ทำให้เรามีตารางจำนวน 10x10 จำนวนของตัวเลขแบบยูนารีที่ระบุคอลัมน์ปัจจุบัน
(?<=(¶?.+)+)1
$#1$*
จับคู่แต่ละ1แถวแล้วกำหนดว่าแถวใดที่เปิดอยู่โดยทำซ้ำกลุ่มที่มีหลายครั้ง แทนที่1ด้วยที่หลาย1s สิ่งนี้จะคูณค่าในแต่ละแถวด้วยดัชนีที่อิงกับ 1 ของแถว
1{10}1?
ทีนี้ลองทำmod 11, mod 10ในขั้นตอนเดียว ในการทำmod 11โดยปกติแล้วเราเพียงแค่ลบทั้งหมดออก1{11}จากสตริงที่เหลือด้วยส่วนที่เหลือ แล้วเราจะลบ1{10}หลังจากนั้น แต่ถ้าเราเพียง แต่เอาสิบ1s บวกอีกถ้าเป็นไปได้ตะกละเครื่องยนต์ regex ที่จะทำmod 11สำหรับเราตราบใดที่เป็นไปได้และถ้าไม่เช่นนั้นก็จะพยายามอย่างน้อยmod 10
,(1*)
$.1
สุดท้ายเราก็แปลงตัวเลขแต่ละตัวให้เป็นทศนิยมโดยแทนที่ด้วยความยาว
l=[1..10]
f=[[x*i`mod`11`mod`10|i<-l]|x<-l]
_=>[...1e9+''].map((_,a,b)=>b.map((_,c)=>-~a*++c%11%10))
บันทึกแล้ว 4 ไบต์ขอบคุณ Shaggy และ 8 ไบต์ขอบคุณ Arnauld
_=>[...a=Array(10)].map((_,x)=>[...a].map((_,y)=>(x+1)*++y%11%10))ไบต์: คุณช่วยฉัน 4 ไบต์ผมช่วยให้คุณประหยัด 4 ไบต์ :)
map()และ 3 ไบต์มากขึ้นโดยใช้แทน1e9+'' นำไปสู่การที่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 's คำตอบ Mathematica : x*y%11%101
คำอธิบาย:
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 ไบต์
1:10%o%1:10%%11%%10อย่างน้อย "R" มองบิตของรหัส R ที่ฉันเคยเขียน ใช้อัลกอริทึมเดียวกันกับคำตอบของ Martin Ender (และเกือบทุกคำตอบอื่น ๆ เช่นกัน) เป็นเช่นเดียวกับx %o% youter(x, y)
Ｆχ«ＦχＩ﹪﹪×⁺¹ι⁺¹κ¹¹χ⸿
»และในขณะที่คุณสามารถใช้ωแทน””คุณสามารถบันทึกทั้งกลุ่มของไบต์โดยใช้เช่นนี้แล้วจะกลายเป็น⸿ Ｆχ«ＦχＩ﹪﹪×⁺¹ι⁺¹κ¹¹χ⸿(ก่อนที่ฉันจะรู้เกี่ยวกับ⸿ฉันจะแนะนำＪ⁰ιซึ่งจะยังคงบันทึกจำนวนไบต์.)
⸿ตัวดำเนินการย้อนกลับทำอะไรในตอนท้ายของรหัสของคุณโดยไม่มีอาร์กิวเมนต์? มันเป็นเอกสารหรือไม่?
⮌เป็นตัวดำเนินการย้อนกลับ⸿คือ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;}อัลกอริทึมเช่นเดียวกับคำตอบอื่น ๆ ส่วนใหญ่และที่สำคัญคือคำตอบ C # ของ@Kevins Java
12345678902468013579369147025848159260375049382716
.*
$&$&
O$^50>`.
.{10}
$&¶
10,{){\)*11%10%}+10,%}%`
-13 thanks to a clever trick Martin Ender suggested.
{ --> ;, } --> `), you can at least drop the first [.
{){\)*11%10%}+10,/n}10,/
/. ;)
int blk + -> {int space contents-of-blk}.
+ trick...although I altered your code a bit
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:)
Uses the same trick as in Martin Ender's Mathematica answer.
1un@i/
/10<@i/01234567890/jl10<qnc0a^t>jtl%n>A (fairly) straightforward implementation of Rod's Python answer.
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!Using <ESC>-terminated inserts and a control character for the ^T command would save another three five bytes, at the expense of readability.
Using Martin's mod-11/mod-10 formula actually makes it longer at 43 bytes using controls for ^A and ^T, mostly because TECO doesn't have a mod operator.
0ur10<%run10<qn-10"g-11%n'qn\r0a^Tqr%n>^a
^A>Mod 11 is done in an ongoing fashion by incrementing the number in qn by -11 whenever it exceeds 10. The qn\r0a^T sequence inserts the number in the editing buffer as decimal digits, reverses past the last digit, retrieves it from the buffer and types it, essentially doing mod-10.
I expected it to be shorter. Oh, well.