Sfida

Dato un intero positivo $N$ , ripetere ognuna delle sue cifre $d_1, d_2, d_3, \cdots, d_n$ un numero di volte corrispondente alla posizione in . In altre parole, ogni cifra dovrebbe essere ripetuta volte (per ogni , 1-indicizzata), creando così il nuovo numero:d k k 1 ≤ k ≤ $N$$d_k$$k$$1\le k\le n$

Quindi, scriverlo sia in orizzontale che in verticale e riempire gli spazi vuoti con copie della cifra che corrisponde all'indice maggiore tra l'indice di colonna e l'indice di riga dello spazio vuoto. L'output finale dovrebbe apparire così:

Specifiche

Puoi prendere come un numero intero, una stringa, un elenco di cifre o un elenco di caratteri che rappresentano le cifre. L'output può essere una stringa separata da una nuova riga, un elenco di stringhe / numeri interi o un elenco di elenchi di caratteri / cifre, ma, se possibile, includere anche una versione piuttosto stampata. Se l'output è una stringa separata da una nuova riga, è anche accettabile:$N$

• hanno spazi iniziali / finali, purché l'aspetto visivo dell'output non cambi
• separare le colonne usando una quantità coerente di spazi o le righe con una quantità coerente (diversa da zero) di newline

Puoi prendere input e fornire output attraverso qualsiasi metodo standard , tenendo presente che queste scappatoie sono vietate per impostazione predefinita. Questo è code-golf , quindi prova a completare l'attività nel minor numero di byte che puoi gestire nella tua lingua preferita.

Casi test

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

Accetta l'input come stringa. Restituisce una stringa con un avanzamento riga finale.

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

Provalo online!

Come?

Metodo

Costruiamo il carattere di output per carattere camminando attraverso una matrice quadrata e convertendo ogni cella in un indice nella stringa di input.$i_{x,y}$

Coordinate all'indice di stringa

Il limite superiore del n t h zona cifre (0-indicizzato) lungo ciascun asse è dato da A000096 :$u_{n}$$n^{th}$

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

Dato un numero intero , possiamo scoprire in quale area n = ⌊ x ⌋ + 1 si trova risolvendo:$k$$n=\lfloor{x}\rfloor+1$

Portando a:

n=⌊

Per ogni cella , definiamo:$(x, y)$

Questi valori vengono convertiti in indici i x , y nella stringa di input effettuando:$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

Condizioni di arresto

Sappiamo di aver raggiunto:

• il limite destro della matrice quando il carattere in non esiste e abbiamo x > $i_{x,y}$$x > y$

• il limite inferiore della matrice quando il carattere non esiste e abbiamo $x \le y$

J , 16 15 byte

-1 byte grazie a FrownyFrog!

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

Provalo online!

Prende Ncome una stringa.

Spiegazione della soluzione iniziale:

              #\   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

Sessione di test con input 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 byte

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

Provalo online!

Versione senza punti (68 byte)

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

Provalo online!

Python 2 , 71 byte

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

Provalo online!

In primo luogo genera la prima riga r, quindi scorre ripetutamente rper stampare ogni riga.

R , 59 byte

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

Provalo online!

• Ho notato che prendere un vettore di cifre è accettabile e questo mi ha permesso di salvare 21 byte :)
• -2 byte grazie al suggerimento di @Giuseppe di accettare solo caratteri vettoriali
• -2 byte che assegnano nella definizione degli argomenti

Gelatina , 7 byte

Jx`»þ`ị

Provalo online!

Uscita chiarita.

05AB1E , 14 11 10 byte

Salvato 1 byte grazie a Magic Octopus Urn / Adnan

ƶJDv¬N×?=¦

Provalo online!

Spiegazione

ƶ            # 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

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

Sto separando questa soluzione dal post con la mia risposta J, come suggerito da Jo King

Provalo online!

Python 2 , 74 byte

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

Provalo online!

Excel VBA, 95 byte

Una funzione di finestra immediata VBE anonima che porta input [A1]e output alla console

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

Ungolf e commentato

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 byte

tftY"t!2$X>)

Provalo online!

Sospetto che questo possa essere abbreviato, ma non è poi così male ...

          % 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

Aggiungi ++ , 35 byte

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

Provalo online!

Come funziona

Prendiamo l'input come un elenco di cifre, mentre ci impedisce di a) dover eseguire il cast con le cifre BDe anche di dover salvare le cifre, il che richiederebbe due byte.

