Concevons une mosaïque de chiffres

25

Défi

Etant donné un nombre entier positif N , répéter chacun de ses chiffres d1,d2,d3,,dn un nombre de fois correspondant à sa position dans N . En d'autres termes, chaque chiffre dk doit être répété k fois (pour chaque 1kn , indexé 1), créant ainsi le nouveau nombre:

d1d2d2d3d3d3dndndndnn times¯

Ensuite, notez-le horizontalement et verticalement et remplissez les blancs avec des copies du chiffre qui correspond à l'index supérieur entre l'index de colonne et l'index de ligne de l'espace vide. La sortie finale devrait ressembler à ceci:

[d1d2d2d3d3d3d2d2d2d3d3d3d2d2d2d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3]

Spécifications

Vous pouvez prendre comme un entier, une chaîne, une liste de chiffres ou une liste de caractères représentant les chiffres. La sortie peut être une chaîne séparée par des sauts de ligne, une liste de chaînes / entiers ou une liste de listes de caractères / chiffres, mais veuillez également inclure une version assez imprimée, si possible. Si la sortie est une chaîne séparée par des sauts de ligne, il est également possible de:N

  • avoir des espaces blancs de début / fin, tant que l'apparence visuelle de la sortie ne change pas
  • séparez les colonnes en utilisant un nombre cohérent d'espaces ou les lignes avec un nombre cohérent (non nul) de sauts de ligne

Vous pouvez prendre des entrées et fournir des sorties par n'importe quelle méthode standard , tout en prenant note que ces failles sont interdites par défaut. Il s'agit de , essayez donc de terminer la tâche dans le moins d'octets possible dans votre langue de choix.

Cas de 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
M. Xcoder
la source
Avons-nous la poignée deux du même chiffre côte à côte?
Dom Hastings
@DomHastings Oui, vous devez les gérer. Ajout d'un cas de test illustrant cela.
M. Xcoder
Connexes
Magic Octopus Urn

Réponses:

9

JavaScript (ES7), 70 octets

Prend l'entrée sous forme de chaîne. Renvoie une chaîne avec un saut de ligne de fin.

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

Essayez-le en ligne!

Comment?

Méthode

Nous construisons la sortie caractère par caractère en parcourant une matrice carrée et en convertissant chaque cellule en un indice ix,y dans la chaîne d'entrée.

Coordonnées de l'index de chaîne

La limite supérieure de la zone de n t h chiffres (indexée sur 0) le long de chaque axe est donnée par A000096 :unnth

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

un=n(n+3)2
u0=0,u1=2,u2=5,u3=9,u4=14,u5=20,

Etant donné un entier , nous pouvons trouver dans quelle zone n = x+ 1 il est situé en résolvant:kn=x+1

x²+3x2k=0

Menant à:

n=

x=1+8k32
n=1+8k32+1=1+8k12

Pour chaque cellule , nous définissons:(x,y)

vx,y=max(1+8x,1+8y)

Ces valeurs sont converties en indices i x , y dans la chaîne d'entrée en faisant:vx,yix,y

ix,y=vx,y12
 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

Conditions d'arrêt

Nous savons que nous avons atteint:

  • la limite droite de la matrice lorsque le caractère en n'existe pas et que nous avons x > yjeX,yX>y

  • la limite inférieure de la matrice lorsque le caractère n'existe pas et que nous avons Xy

Arnauld
la source
7

J , 16 15 octets

-1 octet grâce à FrownyFrog!

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

Essayez-le en ligne!

Prend Ncomme une chaîne.

Explication de la solution initiale:

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

Session de test avec entrée 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
Galen Ivanov
la source
1
Hah, mis à part le placement de la ), votre réponse APL est la même que celle qui aurait été la mienne.
Erik the Outgolfer
Je ne connais vraiment pas du tout J, mais cela [:<:@semble assez coûteux. Pourriez-vous plutôt ajouter quelque chose à la liste dans laquelle vous indexez pour tenir compte de l'indexation 1 (par exemple, ajouter un 0 pour déplacer chaque position nécessaire de l'élément 1 vers la droite)?
M. Xcoder
@ Mr.Xcoder J'y pensais. Je vais l'essayer pour voir si cela permettrait d'économiser quelques octets.
Galen Ivanov
@EriktheOutgolfer {⍵[∘.⌈⍨(/⍨)⍳⍴⍵]} ?
Galen Ivanov
@GalenIvanov Oui, ça.
Erik the Outgolfer
6

