Objectif

L'objectif du programme est de dessiner un rectangle d'art ASCII doublé de taille à plusieurs reprises, alternant horizontalement et verticalement. Chaque fois que le rectangle double de taille, la zone supplémentaire est représentée par un caractère différent et les zones précédentes restent inchangées. Les deux plus petites sections contiennent chacune un caractère et peuvent se trouver dans n'importe quel coin.

Le programme accepte un seul entier en entrée, définissant le nombre de sections que contient le rectangle complet.

Aucune autre ressource ou entrée externe n'est autorisée.

Exemple d'entrée et de sortie

10

ABDDFFFFHHHHHHHHJJJJJJJJJJJJJJJJ
CCDDFFFFHHHHHHHHJJJJJJJJJJJJJJJJ
EEEEFFFFHHHHHHHHJJJJJJJJJJJJJJJJ
EEEEFFFFHHHHHHHHJJJJJJJJJJJJJJJJ
GGGGGGGGHHHHHHHHJJJJJJJJJJJJJJJJ
GGGGGGGGHHHHHHHHJJJJJJJJJJJJJJJJ
GGGGGGGGHHHHHHHHJJJJJJJJJJJJJJJJ
GGGGGGGGHHHHHHHHJJJJJJJJJJJJJJJJ
IIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJ
IIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJ
IIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJ
IIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJ
IIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJ
IIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJ
IIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJ
IIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJ

Les critères de sélection

Le code le plus court en une semaine remporte les points.

code-golf ascii-art Hand-E-Food
la source

Quelle devrait être la sortie pour les non-puissances de 4?

marinus

La sortie doit-elle être de la séquence A, B, C, etc.?

Kendall Frey

2

@marinus Quelle est la particularité des pouvoirs de 4? Peut-être avez-vous mal compris l'exemple?

Kendall Frey

@KendallFrey, non, il doit juste y avoir n caractères imprimables uniques.

Hand-E-Food

Doit-il se reproduire exactement dans le coin supérieur gauche

mniip

10

APL, 25 caractères / octets *

{⍉⍣⍵⊃{a,⍺⍴⍨⍴a←⍉⍪⍵}/⌽⍵↑⎕A}

Vue éclatée

{                   ⍵↑⎕A}   ⍝ take the first ⍵ letters
    ⊃{           }/⌽        ⍝ fold over them, using the first one as initial accum. value
            a←⍉⍪⍵           ⍝    ensure the accum. is a table, transpose it and call it 'a'
        ⍺⍴⍨⍴                ⍝    make a table as large as 'a' filled with the next letter
      a,                    ⍝    append it to the right of 'a' and loop as new accumulator
 ⍉⍣⍵                        ⍝ transpose the result as many times as the original ⍵ number

Exemples

      {⍉⍣⍵⊃{a,⍺⍴⍨⍴a←⍉⍪⍵}/⌽⍵↑⎕A}¨⍳8
A AB  AB  ABDD  ABDD  ABDDFFFF  ABDDFFFF  ABDDFFFFHHHHHHHH
      CC  CCDD  CCDD  CCDDFFFF  CCDDFFFF  CCDDFFFFHHHHHHHH
                EEEE  EEEEFFFF  EEEEFFFF  EEEEFFFFHHHHHHHH
                EEEE  EEEEFFFF  EEEEFFFF  EEEEFFFFHHHHHHHH
                                GGGGGGGG  GGGGGGGGHHHHHHHH
                                GGGGGGGG  GGGGGGGGHHHHHHHH
                                GGGGGGGG  GGGGGGGGHHHHHHHH
                                GGGGGGGG  GGGGGGGGHHHHHHHH

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
^{*: APL peut être écrit dans son propre jeu de caractères à un octet (hérité) qui mappe les symboles APL aux valeurs supérieures de 128 octets. Par conséquent, aux fins de la notation, un programme de N caractères qui utilise uniquement des caractères ASCII et des symboles APL peut être considéré comme long de N octets.}

Tobia
la source

9

GolfScript, 30 caractères

