Herausforderung

Wiederholen Sie bei einer positiven ganzen Zahl jede ihrer Ziffern oft, wie es ihrer Position in . Mit anderen Worten, jede Ziffer sollte mal wiederholt werden (für jede , 1-indiziert), wodurch die neue Zahl erzeugt wird:d 1 , d 2 , d 3 , ⋯ , d n N d k k 1 ≤ k ≤ $N$$d_1, d_2, d_3, \cdots, d_n$$N$$d_k$$k$$1\le k\le n$

Schreiben Sie es dann horizontal und vertikal auf und füllen Sie die Lücken mit Kopien der Ziffer, die dem größeren Index zwischen dem Spaltenindex und dem Zeilenindex des Leerzeichens entspricht. Die endgültige Ausgabe sollte folgendermaßen aussehen:

Technische Daten

Sie können als Ganzzahl, als Zeichenfolge, als Ziffernliste oder als die Ziffern darstellende Zeichenliste verwenden. Die Ausgabe kann eine durch Zeilenumbrüche getrennte Zeichenfolge, eine Liste von Zeichenfolgen / Ganzzahlen oder eine Liste von Listen von Zeichen / Ziffern sein. Geben Sie jedoch nach Möglichkeit auch eine hübsche Druckversion an. Wenn es sich bei der Ausgabe um eine durch Zeilenumbrüche getrennte Zeichenfolge handelt, ist Folgendes zulässig:$N$

• führende / nachfolgende Leerzeichen haben, solange sich das Erscheinungsbild der Ausgabe nicht ändert
• Trennen Sie die Spalten durch konsistente Leerzeichen oder die Zeilen durch eine konsistente Anzahl von Zeilenumbrüchen (ungleich Null)

Sie können Eingaben und Ausgaben mit jeder Standardmethode vornehmen , wobei zu beachten ist, dass diese Lücken standardmäßig verboten sind. Das ist Code-Golf , also versuchen Sie, die Aufgabe in den wenigsten Bytes zu erledigen, die Sie in der Sprache Ihrer Wahl verwalten können.

Testfälle

65:

655
555
555

---------------

203:

200333
000333
000333
333333
333333
333333

--------------

233:

233333
333333
333333
333333
333333
333333

---------------

5202:

5220002222
2220002222
2220002222
0000002222
0000002222
0000002222
2222222222
2222222222
2222222222
2222222222

---------------

12345:

122333444455555
222333444455555
222333444455555
333333444455555
333333444455555
333333444455555
444444444455555
444444444455555
444444444455555
444444444455555
555555555555555
555555555555555
555555555555555
555555555555555
555555555555555

JavaScript (ES7), 70 Byte

Übernimmt die Eingabe als Zeichenfolge. Gibt eine Zeichenfolge mit einem nachfolgenden Zeilenumbruch zurück.

s=>(g=x=>(c=s[(x>y?x:y)**.5-1>>1])?c+g(x+8):x>y?`
`+g(1,y+=8):'')(y=1)

Probieren Sie es online!

Wie?

Methode

Wir bauen die Ausgabe zeichenweise auf, indem wir durch eine quadratische Matrix gehen und jede Zelle in einen Index in die Eingabezeichenfolge umwandeln .$i_{x,y}$

Koordinaten zum Zeichenkettenindex

Die obere Grenze der n t h digit Bereich (0-indizierte) entlang jeder Achse ist gegeben durch A000096 :$u_{n}$$n^{th}$

u0=0,u1=2,u2=5,u3=9,u4=14,u5=20,

Wenn eine ganze Zahl , können wir herausfinden, in welchem ​​Bereich n = ⌋ x ⌋ + 1 sie liegt, indem wir lösen:$k$$n=\lfloor{x}\rfloor+1$

Führen zu:

n=⌊

Für jede Zelle definieren wir:$(x, y)$

Diese Werte werden in Indizes i x , y in die Eingabezeichenfolge umgewandelt, indem Folgendes ausgeführt wird:$v_{x,y}$$i_{x,y}$

 v(x,y) |  0  1  2  3  4  5  6  7  8  9        i(x,y) |  0  1  2  3  4  5  6  7  8  9