Innanzitutto, generiamo un intervallo da [1 ... len (input)] con bLR, quindi ripetiamo ogni elemento$n$ nell'intervallo $n$volte. Poiché la vettorializzazione automatica non esiste in Add ++, la comprimiamo con se stessa dBcB]per creare un elenco di coppie$[[1, 1], [2, 2] ... [n, n]]$. Quindi applichiamo lo starmap , unito alla ripetizione sulle coppie: £Xprima di concatenarle in un array piatto ( ¦Ω+).

Successivamente, abbiamo duplicare questo array e tavolo facendo il massimo, d‽b>. Vale a dire che ogni elemento dell'array è accoppiato con l'altro elemento del secondo array e il comando diadico massimo viene eseguito sulla coppia. Per un input di esempio di [6 5] , questo crea l'array [1 2 2 2 2 2 2 2 2] , che è una versione appiattita del mosaico, come gli indici dell'array. Purtroppo, Aggiungi ++ utilizza array 0-indicizzati, quindi abbiamo bisogno di diminuire ogni elemento: 1€Ω_.

Quindi, ci indicizziamo nell'elenco di input, premendo di nuovo l'input ( A), che salva nuovamente i byte prendendo l'input come un elenco. Indicizzare nell'elenco con €Ω:prima di tagliare l'array nei pezzi opportunamente allungati. Se il numero di cifre nell'input è indicato da$x$, quindi la dimensione del pezzo è

o il $x^{th}$ numero triangolare . Generiamo ciò spingendo la lunghezza dell'input, calcolando l'intervallo da 1 a quel valore, quindi prendendo la somma con AbLR¦+. Ora, lo stack, per un input di [6 5] , sembra [[6 5 5 5 5 5 5 5 5] 3] . Ttaglia l'array in pezzi di dimensioni$n$, ma gli argomenti sono attualmente nell'ordine sbagliato, quindi li scambiamo con $prima di tagliare e tornare con T.

Carbone , 17 byte

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

Provalo online! Spiegazione:

Ｆ⮌…Ｌθ

Scorri gli indici dei personaggi in ordine inverso.

⊕⊘×ι⁺³ι

Calcola la dimensione del quadrato.

ＵＯ...§θι

Disegna il quadrato usando il carattere corrente.

Tela , 12 byte

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

Provalo qui!

Python 2 , 76 73 byte

-3 byte grazie a 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

Provalo online!

Carbone , 14 byte

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

Provalo online!

Come?

Ｅ⭆θ×⊕κι×⊕κι‖Ｏ↗ - 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

... questo metodo può essere giocato a golf?

Stax , 12 byte

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

Esegui ed esegui il debug

Utilizzando questo algoritmo .

Spiegazione:

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 byte

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

Esegui ed esegui il debug

Spiegazione:

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 byte

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

Provalo online!

Spiegazione

Funziona in modo simile alla risposta J di Galen Ivanov .

{_[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 byte

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

Provalo online!

C (gcc) , 130 byte

Chi ha bisogno di matematica elaborata quando puoi avere la forza bruta?

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);}

Provalo online!

QBasic 1.1 , 127 byte

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 grazie a DLosc .

Utilizza una versione modificata dell'algoritmo Python 2 di xnor .

L'input è una stringa non quotata. L'output è \nseparato senza spazi o \ns aggiuntivi .

QBasic , 111 byte

Una funzione anonima che richiede input e output alla console.

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 byte

Tramite CLI fornendo il numero come argomento:

<?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";

Non così golfato:

$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";

Produzione:

122333
222333
222333
333333
333333
333333

Metodo:

Fondamentalmente crea quadrati di array multidimensionali costituiti dalla cifra, quindi sovrapponili tutti (array_replace_recursive).

(Sì, lo so che è imbarazzantemente lungo.)

Rubino , 80 byte

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

Provalo online!

Simile alla risposta ovs

Japt, 12 byte

Accetta input come stringa, genera una matrice di stringhe.

Ë+pE
¬£h°YçX

Provalo

Spiegazione

            :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

Una funzione anonima che accetta l'input foprm STDIN e l'output su STDOUT

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

Provalo online!

Visual Basic .NET (VBC) , 198 byte

Una Subroutine che prende input da STDIN e li invia a STDOUT.

Non sembra riuscire a far funzionare StrDup: /

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

Provalo online!

Lua, 149 140 byte

Funzione che accetta un elenco di stringhe di cifre e stampa il risultato su stdout. Questo è il mio primo tentativo di code golf (e la scelta della lingua non aiuta neanche) quindi abbiate pazienza :)

Provalo 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 byte

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

Provalo online!

Yabasic , 108 byte

Una funzione anonima che accetta input da STDIN e li invia a STDOUT

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

Provalo online!