Alphanumerische Fliege

14

Gib genau diesen Text aus:

1                i
12              hi
123            ghi
1234          fghi
12345        efghi
123456      defghi
1234567    cdefghi
12345678  bcdefghi
123456789abcdefghi
12345678  bcdefghi
1234567    cdefghi
123456      defghi
12345        efghi
1234          fghi
123            ghi
12              hi
1                i

Eine einzelne nachgestellte Zeile ist zulässig, andere Formatierungsänderungen sind jedoch nicht zulässig.

Regeln und I / O

  • Keine Eingabe
  • Die Ausgabe kann auf jede bequeme Weise erfolgen .
  • Es ist entweder ein vollständiges Programm oder eine Funktion zulässig. Bei einer Funktion können Sie die Ausgabe zurückgeben, anstatt sie zu drucken.
  • Standardlücken sind verboten.
  • Dies ist Codegolf, daher gelten alle üblichen Golfregeln, und der kürzeste Code (in Byte) gewinnt.
code-golf  kolmogorov-complexity 
— AdmBorkBork
quelle
1
Können wir stattdessen das Großbuchstaben verwenden?
— Kritixi Lithos
3
@Cowsquack Das wäre eine Regeländerung. Es heißt genau diesen Text ausgeben .
— Dennis
@Cowsquack Nope - Kleinbuchstaben sind erforderlich.
— AdmBorkBork

Antworten:

13

C 87 85 81 80 Bytes

j;main(i){for(;++i<19;)for(j=19;j--;)putchar(j?j<i^j<20-i?32:106-j-j/10*39:10);}

Probieren Sie es online!

Erläuterung

j; // same as int j;
main(i){ // same as int main(int i){, where i = argc (1 with no arguments)
  for(;++i<19;) // loop over rows, i = 2..18
    for(j=19;j--;) // loop over chars, j = 19..0
      putchar(j?j<i^j<20-i?32:106-j-j/10*39:10); // output characters:
      //      j?                           :10 // on last char (j=0), output \n
      //        j<i                            // check for top/left half
      //            j<20-i                     // check for bottom/left half
      //           ^                           // 1 if only one half matched
      //                  ?32:                 // if so, output space
      //                      106              // char code for j
      //                         -j            // get desired letter
      //                           -j/10*39    // subtract 39 for j>9 (numbers)
}
— PurkkaKoodari
quelle
Ich bin erstaunt, ^hat eine niedrigere Priorität als <... was für eine schöne Antwort!
— Lynn
@Lynn Die bitweisen Operatoren in C (und sogar Java / JS und so weiter) haben alle eine niedrigere Priorität als Vergleiche. Dies ist sowohl für Code-Golf als auch eine wirklich schöne Fehlerquelle (denken Sie if (x & 2 == 0), die immer auswertet 0)
— PurkkaKoodari
3

QBasic, 72 Bytes

Gestützt auf Taylor Scotts Vorlage .

FOR y=-8TO 8
z=ABS(y)
?"123456789abcdefghi";
LOCATE,10-z
?SPC(2*z)"
NEXT

Grundlegende Erklärung

In jeder Zeile wird die gesamte Zeichenfolge gedruckt 123456789abcdefghi. Dann gehen wir zurück und überschreiben einen Teil davon mit Leerzeichen.

Vollständige Erklärung

Mit Code leicht ungolfed:

FOR y = -8 TO 8           ' Loop for 17 rows
 z = ABS(y)               ' z runs from 8 to 0 and back to 8
 ? "123456789abcdefghi";  ' Print the full string and stay on the same line (important!)
 LOCATE , 10-z            ' Go back to column 10-z on that line
 ? SPC(2*z); ""           ' Print 2*z spaces
                          ' (SPC keeps the cursor on the same line unlesss you print
                          ' something after it, so we'll use the empty string)
NEXT                      ' Go to the next y value
— DLosc
quelle
Das ist eine wirklich clevere Verwendung des LocateBefehls
— Taylor Scott
2

T-SQL, 108 Bytes

DECLARE @ INT=8a:
PRINT STUFF('123456789abcdefghi',10-abs(@),2*abs(@),SPACE(2*abs(@)))
SET @-=1IF @>-9GOTO a

Rücksendungen dienen nur der Lesbarkeit.

Versuchte viele andere Variationen, einschließlich der Nummerntabellen, dies war die kürzeste.

— BradC
quelle
2