--------+-------------------------------      --------+-------------------------------
    0   |  1  9 17 25 33 41 49 57 65 73           0   |  0  1  1  2  2  2  3  3  3  3
    1   |  9  9 17 25 33 41 49 57 65 73           1   |  1  1  1  2  2  2  3  3  3  3
    2   | 17 17 17 25 33 41 49 57 65 73           2   |  1  1  1  2  2  2  3  3  3  3
    3   | 25 25 25 25 33 41 49 57 65 73           3   |  2  2  2  2  2  2  3  3  3  3
    4   | 33 33 33 33 33 41 49 57 65 73   -->     4   |  2  2  2  2  2  2  3  3  3  3
    5   | 41 41 41 41 41 41 49 57 65 73           5   |  2  2  2  2  2  2  3  3  3  3
    6   | 49 49 49 49 49 49 49 57 65 73           6   |  3  3  3  3  3  3  3  3  3  3
    7   | 57 57 57 57 57 57 57 57 65 73           7   |  3  3  3  3  3  3  3  3  3  3
    8   | 65 65 65 65 65 65 65 65 65 73           8   |  3  3  3  3  3  3  3  3  3  3
    9   | 73 73 73 73 73 73 73 73 73 73           9   |  3  3  3  3  3  3  3  3  3  3

Haltebedingungen

Wir wissen, dass wir erreicht haben:

• die rechte Grenze der Matrix, wenn das Zeichen bei nicht existiert und wir x > $i_{x,y}$$x > y$

• die untere Grenze der Matrix, wenn das Zeichen nicht existiert und wir $x \le y$

J , 16-15 Bytes

-1 Byte dank FrownyFrog!