~(,[0`]{{[49+]1$,*+}+%zip}@/n*

Exemple (exécuté en ligne ):

Howard
la source

Cela produit la mauvaise sortie pour les nombres pairs, comme celui de la question ...

Timwi

@Timwi Je viens de le tester et cela fonctionne pour moi. La sortie est transposée mais l'orientation n'a pas été spécifiée dans la question.

Howard

D'accord, je suppose que j'étais trop strict alors :)

Timwi

@Howard Hm, c'est comme ça que je comprends "et les zones précédentes restent inchangées". Il dit que les deux premiers caractères peuvent être dans n'importe quel coin, mais il ne dit pas que l'orientation peut changer.

Martin Ender

7

Python 2.7 - 85 103

Cela utilise la zip(*s)syntaxe pour transposer continuellement la liste. Un grand merci à Daniel pour son astuce qui a rasé 12 personnages! Puis rasé un peu plus en utilisant des chiffres au lieu de lettres.

s=[]
for i in range(input()):x=1<<i/2;s=zip(*s+[chr(65+i)*x]*x)
for i in s:print''.join(i)

En outre, cela utilise 1<<xplutôt que 2**xle décalage binaire a une priorité inférieure (?). Observer:

>>> 1<<(2*3)
64
>>> 1<<2*3
64
>>> 2**2*3
12
>>> 2**(2*3)
64

Et une sortie:

10
01335555777777779999999999999999
22335555777777779999999999999999
44445555777777779999999999999999
44445555777777779999999999999999
66666666777777779999999999999999
66666666777777779999999999999999
66666666777777779999999999999999
66666666777777779999999999999999
88888888888888889999999999999999
88888888888888889999999999999999
88888888888888889999999999999999
88888888888888889999999999999999
88888888888888889999999999999999
88888888888888889999999999999999
88888888888888889999999999999999
88888888888888889999999999999999

la source

1

Agréable. Vous pouvez le raccourcir un peu avec for i in s:print''.join(i).

Daniel Lubarov

5

Rubis, 88

Lit N à partir de l'entrée standard.

s=[?A]
66.upto(64+gets.to_i){|i|x=i.chr*y=s.size;i%2<1?s.map!{|r|r+x}:s+=[x*2]*y}
puts s

Exemple d'utilisation pour N = 8:

echo 8 | rectangular-pseudo-fractal.rb

Production:

ABDDFFFFHHHHHHHH
CCDDFFFFHHHHHHHH
EEEEFFFFHHHHHHHH
EEEEFFFFHHHHHHHH
GGGGGGGGHHHHHHHH
GGGGGGGGHHHHHHHH
GGGGGGGGHHHHHHHH
GGGGGGGGHHHHHHHH

N = 10

echo 10 | rectangular-pseudo-fractal.rb

Production:

ABDDFFFFHHHHHHHHJJJJJJJJJJJJJJJJ
CCDDFFFFHHHHHHHHJJJJJJJJJJJJJJJJ
EEEEFFFFHHHHHHHHJJJJJJJJJJJJJJJJ
EEEEFFFFHHHHHHHHJJJJJJJJJJJJJJJJ
GGGGGGGGHHHHHHHHJJJJJJJJJJJJJJJJ
GGGGGGGGHHHHHHHHJJJJJJJJJJJJJJJJ
GGGGGGGGHHHHHHHHJJJJJJJJJJJJJJJJ
GGGGGGGGHHHHHHHHJJJJJJJJJJJJJJJJ
IIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJ
IIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJ
IIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJ
IIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJ
IIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJ
IIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJ
IIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJ
IIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJ

Paul Prestidge
la source

À quoi ressemble la sortie de ceci?

@LegoStormtroopr a ajouté quelques exemples, mais c'est exactement le même format que la question.

Paul Prestidge

4

J, 57 43

(,`,.@.(=/@$@[)$${&a.@(66+2&^.@#@,)^:)1$'A'

Exemples:

5 (,`,.@.(=/@$@[)$${&a.@(66+2&^.@#@,)^:)1$'A'
ABDDFFFF
CCDDFFFF
EEEEFFFF
EEEEFFFF

7 (,`,.@.(=/@$@[)$${&a.@(66+2&^.@#@,)^:)1$'A'
ABDDFFFFHHHHHHHH
CCDDFFFFHHHHHHHH
EEEEFFFFHHHHHHHH
EEEEFFFFHHHHHHHH
GGGGGGGGHHHHHHHH
GGGGGGGGHHHHHHHH
GGGGGGGGHHHHHHHH
GGGGGGGGHHHHHHHH

Barbermot
la source

C et D s'étendent tous les deux horizontalement. Ils doivent alterner horizontalement et verticalement.

Hand-E-Food

@ Hand-E-Food vous avez raison. Merci d'avoir fait remarquer cela. J'ai fixé le code (et poste).

barbermot

4

MATLAB, 86 caractères

Mon essai le plus court dans MATLAB, soutiré par @flawr (deux fois!):

function M=f(n)
M='';
if n
M=cat(mod(n,2)+1,f(n-1),64+n*ones(2.^fix(n/2-[.5,1])));
end

Exemple de sortie:

>> disp(f(7))
ACEEGGGG
BCEEGGGG
DDEEGGGG
DDEEGGGG
FFFFGGGG
FFFFGGGG
FFFFGGGG
FFFFGGGG

knedlsepp
la source

Cela vous fera économiser quelques octets:function M=f(n) M=''; if n M=cat(mod(n,2)+1,f(n-1),64+n*ones(2.^fix([n-1,n-2]/2))); end

flawr

@flawr: Oh! Évidemment!

knedlsepp

Enregistrez un autre octet en remplaçant l'argument de fixpar fix(n/2-[.5,1])PS: solution vraiment sympa avec cat, ne connaissait pas cette utilisation où vous pouvez choisir la dimension =)

flawr

@flawr: Il me semble que je gaspille beaucoup. ;-)

knedlsepp

Je viens de remarquer que vous êtes nouveau ici, alors bienvenue sur codegolf.SE, c'est agréable d'avoir a.) Quelques accros au matlab, b.) Des germanophones ici (je suppose)!

flawr

3

q [73 caractères]

{"c"$64+{n:x 0;m:x 1;if[2>n;m:(),m];(o;$[n-2*n div 2;,';,][m;(#m;#m 0)#o:n+1])}/[x-1;(1;1)]1}

exemple

10
"ABDDFFFFHHHHHHHHJJJJJJJJJJJJJJJJ"
"CCDDFFFFHHHHHHHHJJJJJJJJJJJJJJJJ"
"EEEEFFFFHHHHHHHHJJJJJJJJJJJJJJJJ"
"EEEEFFFFHHHHHHHHJJJJJJJJJJJJJJJJ"
"GGGGGGGGHHHHHHHHJJJJJJJJJJJJJJJJ"
"GGGGGGGGHHHHHHHHJJJJJJJJJJJJJJJJ"
"GGGGGGGGHHHHHHHHJJJJJJJJJJJJJJJJ"
"GGGGGGGGHHHHHHHHJJJJJJJJJJJJJJJJ"
"IIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJ"
"IIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJ"
"IIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJ"
"IIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJ"
"IIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJ"
"IIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJ"
"IIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJ"
"IIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJ"

3
"AB"
"CC"

6
"ABDDFFFF"
"CCDDFFFF"
"EEEEFFFF"
"EEEEFFFF"

nyi
la source

3

Sclipting , 59 caractères

❶塊갠分감⓶左貶終辦감標가⓺貶⓹開上❶❶貶雙是不⒉갠乘⒉終가①上뀀❷②갠分小是增終❸⓷另要감右⓶갠加⓶終丟字⓶終丟겠終

(Ce programme pourrait être un peu plus court si j'avais des instructions pour le logarithme en base 2, mais je n'en ai pas, donc je le fais manuellement avec une boucle.)

Code annoté

n est l'entrée.

❶ | n n

f = i => (1 << (i/2)) - 1;
塊갠分감⓶左貶終 | n n f

w = f(n);
辦 | n w f

d = 1;
감 | n w f d

s = "";
標 | n w f d M [s]

for (y in [0..f(n-1)])
가⓺貶⓹開上 | w d M [s] y

    if ((y & (y-1)) == 0) d *= 2;
    ❶❶貶雙是不⒉갠乘⒉終 | w d M [s] y

    for (x in [0..w])
    가①上 | w d M [s] y x

        c = 64; // '@'
        뀀 | w d M [s] y x c

        if (x < d/2) c++;
        ❷②갠分小是增終 | w d M [s] y x c

        a = x | y;
        ❸⓷另 | w d M [s] y c a

        while (a > 0) { a >>= 1; c += 2; }
        要감右⓶갠加⓶終丟 | w d M [s] y c

        s += (char) c;
        字⓶ | w d M [s] y
    終丟 | w d M [s]

    s += "\n"
    겠 | w d M [s]
終

Production

Pour n= 6:

ABDDFFFF
CCDDFFFF
EEEEFFFF
EEEEFFFF

Bien sûr, vous pouvez remplacer 뀀( @) par tout autre caractère de base, par exemple avec 글(espace) et n= 7:

!"$$&&&&
##$$&&&&
%%%%&&&&
%%%%&&&&
''''''''
''''''''
''''''''
''''''''

Le nombre le plus élevé qui ne rallonge pas le programme est 믰(= 255), ce qui nous donne ( n= 8 cette fois):

Āāăăąąąąćććććććć
ĂĂăăąąąąćććććććć
ĄĄĄĄąąąąćććććććć
ĄĄĄĄąąąąćććććććć
ĆĆĆĆĆĆĆĆćććććććć
ĆĆĆĆĆĆĆĆćććććććć
ĆĆĆĆĆĆĆĆćććććććć
ĆĆĆĆĆĆĆĆćććććććć

Si nous allongons le caractère du programme 1, par exemple en utilisant 냟및(= \u4DFF) et n= 9, nous obtenons:

一丁七七丅丅丅丅万万万万万万万万
丂丂七七丅丅丅丅万万万万万万万万
丄丄丄丄丅丅丅丅万万万万万万万万
丄丄丄丄丅丅丅丅万万万万万万万万
丆丆丆丆丆丆丆丆万万万万万万万万
丆丆丆丆丆丆丆丆万万万万万万万万
丆丆丆丆丆丆丆丆万万万万万万万万
丆丆丆丆丆丆丆丆万万万万万万万万
丈丈丈丈丈丈丈丈丈丈丈丈丈丈丈丈
丈丈丈丈丈丈丈丈丈丈丈丈丈丈丈丈
丈丈丈丈丈丈丈丈丈丈丈丈丈丈丈丈
丈丈丈丈丈丈丈丈丈丈丈丈丈丈丈丈
丈丈丈丈丈丈丈丈丈丈丈丈丈丈丈丈
丈丈丈丈丈丈丈丈丈丈丈丈丈丈丈丈
丈丈丈丈丈丈丈丈丈丈丈丈丈丈丈丈
丈丈丈丈丈丈丈丈丈丈丈丈丈丈丈丈

Timwi
la source

3

C #, 239 185 182 180 180 octets

C # n'a rien sur les langages les moins verbeux.

using C=System.Console;
class P{
    static void Main(string[]a){
        for(int x,i,n=int.Parse(a[0]);n-->0;C.CursorTop=0)
            for(i=1<<n,x=1<<n/2+n%2;i-->0;)
                C.Write((char)(n+33)+(i%x<1?"\n":""));
    }
}

Sortie, caractères choisis pour la beauté:

!"$$&&&&((((((((****************
##$$&&&&((((((((****************
%%%%&&&&((((((((****************
%%%%&&&&((((((((****************
''''''''((((((((****************
''''''''((((((((****************
''''''''((((((((****************
''''''''((((((((****************
))))))))))))))))****************
))))))))))))))))****************
))))))))))))))))****************
))))))))))))))))****************
))))))))))))))))****************
))))))))))))))))****************
))))))))))))))))****************
))))))))))))))))****************

