Einfache Komplexität

17

Ausgabe

                  # # # # # ##### ## #         
                  ## #### ####### # # ##        
                #### ## ## # ### #######        
                # # # # ##### ### # #        
                # # ### ##### ##### # # #        
                ####### ### # ### # ## ####        
                ## # # ### # ####### ##          
                 # ## ##### ##### # # #          
                ## # # # # #####  
                 # ## ## ######## #  
                 ####### #### ## # ###
                ### # # # # # ##### 
                    # # # # ### ##### #     
                    #### ####### ### # ##    
                    ## ## # # #######    
                     # # ## ##### # #    
    # # ##### ## # #                     
    ####### # # ## ##                    
    ## # ### ####### ####                    
     # ##### ### # # # #                    
 ##### # # # # # ###                
### # ## #### ########                 
  # ####### ## ## #                 
  ##### # # # # ##                
          # # # ##### ##### ## #                 
          ## ####### # ### # # ##                
        #### ## # ### # ### #######                
        # # # ##### ##### ### # #                
        # # ### ##### # # # #                
        ####### ### # ## ## ####                
        ## # # ####### #### ##                  
         # ## ##### # # # # #                  
                                          #                     
                                          ##                    
                                        ####                    
                                        # #                    
                                        # # ###                
                                        #######                 
                                        ## #                 
                                         # ##                
                                 ##### ## #                 
                                ### # # ##                
                                  # ### ########                
                                  ##### ### # #                
                                  # # #                
                                  ## ####                
                                #### ##                  
                                # # #                  
                                  # # # # # #####  
                                  ## #### ####### #  
                                #### ## ## # ###
                                # # # # ##### 
                                # # ### ##### ##### #     
                                ####### ### # ### # ##    
                                ## # # ### # ########    
                                 # ## ##### ##### # #    
                                ## # #     
                                 # ## ##    
                                 ####### ####    
                                ### # # # #    
                                    # # # # ###
                                    #### ####### 
                                    ## ## # 
                                     # # ##

Leerzeichen erlaubt. Kürzeste Lösung gewinnt.

hint0

Hinweis 1:

hint1

danke @Tahg für die Korrektur von hint1

code-golf  ascii-art  kolmogorov-complexity 
— ngn
quelle
8
@ngn gibt nur Fragen aus, bei denen es keine Erklärung dafür gibt, wie die Daten gebildet wurden (siehe codegolf.stackexchange.com/q/126037 ), da die erste Antwort dazu neigt, den "mysteriösen" Teil in die Luft zu jagen
— Uriel
16
Persönlich mag ich solche Herausforderungen nicht, bei denen das Herausfinden der Regel / des Rezepts Teil der Aufgabe ist. Außerdem können alle anderen, die es einmal gefunden haben, es einfach verfolgen. Warum also nicht zuerst posten?
— Luis Mendo
11
@ LuisMendo Es ist ein interessantes Argument. Beim Code-Golf in seiner reinsten Form geht es darum, "eine bekannte Lösung in Kürze umzusetzen". Bei Rätseln in ihrer reinsten Form geht es darum, eine Lösung zu finden - die Implementierung ist entweder nicht relevant oder wird als vielbeschäftigt angesehen. Eine Möglichkeit wäre, den "Trick" bei Spoilern zu posten. Auf diese Weise könnten die reinen Code-Golfer das Problem als Golfherausforderung angreifen, und diejenigen, die sowohl die Golf- als auch die Puzzleherausforderung mögen, vermeiden, beide zu suchen und zu lösen.
— Jonah
5
Ich denke, der "mysteriöse" Teil ist etwas, von dem ich definitiv mehr sehen konnte. Obwohl eine Antwort den Trick dazu finden könnte, ist der Rest immer noch eine reguläre Code-Golf-Herausforderung ... Und es ist eine gute Herausforderung für diejenigen, die sowieso das Muster am Anfang finden wollen.
— Totalhuman
3
@ H.PWiz, ich bin mir nicht sicher, ob + 26 / -7 wirklich "gut aufgenommen" wird. Es sieht eher so aus, als ob es "schlecht ankommt, es aber geschafft hat, den HNQ schnell genug zu treffen, um eine verzerrte Punktzahl zu erzielen".
— Peter Taylor

Antworten:

11

SOGL V0.12 , 17 16 14 Bytes

 #6{³IIč▓┼;I+§

Probieren Sie es hier aus!

Bei einem späteren Update č▓könnte für 12 Byte - das konvertiert ToS aus einem Array von Arrays von Zeichen eine mehrzeilige Zeichenfolge in ein Array von Zeichenfolgen - entfernt werden [["#","#"],[" ","#"]] -> ["##"," #"]-, weil ┼- horizontales Anhängen - Arrays von Arrays von Zeichen - was nicht gut funktioniert Ierstellt, weil es auch für die Array-Rotation verwendet wird. In SOGL sollte ein Array von Zeichenarrays = Array von Zeichenfolgen sein, aber viele Dinge unterstützen das noch nicht.