{~#\<:@>./~@##\

Probieren Sie es online!

Nimmt Nals Zeichenfolge.

Erklärung der Ausgangslösung:

              #\   finds the length of the successive prefixes of the input (1 2 3...)
            #~     copies each digit as many times (1 2 2 3 3 3...)  
       >./~@       and creates a table of the max of the row/col numbers
  [:<:@            then subtract 1 from each element (for indexing)
{~                 select the corresponding digit from the input

Testsitzung mit Eingabe 203:

   #\ '203'
1 2 3

   #~#\ '203'
1 2 2 3 3 3

   >./~@#~#\ '203'
1 2 2 3 3 3
2 2 2 3 3 3
2 2 2 3 3 3
3 3 3 3 3 3
3 3 3 3 3 3
3 3 3 3 3 3

   <:@>./~@#~#\ '203'
0 1 1 2 2 2
1 1 1 2 2 2
1 1 1 2 2 2
2 2 2 2 2 2
2 2 2 2 2 2
2 2 2 2 2 2

   ({~[:<:@>./~@#~#\) '203'
200333
000333
000333
333333
333333
333333

Haskell , 60 59 58 Bytes

f x|s<-do(n,_)<-zip[0..]x;n<$[0..n]=[(x!!).max a<$>s|a<-s]

Probieren Sie es online!

Punktfreie Version (68 Bytes)

(map=<<(.((snd.).max)).flip map).((\t@(n,c)->t<$[1..n])=<<).zip[1..]

Probieren Sie es online!

Python 2 , 71 Bytes

i=j=0;r=''
for x in input():i+=1;r+=x*i
for c in r:print j*c+r[j:];j+=1

Probieren Sie es online!

Erzeugt zuerst die erste Zeile rund iteriert dann r, um jede Zeile zu drucken.

R , 59 Bytes

function(a){m=outer(x<-rep(g<-seq(a),g),x,pmax);m[]=a[m];m}

Probieren Sie es online!

• Mir ist aufgefallen, dass es akzeptabel ist, einen Vektor von Ziffern zu verwenden. Dadurch konnte ich 21 Bytes sparen :)
• -2 Bytes dank @ Giuseppe Vorschlag, nur Zeichenvektor zu akzeptieren
• -2 Bytes werden in der Argumentdefinition zugewiesen

Gelee , 7 Bytes

Jx`»þ`ị

Probieren Sie es online!

Ausgabe geklärt.

05AB1E , 14 11 10 Bytes

Dank Magic Octopus Urn / Adnan 1 Byte gespeichert

ƶJDv¬N×?=¦

Probieren Sie es online!

Erläuterung

ƶ            # repeat each element its index (1-based) times 
 J           # join to string
  Dv         # for N in [0 ... len(string)-1] do
    ¬N×      # push the head repeated N times
       ?     # print without newline
        =    # print the rest of the string without popping
         ¦   # remove the head

APL (Dyalog Classic) , 16 Byte

{⍵[∘.⌈⍨(/⍨⍳⍴⍵)]}

Ich trenne diese Lösung mit meiner Antwort von der Post, wie von Jo King vorgeschlagen

Probieren Sie es online!

Python 2 , 74 Bytes

i=1;a=[]
for c in input():exec"a=zip(*a+[c*-~len(a)]);"*i;i+=2+i%2
print a

Probieren Sie es online!

Excel VBA, 95 Bytes

Eine anonyme VBE-Direktfensterfunktion, die Eingaben von [A1]und Ausgaben an die Konsole entgegennimmt

n=[len(A1)]:For y=1To n:For l=1To y:?:For x=1To n:?String(x,Mid([A1],IIf(x>y,x,y)));:Next x,l,y

Ungolfed und kommentiert

n=[len(A1)]                         ''  Get Length
For y=1To n                         ''  Iterate down input
For l=1To y                         ''  Iterate down repeat lines
?                                   ''  Print Newline
For x=1To n                         ''  Iterate accross input
?String(x,Mid([A1],IIf(x>y,x,y)));  ''  Print x of the `max(x,y)`th digit in input
Next x,r,y                          ''  Loop, Loop, Loop

MATL , 15 12 Bytes

tftY"t!2$X>)

Probieren Sie es online!

Ich vermute, das kann gekürzt werden, aber es ist nicht so schlimm ...

          % implicit input, '230'
t         % duplicate input. Stack: ['230','230']
f         % indices of nonzero values. Stack: ['230',[1,2,3]]
t         % duplicate. Stack: ['230',[1,2,3],[1,2,3]]
Y"        % run-length decoding. Stack: ['230',[1,2,2,3,3,3]]
t         % duplicate. Stack: ['230',[1,2,2,3,3,3],[1,2,2,3,3,3]]
!         % transpose. Stack: ['230',[1,2,2,3,3,3],[1;2;2;3;3;3]]
2$X>      % elementwise maximum of 2 inputs, with broadcast.
          % Stack:
          % ['230',
          % [1, 2, 2, 3, 3, 3;
          %  2, 2, 2, 3, 3, 3;
          %  2, 2, 2, 3, 3, 3;
          %  3, 3, 3, 3, 3, 3;
          %  3, 3, 3, 3, 3, 3;
          %  3, 3, 3, 3, 3, 3]]
 )        % index into G
          % implicit end, display stack contents

Add ++ , 35 Bytes

L,bLRdBcB]£X¦Ω+d‽b>1€Ω_A€Ω:AbLR¦+$T

Probieren Sie es online!

Wie es funktioniert

Wir nehmen Eingaben als eine Liste von Ziffern, während verhindert wird, dass wir a) in Ziffern umwandeln BDmüssen und auch die Ziffern speichern müssen, die zwei Bytes benötigen würden.

bLR$n$$n$dBcB]$[[1, 1], [2, 2] ... [n, n]]$£X¦Ω+

Als nächstes duplizieren wir dieses Array und tabellieren es nach Maximum d‽b>. Das heißt, jedes Element im Array wird mit jedem anderen Element aus dem zweiten Array gepaart, und der Befehl dyadic maximum wird über das Paar ausgeführt. Bei einer Beispieleingabe von [6 5] wird das Array [1 2 2 2 2 2 2 2 2] , das eine abgeflachte Version des Mosaiks ist, als Index für das Array erstellt. Leider hinzufügen ++ verwendet 0-indizierte Arrays, so dass wir jedes Element verringern müssen: 1€Ω_.

A€Ω:$x$

$x^{th}$ AbLR¦+T$n$$T

Kohle , 17 Bytes

Ｆ⮌…ＬθＵＯ⊕⊘×ι⁺³ι§θι

Probieren Sie es online! Erläuterung:

Ｆ⮌…Ｌθ

Durchlaufen Sie die Indizes der Zeichen in umgekehrter Reihenfolge.

⊕⊘×ι⁺³ι

Berechnen Sie die Größe des Quadrats.

ＵＯ...§θι

Zeichnen Sie das Quadrat mit dem aktuellen Zeichen.

Canvas , 12 Bytes

ø╶｛；ｌ└²＋：＊；ｎ

Probieren Sie es hier aus!

Python 2 , 76 73 Bytes

-3 Bytes dank Lynn .

l=0;m=[]
for k in input():l+=1;m=[r+l*k for r in m]+l*[l*-~l/2*k]
print m

Probieren Sie es online!

Holzkohle , 14 Bytes

Ｅ⭆θ×⊕κι×⊕κι‖Ｏ↗

Probieren Sie es online!

Wie?

Ｅ⭆θ×⊕κι×⊕κι‖Ｏ↗ - implicitly print the result of...
Ｅ                - map:
  ⭆              -   over: string map:       
    θ             -     over: first input
     ×            -     using: repeat
        ι         -       what: ι (loop value)
      ⊕κ          -       by: incremented κ (loop counter)
         ×        -   using: repeat
            ι     -     what: ι (loop value)
          ⊕κ      -     by: incremented κ (loop counter)
             ‖Ｏ  - Reflect with overlap:
                ↗ -   direction: up-right

... kann man mit dieser Methode Golf spielen?

Stax , 12 Bytes

ü°√¿«│⌠º₧@\τ

Führen Sie es aus und debuggen Sie es

Mit diesem Algorithmus .

Erläuterung:

c%R:BXm]i*xit+ Full program, implicit input
c%             Length of input
  R            1-based range
   :B          Repeat each element according to the range ("123" -> "122333")
     X         Save to X register
      m        Map:
       ]         Character -> string
        i*       Repeat by iteration index
          xit    Trim first <iteration index> elements from X
             +   Concatenate
                 Implicit output with newline