Python 2 , 71 octets

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

Essayez-le en ligne!

Génère d'abord la première ligne r, puis itère rpour imprimer chaque ligne.

xnor
la source
6

R , 59 octets

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

Essayez-le en ligne!

  • J'ai remarqué que prendre un vecteur de chiffres est acceptable, et cela m'a permis d'économiser 21 octets :)
  • -2 octets grâce à la suggestion de @Giuseppe d'accepter uniquement le vecteur de caractères
  • -2 octets affectation dans la définition des arguments
digEmAll
la source
1
Vous pouvez prendre acomme vecteur de caractères, ce qui vous permet de définir g=seq(a)directement.
Giuseppe
@Giuseppe: c'est vrai!
digEmAll
5

05AB1E , 14 11 10 octets

1 octet enregistré grâce à Magic Octopus Urn / Adnan

ƶJDv¬N×?=¦

Essayez-le en ligne!

Explication

ƶ            # 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
Emigna
la source
1
Essayez-le en ligne! = 10
Urne de poulpe magique
1
Aucun crédit pour moi cependant, le crédit est Adnans: codegolf.stackexchange.com/a/87074/59376
Magic Octopus Urn
@MagicOctopusUrn: Ah, c'est génial! Merci à vous deux;)
Emigna
4

APL (Dyalog Classic) , 16 octets

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

Je sépare cette solution du message avec ma réponse J, comme suggéré par Jo King

Essayez-le en ligne!

Galen Ivanov
la source
3

Excel VBA, 95 octets

Une fonction de fenêtre immédiate VBE anonyme qui prend des entrées [A1]et des sorties vers la 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

Non golfé et commenté

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
Taylor Scott
la source
2

MATL , 15 12 octets

tftY"t!2$X>)

Essayez-le en ligne!

Je soupçonne que cela peut être raccourci, mais ce n'est pas si mal ...

          % 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
Giuseppe
la source
2

Ajouter ++ , 35 octets

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

Essayez-le en ligne!

Comment ça marche

Nous prenons la saisie comme une liste de chiffres, tout en nous empêchant de a) devoir transtyper en chiffres avec BD , et aussi d'avoir à enregistrer les chiffres, ce qui prendrait deux octets.

Tout d'abord, nous générons une plage de [1 ... len (entrée)] avec bLR, puis nous répétons chaque élémentn dans le périmètre nfois. Comme la vectorisation automatique n'existe pas dans Add ++, nous la compressons avec elle-même dBcB], pour créer une liste de paires[[1,1],[2,2]...[n,n]]. Nous appliquons ensuite le starmap , couplé à la répétition sur les paires: £Xavant de les concaténer en un tableau plat (¦Ω+ ).

Ensuite, nous dupliquer ce tableau et une table par un maximum, d‽b>. C'est-à-dire que chaque élément du tableau est apparié avec l'autre élément du deuxième tableau et la commande dyadique maximale est exécutée sur la paire. Pour un exemple d'entrée de [6 5] , cela crée le tableau [1 2 2 2 2 2 2 2 2] , qui est une version aplatie de la mosaïque, comme index pour le tableau. Malheureusement, Ajouter ++ utilise des tableaux 0 indexées, donc nous devons décrémenter chaque élément: 1€Ω_.

Ensuite, nous indexons dans la liste d'entrée, en poussant à nouveau l'entrée ( A), qui économise à nouveau des octets en prenant l'entrée comme une liste. Indexez dans la liste avec €Ω:avant de découper le tableau en morceaux de longueur appropriée. Si le nombre de chiffres dans l'entrée est indiqué parX, alors la taille de la pièce est

X(X-1)2

ou la Xth nombre triangulaire . Nous générons cela en poussant la longueur de l'entrée, en calculant la plage de 1 à cette valeur, puis en prenant la somme avec AbLR¦+. Maintenant, la pile, pour une entrée de [6 5] , ressemble à [[6 5 5 5 5 5 5 5 5] 3] . Tcoupe le tableau en morceaux de taillen, mais les arguments sont actuellement dans le mauvais ordre, nous les échangeons donc $avant de couper et de revenir avec T.


la source
1

Fusain , 17 octets