Hand-E-Food
la source

1

Je ne sais pas comment vous avez compté, mais j'ai compté 184. Vous pouvez enregistrer deux personnages en abandonnant les accolades de la forboucle extérieure , ce qui fait 182.

Bob

Merci @Bob! Je dois avoir mal compté lors de la micro-optimisation.

Hand-E-Food

2

PERL, 122 caractères

$N=<>;$x=$r=1;do{$_=chr$a+++65;$s=$x;$o=$_ x$s;$o.=$_++x$s,$s*=2while$N+65>ord++$_;print"$o\n"x$r;$r=$x;$x*=2}while++$a<$N

avec des espaces ajoutés:

$N=<>;
$x=$r=1;
do{
    $_=chr$a+++65;
    $s=$x;
    $o=$_ x$s;
    $o.=$_++x$s,$s*=2 
        while $N+65>ord++$_;
    print "$o\n"x$r;
    $r=$x;
    $x*=2
} while++$a<$N

Production:

$ echo 8 | perl pseudo-fractal.pl
ABDDFFFFHHHHHHHH
CCDDFFFFHHHHHHHH
EEEEFFFFHHHHHHHH
EEEEFFFFHHHHHHHH
GGGGGGGGHHHHHHHH
GGGGGGGGHHHHHHHH
GGGGGGGGHHHHHHHH
GGGGGGGGHHHHHHHH