Stax , 20 19 18 16 Bytes

ù↔‼i,ÑΓæ☺=╘‼æ↕4╝

Führen Sie es aus und debuggen Sie es

Erläuterung:

c%R:BX%mYx%{y|Mvx@m Full program, implicit input
c%                  Length of input
  R                 1-based range
   :B               Repeat each element according to the range ("123" -> "122333")
     X              Save to X register
      %             Length
       m            Map over 1-based range:
        Y             Save index to Y register
         x%           Push length of X register
           {      m   Map over 1-based range:
            y|M         Maximum of both indices
               v        1-based -> 0-based (decrement)
                x@      Index into X register
                      Implicit output with newline

Attache , 34 Bytes

{_[Table[Max,Flat!{_&_}=>1:#_]-1]}

Probieren Sie es online!

Erläuterung

Funktioniert ähnlich wie Galen Ivanovs J-Antwort .

{_[Table[Max,Flat!{_&_}=>1:#_]-1]}
{                                }   anonymous function: _ is input, array of digits
                                     example: _ := [2, 0, 3]
                         1:#_        the range 1 to Size[_]
                                     > e.g.: [1, 2, 3]
                  {   }=>            over each number N:
                   _&_                   map to N repeated N times
                                     > e.g.: [[1], [2, 2], [3, 3, 3]]
             Flat!                   flatten it
                                     > e.g.: [1, 2, 2, 3, 3, 3]
   Table[Max,                ]       create a "max" table with it
                                     > e.g.:
                                       1 2 2 3 3 3
                                       2 2 2 3 3 3
                                       2 2 2 3 3 3
                                       3 3 3 3 3 3
                                       3 3 3 3 3 3
                                       3 3 3 3 3 3
                              -1     subtract 1 from each
                                     > e.g.:
                                       0 1 1 2 2 2
                                       1 1 1 2 2 2
                                       1 1 1 2 2 2
                                       2 2 2 2 2 2
                                       2 2 2 2 2 2
                                       2 2 2 2 2 2
 _[                             ]    index the original array with this matrix
                                     > e.g.:
                                       2 0 0 3 3 3
                                       0 0 0 3 3 3
                                       0 0 0 3 3 3
                                       3 3 3 3 3 3
                                       3 3 3 3 3 3
                                       3 3 3 3 3 3

K (ngn / k) , 16 Bytes

{x@i|\:i:&1+!#x}

Probieren Sie es online!

C (gcc) 130 Bytes

Wer braucht ausgefallene Mathematik, wenn man bruteforce kann?

n,l;R(n,c){for(;n--;)putchar(c);}f(s){for(char*p=s,*q;*p++;)for(n=l=p-s;l--;R(1,10))for(R(n*n+n>>1,p[-1]),q=p;*q;q++)R(q-s+1,*q);}

Probieren Sie es online!

QBasic 1.1 , 127 Bytes

INPUT S$
FOR X=1TO LEN(S$)
K=K+X
R$=R$+STRING$(X,MID$(S$,X,1))
NEXT
FOR C=1TO K
?STRING$(C-1,MID$(R$,C,1))RIGHT$(R$,K-C+1)
NEXT

-4 dank DLosc .

Verwendet eine modifizierte Version des Python 2-Algorithmus von xnor .

Die Eingabe ist eine Zeichenfolge ohne Anführungszeichen. Die Ausgabe wird \nohne zusätzliche Leerzeichen oder \ns getrennt.

QBasic , 111 Bytes

Eine anonyme Funktion, die zur Eingabe und Ausgabe an die Konsole auffordert.

INPUT s$
n=LEN(s$)
FOR y=1TO n
FOR l=1TO y
?
FOR x=1TO n
z=x
IF y>x THEN z=y
?STRING$(x,MID$(s$,z));
NEXT x,l,y

Php 7.1 , 163 Bytes

Über die CLI, die die Nummer als Argument angibt:

<?foreach(str_split($argv[1])as$k=>$d)$a[]=array_fill(0,$s+=$k+1,array_fill(0,$s,$d));foreach(array_replace_recursive(...array_reverse($a))as$v)echo join($v)."\n";

Nicht so gut gespielt:

$n = 123;

foreach(str_split($n) as $k => $d) {
    $s += $k + 1;
    $a[] = array_fill(0, $s, array_fill(0, $s, $d));
}

foreach(array_replace_recursive(...array_reverse($a)) as $v)
    echo implode('', $v) . "\n";

Ausgabe:

122333
222333
222333
333333
333333
333333

Methode:

Bauen Sie im Allgemeinen mehrdimensionale Array-Quadrate auf, die aus der Ziffer bestehen, und überlagern Sie sie dann alle (array_replace_recursive).

(Ja, ich weiß, das ist peinlich lang.)

Ruby , 80 Bytes

->n{s=(1..n.size).map{|i|n[i-1]*i}*"";(0...s.size).map{|i|s[i]*i+s[i..-1]}*"\n"}

Probieren Sie es online!

Ähnlich wie Ovs Antwort

Japt, 12 Bytes

Nimmt Eingaben als Zeichenfolge und gibt ein Array von Zeichenfolgen aus.

Ë+pE
¬£h°YçX

Versuch es

Erläuterung

            :Implicit input of string U
Ë           :Map each character D at 0-based index E
  pE        :  Repeat D E times
 +          :  Append to D
\n          :Reassign to U
¬           :Split to character array
 £          :Map each element X at 0-based index Y
   °Y       :  Increment Y
     çX     :  Repeat X Y times
  h         :  Replace the first Y characters in U with that

UBASIC , 120 Byte

Eine anonyme Funktion, die die Eingabe von foprm STDIN und die Ausgabe an STDOUT übernimmt

0Input"",S$:N=Len(S$):ForY=1ToN:ForL=1ToY:ForX=1ToN:ForC=1ToX:Z=X:IfY>XThenZ=Y
1?Mid$(s$,z,1);:NextC:NextX:?:NextL:NextY

Probieren Sie es online!

Visual Basic .NET (VBC) , 198 Byte

Eine SubRoutine, die Eingaben von STDIN entgegennimmt und an STDOUT ausgibt.

StrDup konnte nicht zum Laufen gebracht werden: /

Module M
Sub Main
Dim c,s,n,l,x,y
s=Console.readLine()
n=Len(s)
For y=1To n
For l=1To y
For x=1To n
For c=1To x
Console.Write(Mid(s,IIf(x>y,x,y),1)&IIf(c=n,vbLf,""))
Next c,x,l,y 
End Sub
End Module

Probieren Sie es online!

Lua, 149-140 Bytes

Funktion, die eine Liste von Ziffernfolgen akzeptiert und das Ergebnis auf stdout ausgibt. Dies ist mein erster Versuch, Code Golf zu spielen (und die Sprachauswahl hilft auch nicht).

Probieren Sie es online!

function(a)F,s=0,""for b=1,#a do s=s..a[b]:rep(b)end;for b=1,#a do io.write((s.."\n"):rep(b))F,z=F+b,a[b+1]or""s=z:rep(F)..s:sub(F+1)end end

Ungolfed:

G = function(p)
    F,s = 0,""
    for i=1,#p do
        s=s..p[i]:rep(i)
    end
    for i=1, #p do
        io.write((s.."\n"):rep(i))
        F,z = F+i, p[i+1]or""
        s = z:rep(F)..s:sub(F+1)
    end
end
-- allows to pass the argument list from stdin
-- example: {"1", "2", "3", "4", "5"}
G(load("return " .. io.read())())

Perl 5+ -nalF -M5.010, 67 Bytes

s/./$&x++$-/ge;eval'eval"say;"x++$i;$x+=$i;s/.{$x}/$F[$i]x$x/e;'x@F

Probieren Sie es online!

Yabasic , 108 Bytes

Eine anonyme Funktion, die Eingaben von STDIN akzeptiert und an STDOUT ausgibt

Input""s$
n=len(s$)
For y=1To n
For r=1To y
For x=1To n
For c=1To x?Mid$(s$,max(x,y),1);Next
Next
?Next
Next

Probieren Sie es online!