Japt , 20 Bytes

9Æ9Ç>YÃê1 Ë?S:°EsH
ê

Japt Interpreter

Ausgabe als Array von Arrays von Zeichen. Das -RFlag ist nicht notwendig, um zu funktionieren, es macht die Ausgabe nur schöner.

Erläuterung:

9Æ9Ç                    create a 9x9 2D array 
    >YÃ                 fill bottom left triangle with "false", upper right with "true"
       ê1               mirror horizontally
          Ë?S           replaces "true" with a space
             :°EsH      replaces "false" with the horizontal index + 1 converted to base 32
                  \n    Store the result in U (saves bytes by not closing braces)
                    ê   palindromize vertically
— Kamil Drakari
quelle
1

Stax , 18 Bytes

â4+╤jo♂▐▀3bkWíæß╝╖

Führen Sie es aus und debuggen Sie es

Erläuterung:

9R$|[|<Va17T|]r|>\|pm Full program
9R$                   Produce "123456789"
   |[|<               Left-aligned prefixes (["1        ", "12       ", ...])
       Va17T          Produce "abcdefghi"
            |]        Suffixes (["abcdefghi", "bcdefghi", ...])
              r|>     Reverse and left-align (["        i", "       hi", ...])
                 \    Zip both arrays (["1                i", "12              hi", ...])
                  |p  Palindromize array
                    m Map over array, printing each with a newline
— wastl
quelle
1

APL (Dyalog Unicode) , 30 Byte

(⊢⍪1↓⊖)(↑,\1↓⎕d),⌽↑,\⌽819⌶9↑⎕a

Probieren Sie es online!

↑ in eine Matrix konvertieren (Auto-Pads mit Leerzeichen)

  • ,\ die Präfixe von

  • 1↓ das erste Element fiel aus

  • ⎕d diese Saite '0123456789'

  • Dies ergibt die Zeichenmatrix

1        
12       
123      
1234     
12345    
123456   
1234567  
12345678 
123456789

, verkettet mit

  • ⌽ das Gegenteil

  • ↑ matrixiert

  • ,\ Präfixe von

  • ⌽ das Gegenteil

  • 819⌶ und klein geschrieben

  • 9↑ Die ersten 9 Elemente von

  • ⎕a diese Saite 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

  • Dies ergibt die Zeichenmatrix

        ich
       Hallo
      ghi
     fghi
    efghi
   defghi
  cdefghi
 bcdefghi
abcdefghi

und zu diesem Ergebnis

1 i
12 hi
123 ghi
1234 fghi
12345 efghi
123456 defghi
1234567 cdefghi
12345678 bcdefghi
123456789abcdefghi

Führen Sie den folgenden Zug aus (⊢⍪1↓⊖)

⊢ das richtige argument

⍪ vertikal verkettet mit

1↓ die erste Reihe fiel aus (dies vermeidet das Wiederholen der mittleren Reihe)

⊖ das richtige Argument ist vertikal umgekehrt

Andere Lösungen

33 Bytes

(⊢⍪1↓⊖)(↑,\⍕¨q),⌽↑,\⎕ucs 106-q←⍳9

Probieren Sie es online!

33 Bytes

(⊢⍪1↓⊖)(↑,\⍕¨q),⌽↑,\⌽⎕ucs 96+q←⍳9

Probieren Sie es online!

— Kritixi Lithos
quelle
1

Holzkohle , 22 17 Bytes

Ｇ↗↓←⁹β←Ｇ↖↓⁹⭆χι‖Ｏ↓

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

Ｇ↗↓←⁹β

Zeichnen Sie ein rechtes unteres Dreieck und füllen Sie es mit dem Kleinbuchstaben. (Die Füllung basiert auf dem Kacheln der Ebene mit dem Alphabet und dem anschließenden Kopieren des gezeichneten Bereichs.)

←

Bewegen Sie sich nach links, um das numerische Dreieck zu zeichnen.

Ｇ↖↓⁹⭆χι

Zeichnen Sie ein unteres linkes Dreieck und füllen Sie es mit den Ziffern. (Da das Dreieck links vom Ursprung gezeichnet ist, werden die Ziffern rechtsbündig verwendet, sodass nur die Ziffern 1 bis 9 verwendet werden.)

‖Ｏ↓

Nachdenken, um die untere Hälfte zu vervollständigen.

— Neil
quelle
1

V , 25 , 21 Bytes

