Diesen Textblock ausgeben / drucken:
1234567890
2468013579
3691470258
4815926037
5049382716
6172839405
7306295184
8520741963
9753108642
0987654321
Akzeptable Formate sind:
Eine Liste mit ganzen Zahlen ist jedoch nicht zulässig, da die letzte Zeile keine ganze Zahl ist.
Das ist Code-Golf . Kürzeste Antwort in Bytes gewinnt. Es gelten Standardlücken .
Antworten:
Mod[1##,11]~Mod~10&~Array~{10,10}
Probieren Sie es online! (Verwenden von Mathematik.)
Die Zelle bei 1-basiertem Index (x,y)hat einen Wert((x*y) % 11) % 10
Dank Luis ein Byte gespeichert. Ich vergesse immer wieder die &Abkürzung zum Duplizieren und Transponieren.
10:&*11\10\
Verwendung von @ Martins Algorithmus: x*y % 11 % 10
Erläuterung:
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
Gleiches bytecount:
10t:&*11\w\
t!*durch&*
10|11|∘.×⍨⍳10Ein Port meiner Mathematica-Antwort .
∘.×⍨ ⍝ Multiplication table of...
⍳10 ⍝ The list from 1 to 10.
11| ⍝ mod 11.
10| ⍝ mod 10.Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.
10$*
1
,1$`
,1+
$_¶
(?<=(¶?.+)+)1
$#1$*
1{10}1?
,(1*)
$.1
Eine weitere Implementierung des ...% 11% 10- Algorithmus. Der spaßige Teil mit einer Regex ist, dass wir beide Modulo-Berechnungen gleichzeitig erledigen können.
10$*
Initialisieren Sie die Zeichenfolge auf zehn 1Sekunden.
1
,1$`
Ersetzen Sie diese durch ein Komma, ein Eins und das Präfix davor. Dies ergibt ,1,11,...,1111111111also einen unären Bereich.
,1+
$_¶
Ersetzen Sie nun jedes der Bereichselemente durch die gesamte Zeichenfolge, gefolgt von einem Zeilenvorschub. Dies ergibt ein 10x10-Raster von unären Zahlen, die die aktuelle Spalte angeben.
(?<=(¶?.+)+)1
$#1$*
Ordnen Sie jede zu 1und bestimmen Sie, in welcher Zeile sie sich befindet, indem Sie die Gruppe eine so oft wiederholen. Ersetzen Sie die 1durch so viele 1s. Dies multipliziert die Werte in jeder Zeile mit dem auf 1 basierenden Index der Zeile.
1{10}1?
Jetzt machen wir Mod 11, Mod 10 in einem Schritt. Um Mod 11 zu machen , entfernen wir normalerweise einfach alles 1{11}von der Zeichenkette, um die restlichen Zeichen zu erhalten. Und dann würden wir danach entfernen 1{10}. Aber wenn wir nur zehn 1s plus eine weitere entfernen , wird die Gier der Regex-Engine so lange wie möglich Mod 11 für uns tun , und wenn nicht, wird es mindestens Mod 10 versuchen .
,(1*)
$.1
Schließlich konvertieren wir einfach jede Zahl in eine Dezimalzahl, indem wir sie durch ihre Länge ersetzen.
_=>[...1e9+''].map((_,a,b)=>b.map((_,c)=>-~a*++c%11%10))
4 Bytes dank Shaggy und 8 Bytes dank Arnauld gespeichert.
_=>[...a=Array(10)].map((_,x)=>[...a].map((_,y)=>(x+1)*++y%11%10)). Sie retten mich 4 Bytes, ich rette Sie 4 Bytes :)
map()und 3 weitere Bytes mit 1e9+''anstelle von verwenden Array(10). Das führt zu _=>[...1e9+''].map((_,x,a)=>a.map((_,y)=>-~x*++y%11%10)).
1e9Trick. Ich wusste das nicht. Ich habe überlegt, das dritte Argument zu verwenden, aber aus irgendeinem Grund habe ich es nicht verwendet.
Es stellte sich heraus, dass dies meine 200 (nicht gelöschte) Antwort hier war :)
Sieht so aus, als hätte Martin die gleiche Formel entdeckt .
Aõ
£®*X%B%A
Test it ( -RFlag nur zu Visualisierungszwecken)
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;}Verwendet den gleichen Algorithmus wie @MartinEnders Mathematica-Antwort : 1-indiziert x*y%11%10.
Erläuterung:
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 Bytes dank offcialaimm.
Verwendet Martins Algorithmus, von dem ich nicht verstehe, wie er so schnell darauf gekommen ist. o0
r=range(1,11)
print[[x*y%11%10for y in r]for x in r]r=range(1,11)speichert 6 Bytes
eanstelle von% T
1:10%o%1:10%%11%%10Das am wenigsten "R" aussehende Stück R-Code, das ich je geschrieben habe. Verwendet den gleichen Algorithmus wie die Antwort von Martin Ender (und fast alle anderen Antworten auch). x %o% yist das gleiche wie outer(x, y).
Ｆχ«ＦχＩ﹪﹪×⁺¹ι⁺¹κ¹¹χ⸿
Verwendet Martins Formel .
»s und können ωstattdessen ””eine ganze Reihe von Bytes speichern, indem Sie verwenden, ⸿wie dies dann der Fall ist Ｆχ«ＦχＩ﹪﹪×⁺¹ι⁺¹κ¹¹χ⸿. (Bevor ich davon wusste, ⸿hätte ich vorgeschlagen Ｊ⁰ι, dass immer noch eine Anzahl von Bytes eingespart werden.)
⸿ist der Reverse Operator, was macht er am Ende deines Codes ohne Argumente? Ist es dokumentiert?
⮌ist der Reverse-Operator, ⸿ist das move cursor to start of next lineZeichen (wie ¶, kann aber in einer separaten Zeichenfolge sein).
f(x,y){for(x=0;x++<10;puts(""))for(y=0;y++<10;putchar(x*y%11%10+48));}[|?[|?a*b%11%z';
Dabei wird natürlich Martins Methode angewendet. Es übersetzt zu diesen QBasic-Code übersetzt .
[| 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
12345678902468013579369147025848159260375049382716
.*
$&$&
O$^50>`.
.{10}
$&¶
10,{){\)*11%10%}+10,%}%`
-13 Dank eines cleveren Tricks schlug Martin Ender vor.
{-> ;, }-> `), können Sie zumindest das erste löschen [.
{){\)*11%10%}+10,/n}10,/
/. ;)
int blk +-> {int space contents-of-blk}.
+Trick implementiert ... obwohl ich Ihren Code ein wenig geändert habe
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:)
Verwendet den gleichen Trick wie in Martin Enders Mathematica-Antwort .
1un@i/
/10<@i/01234567890/jl10<qnc0a^t>jtl%n>Eine (ziemlich) einfache Implementierung von Rods Python-Antwort.
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!Die Verwendung von <ESC> -terminierten Einfügungen und eines Steuerzeichens für den Befehl ^ T würde auf Kosten der Lesbarkeit drei weitere fünf Bytes einsparen .
Wenn man Martins Mod-11 / Mod-10-Formel verwendet, wird die Länge bei Verwendung von Steuerelementen für ^ A und ^ T auf 43 Byte erhöht, hauptsächlich, weil TECO keinen Mod-Operator hat.
0ur10<%run10<qn-10"g-11%n'qn\r0a^Tqr%n>^a
^A>Mod 11 wird fortlaufend durchgeführt, indem die Zahl in qn immer dann um -11 erhöht wird, wenn sie 10 überschreitet qn\r0a^T Sequenz fügt die Zahl als Dezimalziffern in den Bearbeitungspuffer ein, kehrt nach der letzten Ziffer um, ruft sie aus dem Puffer ab und gibt sie ein. im wesentlichen tun mod-10.
Ich habe erwartet, dass es kürzer wird. Naja.