Tomas
la source

1

PERL, 94 81 caractères

$N=$_;$_=$:=A;$h=1;++$i%2?s/$/$:x$h/gem:($_.=($/.$:x2x$h)x$h,$h*=2)while++$:,--$N

Il construit la fractale de manière itérative lettre par lettre, en ajoutant de nouvelles lignes et colonnes et lignes et colonnes ... Utilise des opérations de chaîne simples pour ce faire. Notez que j'abuse de la variable standard au lieu de la lettre un pour permettre le sucre de syntaxe (comme omettre des espaces - $:x2etc.)

Avec des espaces et des commentaires ajoutés:

$N=$_;
$_=$:=A;                    # $: is current letter
$h=1;

++$i%2? 
s/$/$:x$h/gem:              # every odd run - add "columns"
($_.=($/.$:x2x$h)x$h,$h*=2) # every even run - add "rows"
while++$:,--$N              # iterate over letters

Quelques sorties:

$ echo 8 | perl -p pseudo-fractal.fill.pl.5a5
ABDDFFFFHHHHHHHH
CCDDFFFFHHHHHHHH
EEEEFFFFHHHHHHHH
EEEEFFFFHHHHHHHH
GGGGGGGGHHHHHHHH
GGGGGGGGHHHHHHHH
GGGGGGGGHHHHHHHH
GGGGGGGGHHHHHHHH