¬19¬ai8ñHÄ/á
r ge.YGp

Probieren Sie es online!

Dank nmjcman101 werden 2-4 Bytes gespart!

Hexdump:

00000000: ac31 39ac 6169 38f1 48c4 2fe1 0a72 2067  .19.ai8.H./..r g
00000010: 652e 5947 70                             e.YGp
— DJMcMayhem
quelle
Ich weiß, alles was ich tue, ist Ihre Antworten heute zu verfolgen, aber ich denke, das funktioniert für 23: Probieren Sie es online aus!
— Nmjcman101
@ nmjcman101 Aus irgendeinem Grund kann ich nicht verstehen, wie diese Version funktioniert. Aber ich habe eine noch kürzere gefunden, also danke!
— DJMcMayhem
Es ging zum Ende einer /\d*Suche
— nmjcman101
1

J , 44 Bytes

(m]\u:49+i.9),.(m=.,}.@|.)]\&.(|."1)u:97+i.9

Probieren Sie es online!

Ich habe versucht, numerisch eine Maske von 1 und Null für die Indizierung zu generieren, aber die Kosten für das Entfernen der zusätzlichen Zeile waren hoch und ich habe aufgegeben:

   (9-.~i.18){0<:-/~(,|.)i.9
1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1
1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1
1 1 1 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1
1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1
1 1 1 1 1 1 0 0 0 0 0 0 1 1 1 1 1 1
1 1 1 1 1 1 1 0 0 0 0 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 0 0 0 0 1 1 1 1 1 1 1
1 1 1 1 1 1 0 0 0 0 0 0 1 1 1 1 1 1
1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1
1 1 1 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1
1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1
1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1
1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
— Galen Ivanov
quelle
1

Japt, 24 Bytes

Gibt ein Array von Zeilen zurück

9Æ´AçXÄ
c¡A°îYd#a
Vù y ê

Probier es aus

Erläuterung

9Æ            :Map each X in the range [0,9)
  ´A          :  Prefix decrement A (initially 10)
    ç         :  Repeat
     XÄ       :  X+1
\n            :Assign to variable U
 ¡            :Map each element at index Y in U
  A°          :  Postfix increment A
    î         :  Repeat
      d       :  The character at codepoint
     Y #a     :  Y+97
c             :Concatenate with U
\n            :Assign to variable V
Vù            :Left pad each element in V to the length of the longest element
   y          :Transpose
     ê        :Palindromise

Alternativen

9õÈîZqÃú Ë+EòdEn#i)¬ù9Ãê

Probier es aus

9ÇòdZn#i)cZòÄ)¬Ãú ®éJ´Ãê

Probier es aus

— Zottelig
quelle
Ich frage mich jetzt, ob das horizontale Bauen nicht zu einer kürzeren Lösung geführt hätte! : \
— Shaggy
1

QBasic , 87 Bytes

Eine anonyme Funktion, die keine Ein- und Ausgaben für die Konsole vornimmt.

For y=-8To 8:z=Abs(y):a$="123456789abcdefghi":?Mid$(a$,1,9-z)Spc(2*z)Mid$(a$,10+z):Next

Diese Antwort ist technisch gesehen mehrsprachig und funktioniert in VBA

— Taylor Scott
quelle
1

Befunge-93 , 314 308 Bytes

<p0+3*67p0+4*77p0+3*77p0-7*88p0-6*88"#v#v>"
"i        "11g1-21p56+1g1+56+1p28*1g1+28*1p  ^       >25*
"        1"92g1+82p56+2g1-56+2p28*2g1-28*2p91g00g`#v_^   >
"ihgfedcba "93p26*3g1-26*3p">^"88*7-0p88*7-4pv     >25*
"987654321 "14p26*4g1+26*4p26*4g12g`#v_            ^
                             >:#,_@#:<

Probieren Sie es online!

Golfed 6 Bytes durch Platzieren eines >mit der pAnweisung

— ItsJ0el
quelle
1

PowerShell 5.1, 70 69 64 57 Bytes

Danke Mazzy für -7 Bytes

1..9+8..1|%{-join(1..$_+'  '*(9-$_)+' ihgfedcba'[$_..1])}

Es hat sich herausgestellt, dass das manuelle Zusammenkleben ein Byte spart. Ein einziger Mega-Join spart außerdem 5 weitere. Funktioniert auch, indem Sie eine Reihe von Ints in ein Zeichen [] umwandeln, um das ai zu erhalten. Die Verwendung eines Bereichs über den tatsächlichen Buchstaben ist 5 Byte besser.

— Veskah
quelle
1
versuchen Sie dies: 1..9+8..1|%{-join(1..$_+' '*(9-$_)+' ihgfedcba'[$_..1])}. Hinweis ' '*(9-$_)enthält 2 Leerzeichen
— mazzy
1
@mazzy ooof, ich vermisse diesen Double Space Trick. Ich dachte an verschiedene mathematische Aussagen, aber die offensichtliche Lösung kam mir nie in den Sinn.
— Veskah,
1

C (gcc) ,143 142 127 + 10 = 137 136 + 10 = 146 (Compiler-Flags) Bytes

-1 Byte durch Ersetzen des logischen ODER durch einen bitweisen Operator.

-5 Bytes dank Logern.

+9 Bytes zur Korrektur der Medianlinie, die zweimal ausgegeben wurde.

char*s="123456789abcdefghi";G{for(;j<18;++j)putchar(i>j|j>17-i?s[j]:32);puts("");}f(){int i=0,j=0;for(;i++<8;)G;g(i+1,j);for(;i-->1;)G;}

Compiler-Flag:

-DG=g(i,j)

Dieses Makro faktorisiert die Vorkommen von g(i,j): Funktionsdeklaration und Aufrufen.

Probieren Sie es online!

Anderer Ansatz als Pietu1998's großartige Antwort , direkter (und lesbarer), aber höhere Punktzahl.

Einstiegspunkt ist Funktion f(); Die Funktion g()verarbeitet den Druck jeder aufeinanderfolgenden Zeile.

Könnte durch Umbenennen fin ein vollständiges Programm gemacht werdenmain , aber es würde die Punktzahl noch erhöhen.

Hübsche Version, Makro Gerweitert:

char *s = "123456789abcdefghi";
int g(int i, int j) {
    for(; j < 18; ++j)
        putchar((i > j | j > 17 - i) ? s[j] : 32);
    puts(""); // Break the line -- shorter than putchar(10) or printf("\n")
}
int f() {
    int i = 0, j = 0; // j is constant, declared here to not have to declare and init it inside g()
    for(; i++ < 8;) // Upper half of the tie
        g(i, j);
    g(i + 1, j); // Median line
    for(; i-- > 1;) // Lower half; --i > 0 would also work for the condition
        g(i, j);
}
— joH1
quelle
— Logern
137, aber +10 für die Compiler-Flags
— JoH1
137 ist die Summe aus 127 Byte Code und 10 Byte Compiler-Flags.
— Logern
Ups tut mir leid, mein Schlimmes. Jetzt aktualisieren!
— JoH1
@Logern Ich habe mir die Freiheit genommen, das Makro in umzubenennen G, um dem Funktionsnamen zu entsprechen.
— JoH1
0

VBA, 75 Bytes

Eine anonyme VBE-Direktfensterfunktion, die keine Ein- und Ausgaben an die Konsole annimmt.

For y=-8To 8:z=Abs(y):a="123456789abcdefghi":Mid(a,10-z)=Space(2*z):?a:Next
— Taylor Scott
quelle
0

Jelly , 22 21 Bytes

9R€z⁶Zµạ106Ọ$Ṡ¡€Uṭ)ŒḄ

Probieren Sie es online!

Beruht auf dem (wahrscheinlich) unbeabsichtigten Verhalten, dass, wenn Ṡ(sign) auf ein Zeichen einwirkt, es Pythons ergibt None. Aus diesem Grund Ṡwird mit einem Byte überprüft, ob das Argument eine Ganzzahl ungleich Null ist, da Nonees in Python falsch ist. Wenn dieses Verhalten geändert wird, OƑfunktioniert es auch für ein weiteres Byte.

Funktion, die eine Liste von Zeilen zurückgibt.

— dylnan
quelle
0

Python 2 , 97 bis 94 Bytes

i=o="123456789abcdefghi";c=8
while c:i=i[:c]+' '*(9-c)*2+i[-c:];o=i+'\n'+o+'\n'+i;c-=1
print o

Probieren Sie es online!

Nur als Alternative zur Verwendung gepostet eval()und weil ich es endlich unter 100 habe. Grundsätzlich fängt die mittlere Reihe dann sowohl auf als auch ab gleichzeitig an.

— ElPedro
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.