Erläuterung:

 #            push "#"
  6{          6 times do
    ³           create 3 total copies of ToS
     II         rotate clockwise twice
       č▓       normalize as explained above
         ┼      append horizontally
          ;     get the 3rd copy ontop
           I    rotate clockwise
            +   append vertically
             §  reverse horizontally
— dzaima
quelle
1
Warten Sie, was wie funktioniert das?
— Conor O'Brien
@ ConorO'Brien hat gerade eine Erklärung hinzugefügt: p
— dzaima
oh schön `` `` `
— Conor O'Brien
22

JavaScript (ES6), 233 217 213 198 182 170 163 122 Bytes

f=_=>[...Array(64)].map((_,x,a)=>a.map(g=(i=(n=64,x),j)=>(n>>=1)?i&n?j&n?g(j,i):` `:j&n?g(i,~j):g(~i,j):`#`).join``).join`
`
document.write(`<pre>${f()}</pre>`)
Erweitern Sie das Snippet

Bearbeiten: Gespeichert 14 18 Bytes dank @Shaggy gespeichert. 3 Bytes dank @ngn gespeichert. Dank der Zusammenarbeit der beiden wurden weitere 12 Bytes eingespart. 41 Bytes wurden gespart, indem @ user202729s Beobachtungen gestohlen wurden, dass die Viertel eher Reflexionen als Rotationen verwenden. Ungolfed:

function f() {
    var s = '';
    for (var i = 0; i < 64; i++) {
        for (var j = 0; j < 64; j++) {
            var x = i, y = j, c = '#'; // Default to #
            // Each non-blank quadrant maps to to the original
            // image by doubling and a reflection. Repeat
            // this six times unless we hit the blank quadrant.
            for (var n = 0; n < 6; n++) {
                if (x >= 32) {
                    if (y >= 32) {
                        // Bottom right quarter is a diagonal reflection
                        var t = x - 32;
                        x = y - 32;
                        y = t;
                    } else {
                        // Bottom left quarter is blank
                        c = ' ';
                        break;
                    }
                } else {
                    if (y >= 32) {
                       // Top right corner is a horizontal reflection
                       y = 63 - y;
                    } else {
                       // Top left corner is a vertical reflection
                       x = 31 - x;
                    }
                }
                x *= 2;
                y *= 2;
            }
            s += c;
        }
        s += '\n';
    }
    return s;
}
— Neil
quelle
Müssen Sie das f=hier zählen? Übrigens gut gemacht.
— Shaggy
— Shaggy
1
Sie müssen nicht f=in Byte zählen, aber Code-Snippet funktioniert nicht ohne.
1
@Neil Könntest du vielleicht eine Erklärung oder eine ungolfed Version hinzufügen?
— Jonah
1
@Jonah Ich hoffe du findest das hilfreich.
— Neil
11

LOGO, 375 341 297 295 278 + 3 Bytes

Durch das Hinzufügen von 3 Bytes aufgrund des -pFlags, das den Perspektivmodus standardmäßig aktiviert und daher keinen perspectiveBefehl ausführen muss , werden insgesamt 9 Bytes eingespart.

Verwenden von FMSLogo unter Windows mit dem Newline-Format von Unix (LF) (FMSLogo hat Probleme beim Parsen des CR-Newline-Formats)

to R
rt 90
end
to g :w :l
R fd 2*:l R bk :l up 180
run :w
R run :w
fd 2*:l R bk :l run :w
fd 2*:l up 180
end
to h
pu
ask -1[setxyz 0 0 870]g[g[g[g[g[g[rt 45 fd .7 pd fd 0 pu bk .7 lt 45]1]2]4]8]16]32
repeat 64[sety 64-# repeat 64[setx #-1 type if pixel=[0 0 0]""#["\ ]](pr)]
end

Leider kein "online ausprobieren!" Link, da ich keinen Perspektivmodus für die Unterstützung von Online-Dolmetschern finde.

Idee: Zeichnen Sie ein Bild des Bildes, rufen Sie dann die Pixel des Bildes ab und drucken Sie es als Ausgabe.

Bildaufteilung auf einfache Wiederholteile:

.

Nutzen Sie den obigen Hinweis. Da LOGO jedoch keine Reflexion unterstützt, können wir dies nur simulieren, indem Sie in den 3D ( perspective) -Modus wechseln und die Schildkröte um 180 Grad um eine Achse parallel zum Computerbildschirm drehen.

Dies definiert eine Hilfsfunktion g, die bei 2 Parametern l(Bildseitenlänge) und w(Verfahren zum Zeichnen des Bildes) 3 Kopien des reflektierten Bildes zeichnet. (siehe Hinweis in der Frage) Die Prozedur hführt die Hauptprozedur durch.

— user202729
quelle
Sie können wahrscheinlich einige Leerzeichen wie 90 fd-> weglassen 90fdund ein paar Bytes sparen.
— Jonathan Frech
@JonathanFrech Leider unterstützt FMSLogo das nicht.
— user202729
Warum funktioniert Papert Unterstützung es dann?
— Jonathan Frech
2
Ist dies die einzige Antwort, die das Muster tatsächlich ausnutzt und nicht das Bit-Packing?
— Jonah
2
@Jonah Die JS-Lösung nutzte das Muster zunächst auf interessante Weise - mit modularen Arithmetik- und Bitoperationen, anstatt Matrizen zu verketten. Interessant und einzigartig ist auch diese LOGO-Lösung mit dem Pixel-Leseansatz. Ich kenne nicht genug LOGO, um den Code zu verstehen, aber nach der Beschreibung zu urteilen, werden bestimmte Muster wiederholt, ohne die fraktale Struktur vollständig zu durchlaufen (was ich bereits in hint1 verraten habe).
— 21.
8

Python 2 , 205 195 ... 145 144 142 144 Bytes

g=lambda n,i,j,*_:g(n/2,*[~i,j,i,~j][2*(j&n>0)-(i&n>0):])if n*(i&n<=j&n)else'# '[i&n>0]
r=range(64)
for j in r:print''.join(g(32,j,i)for i in r)

Probieren Sie es online!

Inspiriert von Neils JS-Antwort .

— TFeld
quelle
n>>1ist n/=2.
— Jonathan Frech
awird definiert und dann einmal verwendet. Durch Ersetzen der Referenz durch ihren Wert könnten vier Bytes eingespart werden.
— Jonathan Frech
Ich habe eine nützliche Vereinfachung übersehen - anstatt alles mit Rotationen zu machen, hätte ich stattdessen Reflexionen verwenden sollen. Es hat mir 41 Bytes bei meiner Antwort gespart!
— Neil
Ich denke, Sie können zwei Bytes sparen, indem Sie Ihre [...[x],...[x]][z]Auswahl vereinfachen .
— Jonathan Frech
1
@totallyhuman Fair genug
— TFeld
7

Haskell, 126 125 113 106 103 Bytes

e=[]:e
z=zipWith
r=reverse
m s=z(++)(r s++map(' '<$)s)$map r s++foldr(z(:))e s
unlines$m$m$m$m$m$m["#"]

Eine direkte Implementierung von hint1 im Spoiler.

Funktion mgeneriert die nächste Iteration. Die Hauptfunktionen gelten m6 mal. Details zu m:

m s=                          -- s is the current pattern
     zipWith(++)              -- concatenate pairwise the lines of
                (r s)++       --    the lines of s in reverse order, followed by
                map(' '<$)s   --    each char in s replaced by a space
                              -- and
                map r s++     --    each line of s reversed, followed by
                foldr ... s   --    the transposition of s


e=[]:e;foldr(zipWith(:))e     -- this right fold transposes a matrix

Edit: @ngn speicherte ein Byte und @Laikoni ein weiteres 3. Danke!

— nimi
quelle
n$n$n$n$n$n["#"]ist kürzer als iterate n["#"]!!6:)
— ngn
@ngn: gut gesehen. Danke vielmals!
— nimi
Sie können e=[]:e;foldr(zipWith(:))estatt verwenden import Data.List;transposeund dann kürzen zipWith.
— Laikoni
6

Java 7, 259 238 237 200 Bytes

void f(){char[][]o={{35}},n;for(int s=1,x,y;s<64;s*=2,o=n)for(n=new char[64][64],x=s;x-->0;)for(y=0;y<s;n[s+y++][x]=32)n[s+~y][x]=n[y][2*s+~x]=n[s+x][s+y]=o[y][x];for(char[]b:o)System.out.println(b);}

2 Bytes durch Entfernen von {} in der x-Schleife gespart, danke ngn
19 Bytes bei verschiedenen Zuweisungsänderungen
gespart , danke Jonathan 24 Bytes für Druck und Rückgabe gespart (wusste nicht, dass dies zulässig war) und
13 Bytes für Schleifenänderungen gespart, danke Nevay

Probieren Sie es online!

Meine erste Herausforderung, und ich halte Java für seriös. Verwendet Tipp 1 (was übrigens falsch ist, aber ich kann keine Kommentare schreiben). Es kann wohl weiter golfen werden, dieser Pass war im Grunde so wie er ist, ohne hübschen Aufdruck.

— Tahg
quelle
Ich bin nicht sicher, ob dies an einem Versionsunterschied liegt, aber ich habe Ihren Code unter TIO mit Java 8 getestet und er gibt Nullzeichen anstelle von Leerzeichen aus.
— Jonathan Frech
Vielen Dank, dass Sie es bemerkt haben. Anscheinend ist Java ziemlich zufrieden damit, Nullen als Leerzeichen in seinen Strings anzuzeigen.
— Tahg
Sie können durch das Entfernen eines Byte speichern s=1aus Ihrer for - Schleife und Ersetzen int s,t,x,y;mit int s=1,t,x,y;.
— Jonathan Frech
1
n[s-1-y][x]=o[y][x];n[y][t-1-x]=o[y][x];-> n[s-1-y][x]=n[y][t-1-x]=o[y][x];.
— Jonathan Frech
2
Die richtige Transformationsmatrix ist [[V, H], [_, T]] (Entweder das oder es gibt einen subtilen Unterschied in Ihrem Algorithmus, aber das habe ich gebraucht)
— Tahg
3

Python 2, 586 Bytes

import zlib,base64 as b
print zlib.decompress(b.b64decode('eJyVVlsOwzAI++8pJuX+d1zXDGLAUKi0pUp52ATcfj7+Wni3dF2/677ZO1dw+z/Zd3+rJU4SdkVHMcYQS9OuJVGio4N61p31+TGoQkco6eqoU6gSWdBJRrQhjhIdvLQ6YhNrqrEtUsu8yEbjmRqUWXlgYbl5EHfLC7cDQl4sxxAhO4wUv7fFPTx22sUWqOeEJ544Z3vn9FPU+ZmdHtCak6Fk3hfCx0FkOC8DF4YvmgoFMnCEwW2cDBkzftoiGy4GZaNhM8VYSl3YMEV7ctxsjLQKRCHZ3IB6+ATZpKSKmEyGrqZvEHY8lEQBWf8zbuAg0eypWG6nRqTLIzM+NPQa2faN89FlxhMY2vcTKDP7579fl0rmIpJ+grTvSyis798ghb4vM0CuVgbM1SFdvukjnFnfR1Gt3vAEngd6lGrIDdfkDU/ARwl+ecMHf5SzIzct8KhsqHANZ0FqFbpXdad5qH2DzOHJIHGM2pz26oug9i2+EBpX+cXQCpBA7/tne01lLb4wviHjtJE='))

Probieren Sie es online aus.

Python 2, 1032 1025 Bytes

Ich mag dieses noch. Aber es ist viel länger. Man könnte Golf spielen, aber das ist nicht nötig. Der Ansatz von officialaimm ist viel kürzer.

-7 Danke an Jonathan Frech

print''.join(' '*int(x)if'/'<x<'@'else("#"*(ord(x)-64),"\n")[x<"#"]for x in'99A9A2A4A2A1E2B4A9!99B8D4G2A3A4B8!88D8B6B4A2C1G8!88A2A9A7A4E1C1A2A8!88A2A1C1E3E4A9A2A8!88G1C2A2C2A4B8D8!88B4A3A2C2A2G8B55!98A4B2E3E1A2A9A55!88B4A559A9A2A1E2!98A4B99B8G2A2!98G88D8B4A2C!88C1A2A88A2A9A4E1!992A2A88A2A1C1E4A5!992D88G1C2A4B4!992B99B4A3A2G4!777A559A4B2E1A2A4!4A2A1E2B4A559A777!4G2A3A4B99B992!4B4A2C1G88D992!5A4E1C1A2A88A2A569!1E4A9A2A88A2A1C88!C2A4B8D88G98!2A2G8B99B4A89!2E1A2A9A559A4B88!55A9A2A1E3E2B4A98!55B8G2A2C2A3A4B88!8D8B4A2C2A2C1G88!8A2A9A4E3E1C1A2A88!8A2A1C1E4A7A9A2A88!8G1C2A4B6B8D88!8B4A3A2G4D8B99!9A4B2E1A2A4A2A9A99!99996A777!99996B992!99994D299!99994A2A992!99994A2A1C88!99994G98!99994B4A98!99995A4B88!9996E2B4A89!9995C2A3A4B88!9997A2C1G88!9997E1C1A2A88!9997A9A2A88!9997B8D88!9995D8B99!9995A2A9A99!9997A9A2A4A2A1E2!9997B8D4G2A2!9995D8B6B4A2C!9995A2A9A7A4E1!9995A2A1C1E3E4A5!9995G1C2A2C2A4B4!9995B4A3A2C2A2G4!9996A4B2E3E1A2A4!9995B4A559A5!9996A4B99B4!9996G88D4!9995C1A2A88A2A4!9999A2A88A2A1C!9999D88G1!9999B99B4A1!99991A559A4B')

Probieren Sie es online aus.

— Simon
quelle
Die Frage erlaubt [t]railing spaces, obwohl Ihre Lösung einige Leerzeichen weglässt.
— Jonathan Frech
Nachgestellte Leerzeichen zuzulassen bedeutet, dass ich sie nicht ausgeben muss. Ist das korrekt? Bei meinem zweiten Ansatz würden Bytes gespart. Beim ersten ist dies bereits geschehen, da ich beim Speichern meiner Datei die nachgestellten Leerzeichen gelöscht habe ...
— Simon,
Ich weiß es nicht genau, aber ich habe es so interpretiert, dass es zusätzliche Leerzeichen zulässt und fehlende Leerzeichen nicht zulässt.
— Jonathan Frech
x=='!'->x<'#'
— Jonathan Frech
if x.isdigit()->if"/"<x<"@"
— Jonathan Frech
3

Mathematica, 112 90 Bytes

Vielen Dank an Jonathan Frech für die Hilfe beim Speichern von 2 Bytes!

""<>Nest[{{(r=Reverse)@#,r/@#},{" "+0#,#}}~Flatten~{{1,3},{2,4}}&,{{"#"}},6]~Riffle~"
"

Probieren Sie es online!(Mathematik)

Aus bestimmten Gründen druckt Mathics beim Drucken von mehrzeiligen Zeichenfolgen führende Leerzeichen in allen Zeilen mit Ausnahme der ersten. Auch Mathics unterstützt keine Operator .

Erläuterung:

  • {{Reverse@#,Reverse/@#},{" "+0#,#}}: Stellen Sie die Optionen horizontal umkehren, vertikal umkehren, alles durch Ersetzen " "und Transponieren dar ( ist in Mathematica der Transponierungsoperator), die verschiedenen Möglichkeiten zum Reflektieren oder Drehen des Bildes entsprechen.
  • ~Flatten~{{1,3},{2,4}} : In bestimmten Dimensionen abflachen.
  • Nest[ ... ,{{"#"}},6]: Wenden Sie die Funktion innerhalb von {{"#"}}6 mal an.
  • ~Riffle~"<literal newline character>" : Riffle ein Newline-Zeichen zwischen den Zeilen.
  • ""<> : Füge alle Saiten zusammen.
— user202729
quelle
Sie können Ersetzen Reversedurch Rdefinieren und definieren R=Reverse;, um zwei Bytes zu sparen.
— Jonathan Frech
2

C # (.NET Core) , 1016 1002 980 955 Bytes

Dank Kevin Cruijssen 14 Byte gespeichert!
47 Bytes gespart dank Jonathan Frech!

o=>{foreach(var l in new[]{35223185965568,52841249260288,0xf00c0c277f00,0x9004043ee900,0x977c7c200900,0xfee4e4300f00,0xc22727f00c00,73934616658944,0xc2000020097c,73667282210788,0x7f0000f00c27,0xe9000090043e,9895614577696,0xf0000fee430,0xc0000c227f0,4398050918032,325982355457<<21,1092065689603<<20,835235872783<<20,291765223433<<20,0x7c20090000970000,-15289957744513<<17,21955973480545<<17,68788263321667<<16,68799053409<<17,206425089091<<16,0xf00c27277f0000,618546478825<<16,650622541833<<16,0xfee430300f0000,208473439235<<18,72203117569<<18,1<<21,3<<20,15<<20,9<<20,9895936,127<<17,97<<17,67<<16,15969<<17,3829596160,662634496,16105<<16,8201<<16,806289408,4027318272,9217L<<18,537463164,806293476,4027321383,2416182334,2541517856,4276413488,3257346032,1128152720,3254779936,1124073520,2130706672,3909091472,150995095,251658494,201326786,67108931})System.Console.WriteLine(System.Convert.ToString(l,2).PadLeft(64,'0').Replace('0',' ').Replace('1','#'));}

Probieren Sie es online!

Erläuterung

Das Format der Ausgabe wird in einem Array von 64-Bit-Zahlen mit Vorzeichen gespeichert, das perfekt passt, da jede Zeile 64 Zeichen lang ist. Leerzeichen werden durch dargestellt 0und #durch dargestellt 1.

Die Zahlen werden dann in ihre Binärzeichenfolge konvertiert, Nullen werden nach links aufgefüllt, bis die Zeichenfolge 64 Zeichen breit ist, und dann werden die Zeichen 0und 1durch  und ersetzt# .

Der Code wird in einer Lamba-Funktion gespeichert, genauer gesagt in a System.Func<string> .

Einige Konstanten in der long[]werden durch Bitverschiebung gekürzt.

— Ian H.
quelle
Ist nicht unnötig Platz drin long[] n=new[]?
— Jonathan Frech
@ JonathanFrech Ah du hast recht, anscheinend hat es sich da irgendwie eingeschlichen.
— Ian H.
1
Sie würden 4 Bytes einsparen, indem Sie das Füllzeichen nicht angeben müssen.
— Neil
1
Wenn das Trailing lnicht benötigt wird, können Sie wahrscheinlich noch mehr Bytes einsparen .
— Jonathan Frech
1
Sieht so aus, als ob der Grund dafür abgehört ist.
— Shaggy
2

Holzkohle , 42 Bytes

#↓##ＦＥ⁵Ｘ²ι«‖↑Ｊ⁻×³ι¹±⁰ψ⟲ＯＯ⁴ײι⟲ＣＪ⁰±φＴ×⁴ι×⁴ι

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Wäre 25 Bytes, wenn dies funktioniert:

#ＦＥ⁷Ｘ²ι«‖↑⟲Ｃ→⁴⟲ＣＪ⁰±φＴιι

Erläuterung:

#↓##

Generieren Sie die erste Rekursion manuell, da eine Drehung um (1, 0,5) nicht möglich ist. (Eine solche Drehung wäre nur bei 180 ° sinnvoll.)

ＦＥ⁵Ｘ²ι«

Überfliege die ersten fünf Potenzen von 2 (1, 2, 4, 8, 16).

‖↑

Spiegeln Sie die Leinwand vertikal. Dies vervollständigt das obere linke Viertel des Ergebnisses.

Ｊ⁻×³ι¹±⁰ψ⟲ＯＯ⁴ײι

Drehen Sie die Leinwand um 180 ° um einen Punkt auf halber Höhe der rechten Seite. Die Kopie landet in der richtigen Position für das obere rechte Viertel des Ergebnisses.

⟲Ｃ

Drehen Sie die Leinwand um 90 ° um die rechte untere Ecke. Die Kopie der oberen rechten Ecke landet in der richtigen Position für die untere rechte Ecke des Ergebnisses. Die Kopie der linken oberen Ecke ist irrelevant.

Ｊ⁰±φＴ×⁴ι×⁴ι

Schneiden Sie die Leinwand auf die gewünschte Größe. Der Zuschnitt beginnt am Cursor oder oben links auf der Leinwand, je nachdem, was ganz unten rechts ist. Der Cursor wird daher an (0, -1000) gesendet, um sicherzustellen, dass die Trimmung nicht beeinträchtigt wird.

— Neil
quelle
1

Perl 5 , 452 Bytes

451 Byte Code + 1 für -p.

Pack werden alle Daten in den String, anstatt zu stehlen @ Neil ‚s richtige Antwort .

$_=unpack"B*","\x00\x00\x20\x09\x09\x7c\xc2\x33\x00\x30\x0f\x0f\xe4\x43\x33\x00\xf0\x0c\x0c\x27\x7f\x33\x00\x90\x04\x04\x3e\xe9\x33\x00\x97\x7c\x7c\x20\x09\x33\x00\xfe\xe4\xe4\x30\x0f\x33\x00\xc2\x27\x27\xf0\x0c\x33\x00\x43\x3e\x3e\x90\x04\x33\x00\xc2\x00\x00\x20\x09\x7c\x00\x00\x43\x00\x00\x30\x0f\xe4\x00\x00\x7f\x00\x00\xf0\x0c\x27\x00\x00\xe9\x00\x00\x90\x04\x3e\x00\x00\x09\x00\x00\x97\x7c\x20\x00\x00\x0f\x00\x00\xfe\xe4\x30\x00\x00\x0c\x00\x00\xc2\x27\xf0\x00\x00\x04\x00\x00\x43\x3e\x90\x09\x7c\xc2\x00\x00\x20\x00\x00\x0f\xe4\x43\x00\x00\x30\x00\x00\x0c\x27\x7f\x00\x00\xf0\x00\x00\x04\x3e\xe9\x00\x00\x90\x00\x00\x7c\x20\x09\x00\x00\x97\x00\x00\xe4\x30\x0f\x00\x00\xfe\x00\x00\x27\xf0\x0c\x00\x00\xc2\x00\x00\x3e\x90\x04\x00\x00\x43\x33\x00\x20\x09\x7c\x7c\xc2\x33\x00\x30\x0f\xe4\xe4\x43\x33\x00\xf0\x0c\x27\x27\x7f\x33\x00\x90\x04\x3e\x3e\xe9\x33\x00\x97\x7c\x20\x20\x09\x33\x00\xfe\xe4\x30\x30\x0f\x33\x00\xc2\x27\xf0\xf0\x0c\x33\x00\x43\x3e\x90\x90\x04\x37\x00\x20\x37\x00\x30\x37\x00\xf0\x37\x00\x90\x37\x00\x97\x37\x00\xfe\x37\x00\xc2\x37\x00\x43\x36\x00\x7c\xc2\x36\x00\xe4\x43\x36\x00\x27\x7f\x36\x00\x3e\xe9\x36\x00\x20\x09\x36\x00\x30\x0f\x36\x00\xf0\x0c\x36\x00\x90\x04\x36\x00\x20\x09\x09\x7c\x34\x00\x30\x0f\x0f\xe4\x34\x00\xf0\x0c\x0c\x27\x34\x00\x90\x04\x04\x3e\x34\x00\x97\x7c\x7c\x20\x34\x00\xfe\xe4\xe4\x30\x34\x00\xc2\x27\x27\xf0\x34\x00\x43\x3e\x3e\x90\x34\x00\xc2\x00\x00\x20\x34\x00\x43\x00\x00\x30\x34\x00\x7f\x00\x00\xf0\x34\x00\xe9\x00\x00\x90\x34\x00\x09\x00\x00\x97\x34\x00\x0f\x00\x00\xfe\x34\x00\x0c\x00\x00\xc2\x34\x00\x04\x00\x00\x43"=~s/[3-9](.)/$1x$&/ger;y/01/ #/;s/.{64}/$&
/g

Reversible Ausgabe von xxdfür 451-Byte-Datei:

00000000: 245f 3d75 6e70 6163 6b22 422a 222c 2200  $_=unpack"B*",".
00000010: 0020 0909 7cc2 3300 300f 0fe4 4333 00f0  . ..|.3.0...C3..
00000020: 0c0c 277f 3300 9004 043e e933 0097 7c7c  ..'.3....>.3..||
00000030: 2009 3300 fee4 e430 0f33 00c2 2727 f00c   .3....0.3..''..
00000040: 3300 433e 3e90 0433 00c2 0000 2009 7c00  3.C>>..3.... .|.
00000050: 0043 0000 300f e400 007f 0000 f00c 2700  .C..0.........'.
00000060: 00e9 0000 9004 3e00 0009 0000 977c 2000  ......>......| .
00000070: 000f 0000 fee4 3000 000c 0000 c227 f000  ......0......'..
00000080: 0004 0000 433e 9009 7cc2 0000 2000 000f  ....C>..|... ...
00000090: e443 0000 3000 000c 277f 0000 f000 0004  .C..0...'.......
000000a0: 3ee9 0000 9000 007c 2009 0000 9700 00e4  >......| .......
000000b0: 300f 0000 fe00 0027 f00c 0000 c200 003e  0......'.......>
000000c0: 9004 0000 4333 0020 097c 7cc2 3300 300f  ....C3. .||.3.0.
000000d0: e4e4 4333 00f0 0c27 277f 3300 9004 3e3e  ..C3...''.3...>>
000000e0: e933 0097 7c20 2009 3300 fee4 3030 0f33  .3..|  .3...00.3
000000f0: 00c2 27f0 f00c 3300 433e 9090 0437 0020  ..'...3.C>...7. 
00000100: 3700 3037 00f0 3700 9037 0097 3700 fe37  7.07..7..7..7..7
00000110: 00c2 3700 4336 007c c236 00e4 4336 0027  ..7.C6.|.6..C6.'
00000120: 7f36 003e e936 0020 0936 0030 0f36 00f0  .6.>.6. .6.0.6..
00000130: 0c36 0090 0436 0020 0909 7c34 0030 0f0f  .6...6. ..|4.0..
00000140: e434 00f0 0c0c 2734 0090 0404 3e34 0097  .4....'4....>4..
00000150: 7c7c 2034 00fe e4e4 3034 00c2 2727 f034  || 4....04..''.4
00000160: 0043 3e3e 9034 00c2 0000 2034 0043 0000  .C>>.4.... 4.C..
00000170: 3034 007f 0000 f034 00e9 0000 9034 0009  04.....4.....4..
00000180: 0000 9734 000f 0000 fe34 000c 0000 c234  ...4.....4.....4
00000190: 0004 0000 4322 3d7e 732f 5b33 2d39 5d28  ....C"=~s/[3-9](
000001a0: 2e29 2f24 3178 2426 2f67 6572 3b79 2f30  .)/$1x$&/ger;y/0
000001b0: 312f 2023 2f3b 732f 2e7b 3634 7d2f 2426  1/ #/;s/.{64}/$&
000001c0: 0a2f 67                                  ./g

Probieren Sie es online!

— Dom Hastings
quelle
1

Jq 1,5 , 538, 535, 488, 476 Bytes

Dies ist eine einfache Darstellung. Ich habe noch keine ausgefallenen Codierungen versucht. Ersetzt 0,0 Paare mit Z-Funktion.

Nochmals vielen Dank an Jonathan Frech, der dabei geholfen hat, 3 Bytes zu eliminieren!

def B:recurse(if.>0then./2|floor else empty end)|.%2;def S:256+.|[B]|reverse[2:]|map(if.>0then"#"else" "end)|join("");def Z:0,0;[[Z,3,1,1,4,5,2],[1,4,5,2,2,3,Z],[Z,Z,2,3,Z],[Z,Z,3,1,1,4]]as$m|[[],[9,15,12,4,124,228,39,62],[Z,Z,Z,Z,124,228,39,62,32,48,240,144],[32,48,240,144,151,254,194,67,194,67,127,233,9,15,12,4],[124,228,39,62,32,48,240,144,32,48,240,144,151,254,194,67],[194,67,127,233,9,15,12,4,9,15,12,4,124,228,39,62]]as$c|$m[]|range(16)as$l|map($c[.][$l]|S)|join("")

Zeichenanzahl

$ wc -c picture.jq
 476 picture.jq

Probelauf

$ jq -Mnr -f picture.jq
                  #         #  #    #  # #####  ##    #         
                  ##        ####    #######  #   #    ##        
                ####        ##      ##    #  ### #######        
                #  #         #       #    ##### ### #  #        
                #  # ### #####   #####    #         #  #        
                ####### ###  #  ###  #    ##        ####        
                ##    #   #  ###  #  #######        ##          
                 #    ##  #####   ##### #  #         #          
                ##    #                   #         #  # #####  
                 #    ##                  ##        #######  #  
                 #######                ####        ##    #  ###
                ### #  #                #  #         #    ##### 
                    #  #                #  # ### #####    #     
                    ####                ####### ###  #    ##    
                    ##                  ##    #   #  #######    
                     #                   #    ##  ##### #  #    
    #  # #####  ##    #                   #                     
    #######  #   #    ##                  ##                    
    ##    #  ### #######                ####                    
     #    ##### ### #  #                #  #                    
 #####    #         #  #                #  # ###                
###  #    ##        ####                #######                 
  #  #######        ##                  ##    #                 
  ##### #  #         #                   #    ##                
          #         #  # #####   #####  ##    #                 
          ##        #######  #  ###  #   #    ##                
        ####        ##    #  ###  #  ### #######                
        #  #         #    #####   ##### ### #  #                
        #  # ### #####    #       #         #  #                
        ####### ###  #    ##      ##        ####                
        ##    #   #  #######    ####        ##                  
         #    ##  ##### #  #    #  #         #                  
                                          #                     
                                          ##                    
                                        ####                    
                                        #  #                    
                                        #  # ###                
                                        #######                 
                                        ##    #                 
                                         #    ##                
                                 #####  ##    #                 
                                ###  #   #    ##                
                                  #  ### #######                
                                  ##### ### #  #                
                                  #         #  #                
                                  ##        ####                
                                ####        ##                  
                                #  #         #                  
                                  #         #  #    #  # #####  
                                  ##        ####    #######  #  
                                ####        ##      ##    #  ###
                                #  #         #       #    ##### 
                                #  # ### #####   #####    #     
                                ####### ###  #  ###  #    ##    
                                ##    #   #  ###  #  #######    
                                 #    ##  #####   ##### #  #    
                                ##    #                   #     
                                 #    ##                  ##    
                                 #######                ####    
                                ### #  #                #  #    
                                    #  #                #  # ###
                                    ####                ####### 
                                    ##                  ##    # 
                                     #                   #    ##
— jq170727
quelle
1
Drei weglassbare Leerzeichen in B: recund 16) as $l|.
— Jonathan Frech
1
if.==0then" "else"#"end-> if.>0then"#"else" "end.
— Jonathan Frech
0

JavaScript (Node.js) , 1233 Byte

_=>` 18# 9# 2# 4# 2# #5 2#2 4#
 18#2 8#4 4#7 2# 3# 4#2
 16#4 8#2 6#2 4# 2#3 #7
 16# 2# 9# 7# 4#5 #3 # 2#
 16# 2# #3 #5 3#5 4# 9# 2#
 16#7 #3 2# 2#3 2# 4#2 8#4
 16#2 4# 3# 2#3 2# 2#7 8#2
 17# 4#2 2#5 3#5 # 2# 9#
 16#2 4# 19# 9# 2# #5
 17# 4#2 18#2 8#7 2#
 17#7 16#4 8#2 4# 2#3
 16#3 # 2# 16# 2# 9# 4#5
 20# 2# 16# 2# #3 #5 4#
 20#4 16#7 #3 2# 4#2
 20#2 18#2 4# 3# 2#7
 21# 19# 4#2 2#5 # 2#
 4# 2# #5 2#2 4# 19#
 4#7 2# 3# 4#2 18#2
 4#2 4# 2#3 #7 16#4
 5# 4#5 #3 # 2# 16# 2#
 #5 4# 9# 2# 16# 2# #3
#3 2# 4#2 8#4 16#7
 2# 2#7 8#2 18#2 4#
 2#5 # 2# 9# 19# 4#2
 10# 9# 2# #5 3#5 2#2 4#
 10#2 8#7 2# 2#3 2# 3# 4#2
 8#4 8#2 4# 2#3 2# 2#3 #7
 8# 2# 9# 4#5 3#5 #3 # 2#
 8# 2# #3 #5 4# 7# 9# 2#
 8#7 #3 2# 4#2 6#2 8#4
 8#2 4# 3# 2#7 4#4 8#2
 9# 4#2 2#5 # 2# 4# 2# 9#
 42#
 42#2
 40#4
 40# 2#
 40# 2# #3
 40#7
 40#2 4#
 41# 4#2
 33#5 2#2 4#
 32#3 2# 3# 4#2
 34# 2#3 #7
 34#5 #3 # 2#
 34# 9# 2#
 34#2 8#4
 32#4 8#2
 32# 2# 9#
 34# 9# 2# 4# 2# #5
 34#2 8#4 4#7 2#
 32#4 8#2 6#2 4# 2#3
 32# 2# 9# 7# 4#5
 32# 2# #3 #5 3#5 4#
 32#7 #3 2# 2#3 2# 4#2
 32#2 4# 3# 2#3 2# 2#7
 33# 4#2 2#5 3#5 # 2#
 32#2 4# 19#
 33# 4#2 18#2
 33#7 16#4
 32#3 # 2# 16# 2#
 36# 2# 16# 2# #3
 36#4 16#7
 36#2 18#2 4#
 37# 19# 4#2`.replace(/(.)(\d+)/g,(_,c,n)=>c.repeat(n))

Probieren Sie es online!

— total menschlich
quelle
Oh, was ist das Problem jetzt? Ähm ... Vermisse ich etwas?
— Totalhuman
1
Ich habe nicht abgelehnt, aber es kann viel mehr mit diesem komprimiert werden .
Ich habe es auch nicht getan, aber das ist nicht im Sinne der Frage. Das Muster wurde vermutlich durch eine einfache rekursive Prozedur erzeugt. Die Herausforderung besteht darin, die Regel zu bestimmen, an welcher Stelle Ihre Lösung äußerst kurz sein wird.
— Jonah
1
Konvertieren Sie in Basis 36, um ~ 50 Bytes zu sparen.
— Shaggy
2
Mir ist völlig bewusst, dass dies nicht die optimale oder die kürzeste oder eine clevere Lösung ist. Ich habe einfach versucht, einen Algorithmus zu verwenden, und es endete so. Dies ist jedoch eine vollkommen gültige Lösung und verdient daher keine Ablehnung. Langweilige Lösungen sollten nicht heraufgestuft, aber auch nicht herabgestuft werden.
— Totalhuman
0

C # (.NET Core) , 976 969 Byte

o=>{foreach(var l in new[]{35223185965568,52841249260288,0xf00c0c277f00,0x9004043ee900,0x977c7c200900,0xfee4e4300f00,0xc22727f00c00,73934616658944,0xc2000020097c,73667282210788,0x7f0000f00c27,0xe9000090043e,9895614577696,0xf0000fee430,0xc0000c227f0,4398050918032,0x97cc20000200000,0xfe44300003<<20,0xc277f0000f<<20,0x43ee900009<<20,0x7c20090000970000,-0x1bcff0ffff020000,0x27f00c0000c20000,0x3e90040000430000,9017629528424448,0x300fe4e4430000,0xf00c27277f0000,0x90043e3ee90000,0x977c2020090000,0xfee430300f0000,0xc227f0f00c0000,0x433e9090040000,2097152,3145728,15728640,9437184,9895936,16646144,12713984,4390912,2093088768,3829596160,662634496,1055457280,537460736,806289408,4027318272,2416181248,537463164,806293476,4027321383,2416182334,2541517856,4276413488,3257346032,1128152720,3254779936,1124073520,2130706672,3909091472,150995095,251658494,201326786,67108931})System.Console.WriteLine(System.Convert.ToString(l,2).PadLeft(64).Replace('0',' ').Replace('1','#'));}

Probieren Sie es online!

— Mein Pronomen ist monicareinstate
quelle
Hallo, willkommen bei PPCG! Dies sieht fast genauso aus wie die C # .NET-Antwort von @IanH . Wenn Sie also Verbesserungen für seine Antwort haben, machen Sie einen Kommentar, anstatt eine neue Antwort zu erstellen, die fast identisch ist. Mit Ihrer Frage können Sie <s>969</s>die vorherigen Bytes streichen.
— Kevin Cruijssen
4
Ich habe nicht den Ruf, einen Kommentar abzugeben.
— Mein Pronomen ist monicareinstate
Bitte versuchen Sie nicht, die Rep-Anforderungen zu umgehen.
— Shaggy
2
Bedeutet dies, dass ich bei PPCG nicht versuchen kann, anderen zu helfen, wenn mein Ruf zu niedrig ist?
— Mein Pronomen ist monicareinstate
3
@Shaggy um fair zu sein, Stackexchange ist ein bisschen hart für Neulinge. Machen wir es ihnen nicht schwerer, indem
— wir
0

C # (.NET Core) , 739 Byte

_=>{var r="";for(int i=0,j,k=0;i<626;i++)for(j=0;j++<@"4#+#$#&#$##'$$&#=$*&&)$#%#&$:&*$($&#$%#):#$#+#)#&'#%##$#:#$##%#'%'&#+#$#:)#%$#$%$#&$*&:$&#%#$%$#$)*$=#&$$'%'##$#+#<$&#5#+#$##'5#&$4$*)$#5)2&*$&#$%2%##$#2#$#+#&'7#$#2#$##%#'&#;&2)#%$#&$:$4$&#%#$);#5#&$$'##$#*#$##'$$&#5#;)$#%#&$4$:$&#$%#)2&;#&'#%##$#2#$#7'&#+#$#2#$##%2%$#&$*&2)5#$)*$4$&#5'##$#+#5#&$<#+#$##'%'$$&#=$*)$#$%$#%#&$:&*$&#$%$#$%#):#$#+#&'%'#%##$#:#$##%#'&#)#+#$#:)#%$#&$($*&:$&#%#$)&&*$=#&$$'##$#&#$#+#^#a$^&^#$#^#$##%Z)[$&#\#&$S'$$&#S%$#%#&$T#$%#)T'#%##$#T#+#$#T$*&R&*$T#$#+#V#+#$#&#$##'F$*&&)$#D&*$($&#$%B#$#+#)#&'C#$##%#'%'&#G)#%$#$%$#&$F$&#%#$%$#$)G#&$$'%'##$#F$&#5#H#&$4$G)2&F%##$#2#$#J#$#2#$##%F&2)G$4$&#H#5#&$"[i]-34;){r+=i%2<1?' ':'#';if(++k%64<1)r+='\n';}return r;}

Probieren Sie es online!

Verwendet den gleichen Ansatz ist diese andere Antwort .

— Charlie
quelle
0

K (ngn / k) , 32 31 27 Bytes

6{,[|x;""x],'(+|+x),+x}/"#"

Probieren Sie es online!

6{ }/ 6 mal machen

+x transponieren

|x vertikal umkehren

+|+x horizontal umkehren

, vertikal verketten

,' horizontal verketten

,[A;B]ist das gleiche wie A,B. Es hilft dabei, Klammern zu vermeidenA und um den gesamten Ausdruck

""xVerwenden Sie die Elemente von xals Indizes in der leeren Zeichenfolge. Out-of-Bound-Indizierung erzeugt Leerzeichen, sodass dieser Ausdruck eine Matrix mit allen Leerzeichen zurückgibt, die dieselbe Größe wie hatx

— ngn
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.