Tomas
la source

1

Sclipting , 45 caractères

가⓶貶上倘감雙⓶壹長⓸講增字⓶復⓷是標⓷各①合終并不⓶梴❸⓶疊合終不뀐標뀐并終終⓶丟各겠終

Cette solution fonctionne complètement différemment de l'autre solution Sclipting. C'est beaucoup plus ennuyeux, mais c'est plus court ...

Annoté

for i in [0..n-1]
가⓶貶上
    if (i != 0)
    倘
        i &= 1
        감雙
        e = list[0].Length
        ⓶壹長
        c = ((char) (c[0] + 1)).Repeat(e)
        ⓸講增字⓶復
        if (i)
        ⓷是
            concatenate c onto every element of list
            標⓷各①合終并
        else
        不
            concatenate c.Repeat(list.Length) onto list
            ⓶梴❸⓶疊合
        終
    else (i.e., i == 0)
    不
        c = "A"
        뀐
        list = ["A"]
        標뀐并
    終
終
concatenate "\n" to every element in list
⓶丟各겠終

Timwi
la source

1

Delphi 348 || 449 avec tiret

Sans retrait

var inp,j,i,x: integer;s:string;L:TStringlist;begin L:=TStringList.Create;readln(s);inp:=StrToIntDef(s,4);if inp<4then inp:=4;s:='';l.Add('AB');for I:=2to inp-1do begin j:=Length(L[0]);if i mod 2=0then for x:=0to L.Count-1do L.Add(s.PadLeft(j,Chr(65+i)))else for x:=0to L.Count-1do L[x]:=L[x]+s.PadLeft(j,Chr(65+i));end;Write(L.GetText);readln;end.

Avec retrait

var
  inp,j,i,x: integer;
  s:string;
  L:TStringlist;
begin
  L:=TStringList.Create;
  readln(s);
  inp:=StrToIntDef(s,4);
  if inp<4then inp:=4;
  s:='';
  l.Add('AB');

  for I:=2to inp-1do
  begin
    j:=Length(L[0]);
    if i mod 2=0then
      for x:=0to L.Count-1do L.Add(s.PadLeft(j,Chr(65+i)))
    else
      for x:=0to L.Count-1do
        L[x]:=L[x]+s.PadLeft(j,Chr(65+i));
  end;
  Write(L.GetText);
  readln;
end.

Teun Pronk
la source

1

CJam, 30 (23) octets

CJam a quelques mois de moins que ce défi, il n'est donc pas éligible à la coche verte.

l~(Sa1${{_,I'!+*+}%z}fI\{z}*N*

Testez-le ici.

L'OP a précisé dans un commentaire que tout ensemble de caractères imprimables uniques est autorisé, donc je prends juste les caractères ASCII imprimables depuis le début (avec un espace dans le coin, à !côté et ainsi de suite).

Si l'orientation peut changer entre les entrées paires et impaires (ce que je ne pense pas, mais c'est ce que fait la soumission GolfScript), je peux le faire en 25 octets:

S]l~({{_,I'!+*+}%z}fIN*

L'idée est vraiment simple: commencez par une grille contenant un espace, puis N-1 fois le transposez et doublez toutes les lignes avec le caractère suivant.

Pour la version longue, à la fin je transpose également à nouveau N-1 fois afin de garantir une orientation cohérente.

Martin Ender
la source

Pseudo-fractale rectangulaire

Objectif

Exemple d'entrée et de sortie

Les critères de sélection

Réponses:

APL, 25 caractères / octets *

GolfScript, 30 caractères

Python 2.7 - 85 103

Rubis, 88

q [73 caractères]

exemple

Sclipting , 59 caractères

Code annoté

Production

C #, 239 185 182 180 180 octets

PERL, 122 caractères

PERL, 94 81 caractères

Sclipting , 45 caractères

Annoté

Delphi 348 || 449 avec tiret

Sans retrait

Avec retrait

CJam, 30 (23) octets