F⮌…LθUO⊕⊘×ι⁺³ι§θι

Essayez-le en ligne! Explication:

F⮌…Lθ

Faites une boucle sur les indices des caractères dans l'ordre inverse.

⊕⊘×ι⁺³ι

Calculez la taille du carré.

UO...§θι

Dessinez le carré en utilisant le caractère actuel.

Neil
la source
1

Fusain , 14 octets

E⭆θ×⊕κι×⊕κι‖O↗

Essayez-le en ligne!

Comment?

E⭆θ×⊕κι×⊕κι‖O↗ - implicitly print the result of...
E                - 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)
             ‖O  - Reflect with overlap:
                ↗ -   direction: up-right

... cette méthode peut-elle être jouée au golf?

Jonathan Allan
la source
"... cette méthode peut-elle être jouée au golf?" Même la solution de Neil est plus longue, donc je ne vois aucun espoir ici. : P
Erik the Outgolfer
×⊕κιdeux fois cependant.
Jonathan Allan
Le problème est qu'il n'est pas facile d'affecter cela à une variable, car les valeurs de ιet κchangent à chaque itération de la boucle Each.
Erik the Outgolfer
Il faut que ce soit une fonction mais je ne sais pas si c'est même possible.
Jonathan Allan
La question à se poser est de savoir si c'est possible en 3 (ou 5, selon la façon dont la fonction est définie) octets ou moins. ;) (La réponse évidente est bien sûr que non.)
Erik the Outgolfer
1

Stax , 12 octets

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

Exécuter et déboguer

En utilisant cet algorithme .

Explication:

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 octets

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

Exécuter et déboguer

Explication:

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
wastl
la source
1

Attaché , 34 octets

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

Essayez-le en ligne!

Explication

Fonctionne de manière similaire à la réponse J de 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
Conor O'Brien
la source
1

C (gcc) , 130 octets

Qui a besoin de maths fantaisistes quand on peut brutaliser?

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

Essayez-le en ligne!

gastropner
la source
1

QBasic 1.1 , 127 octets

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 grâce à DLosc .

Utilise une version modifiée de l'algorithme Python 2 de xnor .

L'entrée est une chaîne sans guillemets. La sortie est \nséparée sans espaces supplémentaires ni \ns.

Erik le Outgolfer
la source
1

QBasic , 111 octets

Une fonction anonyme qui demande des entrées et des sorties à la 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
Taylor Scott
la source
Ça a l'air bien - mais ne voulez-vous pas dire "programme complet"? Je ne pense pas que QBasic ait des "fonctions anonymes".
DLosc
0

Php 7.1 , 163 octets

Via CLI fournissant le numéro comme argument:

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

Pas si golfé:

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

Sortie:

122333
222333
222333
333333
333333
333333

Méthode:

Fondamentalement, créez des carrés de tableau multidimensionnels constitués du chiffre, puis superposez-les tous (array_replace_recursive).

(Oui, je sais que c'est d'une longueur embarrassante.)

Progrock
la source
Si l'entrée est un tableau prédéfini de chiffres et que l'implosion / jointure d'écho est supprimée / remplacée par une affectation à une liste de liste de chiffres, cela peut être réduit à environ 119 octets, yep toujours long.
Progrock
0

Japt, 12 octets

Prend l'entrée sous forme de chaîne, génère un tableau de chaînes.

Ë+pE
¬£h°YçX

Essayez-le


Explication

            :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
Hirsute
la source
0

uBASIC , 120 octets

Une fonction anonyme qui prend les entrées foprm STDIN et les sorties vers 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

Essayez-le en ligne!

Taylor Scott
la source
0

Visual Basic .NET (VBC) , 198 octets

Une Subroutine qui prend les entrées de STDIN et les sorties vers STDOUT.

Impossible de faire fonctionner 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

Essayez-le en ligne!

Taylor Scott
la source
0

Lua, 149 140 octets

Fonction qui accepte une liste de chaînes de chiffres et imprime le résultat sur stdout. Ceci est ma première tentative de code golf (et le choix de la langue n'aide pas non plus), alors restez avec moi :)

Essayez-le en ligne!

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

Non golfé:

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())())
PhilipRoman
la source
0

Yabasic , 108 octets

Une fonction anonyme qui prend les entrées de STDIN et les sorties vers 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

Essayez-le en ligne!

Taylor Scott
la source