Drucken Sie einen Bogen mit aufsteigenden / absteigenden Zahlen

28

Ich dachte, ein "Bogen" wäre der beste Weg, um dieses Zahlenmuster zu beschreiben:

1234567887654321
1234567  7654321
123456    654321
12345      54321
1234        4321
123          321
12            21
1              1

Formal definiert besteht jede Zeile aus den Nummern 1 bis 9-n, (n-1)*2Leerzeichen und den Nummern 9-nbis 1 (wobei ndie aktuelle Zeile ist).

Ihre Aufgabe ist es, mit dem kürzestmöglichen Code ein kleines Skript / Programm zu schreiben, das das obige Muster mit den folgenden Einschränkungen druckt:

  1. Sie können möglicherweise nicht das gesamte Muster fest codieren. Sie dürfen höchstens eine einzelne Zeile des Musters fest codieren.
  2. Ihr Programm muss am Ende jeder Zeile eine neue Zeile (eine beliebige Kombination von \noder \r) ausgeben .

Achtung, fertig, los!

code-golf  ascii-art  number  kolmogorov-complexity 
— Nathan Osman
quelle
1
Zusätzlicher kleiner Trick wäre mit der oberen Zeile verfügbar, 123456787654321wie es entspricht 11111111^2 ;-)
— Egor Skriptunoff
3
@EgorSkriptunoff 11111111^2 == 123465787654321 != 1234567887654321( Beachten Sie die wiederholte 8)
— Bob
Dies ist die Umkehrung von Print this diamond
— Peter Taylor
6
Es sieht eher aus wie ein Vorhang .
— Volatilität

Antworten:

22

Python 2, 65 55 53 51

s=12345678
while s:r='%-8d'%s;print r+r[::-1];s/=10

Verkürzt mit einigen von Ugorens Ideen.

— Flüchtigkeit
quelle
Heh, ich wusste, dass es Raum für Verbesserungen gibt: P
— Nathan Osman
2
Sie können viel sparen durch s=s[1:]pro Schleife undwhile s:
— ugoren
9

APL (18) 

k,⌽k←↑↑∘(1↓⎕D)¨⌽⍳8

Erläuterung:

  • 1↓⎕D: Die Ziffernfolge ("0123456789") abzüglich des ersten Elements
  • ↑∘(1↓⎕D)¨⌽⍳8: Wählen Sie die ersten [8..1] Zeichen aus ('12345678', '1234567' ...)
  • ↑: Format als Matrix (Füllen der nicht verwendeten Zeichen mit Leerzeichen)
  • k,⌽k←: Speichern in kund Anzeigen kgefolgt von der vertikalen Spiegelung vonk
— Marinus
quelle
4

Ruby: 61 50 Zeichen

s="87654321";s.chars{|c|puts s.reverse+s;s[c]=" "}

Probelauf:

bash-4.2$ ruby -e 's="87654321";s.chars{|c|puts s.reverse+s;s[c]=" "}'
1234567887654321
1234567  7654321
123456    654321
12345      54321
1234        4321
123          321
12            21
1              1
— Mann bei der Arbeit
quelle
4

Befunge - 3 x 18 = 54

Ich hatte das Gefühl, ich musste etwas mit befunge tun, es ist zu lange her, seit ich es das letzte Mal benutzt habe. Dieses Problem schien der Sprache am ehesten zu entsprechen.

Es ist furchtbar langsam, da in der Druckschleife pro Zeichen etwa 8 Aktionen ausgeführt werden (die Zählweisen unterscheiden sich). 

80v >#v"12345678"<
>5 *^ >,#$:_$:1-:v
^2< 0p0+7\*48\_@#<
— Shiona
quelle
4

JavaScript, 71

s='1234567887654321',i=10;while(--i)console.log(s=s.split(i).join(' '))
— Steveworley
quelle
s="1234567887654321";for(i=10;--i;)console.log(s=s.split(i).join(" "))für 70 Zeichen, @SteveWorley
— WallyWest
3

C 83 Zeichen

main(a,b,n){
    for(a=12345678,n=1e8,b=n-a-1;a;a/=10)
        printf("%-8d%8d\n",a,b),
        b%=n/=10;
}
— ugoren
quelle
3

Python 2, 75 62

Es wird die Antwort von Volatility nicht übertreffen, aber hier ist ein anderer Ansatz, bei dem Pythons veränderbare Zeichenfolgen ( bytearray) verwendet werden:

s=bytearray('1234567887654321')
for i in range(8):s[8-i:8+i]=i*'  ';print s

Bearbeiten

Ich habe eine kürzere Version gefunden, mit str.replace:

s='1234567887654321'
for c in s[8:]:print s;s=s.replace(c,' ')
— Baptiste M.
quelle
3

Perl, 41

Plus- -ESchalter. Gesamtanzahl der Zeichen in der Befehlszeile: 50

benötigt mindestens perl5, version 10.

perl -E'say@!=1..8-$_,$"x(2*$_),reverse@!for-0..7'
— amon
quelle
Ich würde sagen, dass dies 42 ist, da der Standard-Look -Eeine Ein-Byte-Erweiterung des Programms ist.
— Timtech
3

Mathematica 92 85 67 54 51

Methode Nr. 1 : (54 Zeichen) Erstellt ein Array unter Verwendung von Zeile Nr., Spalte Nr. Und Abstand vom linken und rechten Rand.

Grid@Array[If[#2<9,#2,17-#2]/.x_/;x+#>9:>" "&,{8,16}]

Methode 2 : (67 Zeichen) Füllen Sie immer kürzere Bereiche auf.

Print@@@Table[Join[k = PadRight[Range@i, 8, " "], Reverse@k], {i, 8, 1, -1}];

Methode 3 : (85 Zeichen) Füllen Sie selektiv jede Zeile eines Arrays.

Beginnen Sie mit einer Liste von 8 Leerzeichen. Ersetzen Sie die Positionen 1 und 16 durch "1"; Ersetzen Sie "2" an den Positionen 2 und 15 usw.

p = 0; q = 16;
Print @@@Reverse@Rest@NestList[ReplacePart[#, {++p -> p, q-- -> p}]&,Array[" "&,q], 8];

Methode 4 : (86 Zeichen) Leeren Sie selektiv jede Zeile eines Arrays.

p=8;q=9;
Print@@@NestList[ReplacePart[#,{p---> " ",q++-> " "}]&,Join[k=Range@8,Reverse@k],7];

Methode 5 : Verwenden von Zeichenfolgen (92 Zeichen)

p=8;s="12345678";
Print[#,StringReverse@#]&/@NestList[StringReplace[#,ToString@p-- ->  " "]&,s,7];
— DavidC
quelle
Das neue ist schlau! Ich würde wieder +1 geben, wenn ich könnte. :-) Übrigens können Sie die fallen lassen ()und ersetzen #1durch #:Grid@Array[If[#2<9,#2,17-#2]/.x_/;x+#>9:>" "&,{8,16}]
— Mr.Wizard
Danke für die Tipps. Ja, Arraymanchmal lassen sich schöne Tabellen erstellen, ohne dass Iteratoren hinzugefügt werden müssen.
— DavidC
3

PHP, 68

(Inspiriert von HamZas Antwort)

for($n=8;$n;$r[]=$n--)echo str_replace($r," ","1234567887654321\n");

Spielt man die Tatsache ab, dass PHPs str_replace ein Array für die Suche und einen String für das Ersetzen akzeptieren kann, wird jedes Element im Array durch den angegebenen String ersetzt. Nach jeder Iteration wird die aktuelle Nummer zum Suchfeld hinzugefügt und aus der nächsten Schleife entfernt.

Beispiel für den Code in Aktion: http://ideone.com/9wVr0X

— Herr Lama
quelle
hehe nice +1
— HamZa
scheint jedoch nicht die richtige Anzahl von Leerzeichen in die Mitte zu setzen
— Nathan Hayfield
@ Nathanhayfield: Wie so? Die erste Zeile enthält 0 Leerzeichen, die zweite 2, dann 4, 6, 8 usw.
— Mr. Llama
nicht, wenn ich es auf writecodeonline.com/php lief
— Nathan Hayfield
Das liegt daran, dass die Ausgabe nicht in <pre>Tags eingeschlossen war. Bei der Interpretation als HTML-Text werden die Leerzeichen reduziert und die Zeilenumbrüche ignoriert. Wenn Sie jedoch die Quelle überprüfen, sehen Sie etwas anderes.
— Mr. Llama
3

Marbelous 165

@0
08
>0
LN
--
@0
:LN
}0}0}0}0
..SAPSSD0A
{0
:PS
}0
~~09
..//
<<@0
\\>0
&0//
--@1
@020
&0/\&0
@1
:SA
@0
}0
>0!!
--00@1
@0++//
+O/\@1
+O
:SD
}0@0
\\>0\/
--/\+O
@0..+O

Pseudocode:

MB():
    for x in 8..1:
        LN(x)
LN(x):
    SA(x)
    PS(x)
    SD(x)
    print "\n"
PS(x):
    print " "*(8-x)*2
SA(x):
    for n in 1..x:
        print n
SD(x):
    for n in x..1:
        print n
— Sparr
quelle
2

Python 2.x - 73 65 63 61 Zeichen

c=1;s='87654321'
while c<9:print s[::-1]+s;s=' '*c+s[c:];c+=1
— TerryA
quelle
2

PHP, 76

for($i=9;$i>1;){$r[]=$i--;echo str_replace($r,' ','1234567887654321')."\r";}
— HamZa
quelle
2

K 28

-1_a,'|:'a:8$'{-1_x}\,/$1+!8

.

k)-1_a,'|:'a:8$'{-1_x}\,/$1+!8
"1234567887654321"
"1234567  7654321"
"123456    654321"
"12345      54321"
"1234        4321"
"123          321"
"12            21"
"1              1"

Sie könnten es für 36 verallgemeinern: {-1_a,'|:'a:(#*m)$'m:{-1_x}\,/$1+!x}

k){-1_a,'|:'a:(#*m)$'m:{-1_x}\,/$1+!x} 5
"1234554321"
"1234  4321"
"123    321"
"12      21"
"1        1"
q)k){-1_a,'|:'a:(#*m)$'m:{-1_x}\,/$1+!x} 15
"123456789101112131415514131211101987654321"
"12345678910111213141  14131211101987654321"
"1234567891011121314    4131211101987654321"
"123456789101112131      131211101987654321"
"12345678910111213        31211101987654321"
"1234567891011121          1211101987654321"
"123456789101112            211101987654321"
"12345678910111              11101987654321"
"1234567891011                1101987654321"
"123456789101                  101987654321"
"12345678910                    01987654321"
"1234567891                      1987654321"
"123456789                        987654321"
"12345678                          87654321"
"1234567                            7654321"
"123456                              654321"
"12345                                54321"
"1234                                  4321"
"123                                    321"
"12                                      21"
"1                                        1"
— tmartin
quelle
2

Javascript, 67 Zeichen

Begeistert von Steveworleys Antwort (Ich würde es kommentieren, wenn ich könnte):

Code-Auszug

a='1234567887654321\n',b='',c=10;while(--c)b+=a=a.split(c).join(' ')
<a href="#" onclick="javascript:document.getElementById('output').innerHTML = b;">Display</a>
<pre id="output">...</pre>
Erweitern Sie das Snippet

Das Vorhandensein der letzten Zeile folgt den Regeln.

Update: Schneiden Sie 2 Zeichen durch Entfernen von Klammern (Operator-Rangfolge) und 1 durch Entfernen eines nicht benötigten Leerzeichens

Es schien, als würde es mich belästigen, denn egal wie viele verschiedene Arten ich versuchte, durch un-hardcoding eines Codesegments zu verkürzen oder zu vereinfachen, die Länge blieb gleich, bis ich die unten aufgeführte Regel "Ich denke, dies zählt" anwenden ließ.

(Wenn das Drucken als das zählt, was zurückkommt, wenn dies in der Chrome-Konsole ausgeführt wird)

— Sophiα2329
quelle
Es sieht nicht wie die andere Antwort aus, die Zahlen sind nicht in der rechten Spalte ausgerichtet.
— AL
@AL Die Warnung ist nicht erforderlich, wenn Sie lesen, welche Ausgabe übrigens aus der Konsole kommt.
— Sophiα2329
Um die rechte Spalte auszurichten, sollte das Zeichenfolgenargument von join 1 Leerzeichen anstelle von 2 enthalten. Mit 2 Leerzeichen ist es korrekt in der Chrome-basierten Browser-Warnung ausgerichtet.
— Qwertiy
Ich habe Ihren Beitrag aktualisiert (die Bearbeitung sollte akzeptiert werden), um das Ergebnis in einem Snippet ohne JS-Warnung anzuzeigen. In diesem Fall wird nur ein Leerzeichen benötigt.
— AL
2

Brainfuck: 542 Bytes

-[----->+<]>--.+.+.+.+.+.+.+..-.-.-.-.-.-.-.>++++++++++.[->+++++
<]>-.+.+.+.+.+.+.+[-->+<]>++++..----[->++<]>-.-.-.-.-.-.-.>++++++++++.[->+++++
<]>-.+.+.+.+.+.[-->+<]>+++++....-----[->++<]>.-.-.-.-.-.>++++++++++.[->+++++
<]>-.+.+.+.+.--[--->++<]>--......-----[->++<]>-.-.-.-.-.>++++++++++.[->+++++
<]>-.+.+.+.-[--->++<]>--........++[-->+++<]>+.-.-.-.>++++++++++.[->+++++
<]>-.+.+.[--->++<]>--..........++[-->+++<]>.-.-.>++++++++++.[->+++++
<]>-.+.--[--->++<]>............[-->+++<]>++.-.>++++++++++.[->+++++
<]>-.-[--->++<]>..............[-->+++<]>+.
— NaCl
quelle
1

Mathematica , 59

61 mit meinen eigenen Ideen:

Grid[Clip[#~Join~Reverse@#&@Range@8,{1,9-#},{," "}]&~Array~8]

Oder 59, entlehnt von Davids Antwort:

Grid@Array[Join[k=PadRight[Range[9-#],8," "],Reverse@k]&,8]
— Mr.Wizard
quelle
Ich habe gerade 4 Zeichen mit Grid gespeichert, inspiriert von Ihrem Eintrag.
— DavidC
1

R: 52

for(i in 8:1)cat(1:i,rep(" ",16-2*i),i:1,"\n",sep="")
— Flodel
quelle
1

Haskell, 84

Ein Ansatzpunkt für jemanden, der sich verbessern möchte:

mapM_ putStrLn[let l=take(8-i)"12345678"++replicate i ' 'in l++reverse l|i<-[0..7]]

Am wahrscheinlichsten wäre es, den l++reverse lPunkt frei zu machen und uns die let-Anweisung loswerden zu lassen, aber ich werde feststellen können, dass war ap, was Importe erfordert.

— Shiona
quelle
1

PostScript: 105 Zeichen

Die Handhabung von Strings ist in PS nicht einfach, kann aber zu relativ einfachem Code führen:

0 1 7{(1234567887654321)dup
8 3 index sub(              )0 6 -1 roll 2 mul getinterval putinterval =}for

Eine etwas längere Version mit 120 Zeichen kann jedoch unterschiedliche Zahlenbögen erzeugen, indem die 8 am Anfang der zweiten Zeile durch eine beliebige Zahl im Bereich von 1 bis 9 ersetzt wird:

/D{dup}def/R{repeat}def/P{=print}def
8 D -1 1{1 1 index{D P 1 add}R pop 2 copy sub{(  )P}R D{D P 1 sub}R pop()=}for pop
— MrMRDubya
quelle
Es ist schön zu sehen, dass ich nicht der einzige bin, der PostScript liebt.
— AJMansfield
1

GoRuby 2.1

36 Zeichen

8.w(1){|x|a=[*1..x].j.lj 8;s a+a.rv}

Ungolfed

8.downto(1) do |x|
  a = [*1..x].join.ljust(8)
  puts a + a.reverse
end
— Patrick Oscity
quelle
1

K 20

{x,'|:'x:|x$,\$1+!x}    

q)k){x,'|:'x:|x$,\$1+!x}8    
"1234567887654321"    
"1234567  7654321"    
"123456    654321"    
"12345      54321"    
"1234        4321"      
"123          321"    
"12            21"    
"1              1"
— ppp
quelle
1

TSQL, 148

Edit: auf 148 mit dem Vorschlag von manatwork und dem Ändern von ORDER BY.

Lesbar:

WITH t AS(
    SELECT 1n, CAST(1 AS VARCHAR(MAX)) o
 UNION ALL
    SELECT n+1,o+CHAR(n+49)
    FROM t
    WHERE n<8
)
SELECT o  + SPACE(16-2*n) + REVERSE(o)
FROM t
ORDER BY 1 DESC

Golf gespielt:

WITH t AS(SELECT 1n,CAST(1AS VARCHAR(MAX))o UNION ALL SELECT 1+n,o+CHAR(n+49)FROM t WHERE n<8)SELECT o+SPACE(16-2*n)+REVERSE(o)FROM t ORDER BY 1DESC

Ausgabe:

1234567887654321
1234567  7654321
123456    654321
12345      54321
1234        4321
123          321
12            21
1              1
— bequemdrei
quelle
1
Schön. Aber können Sie es bitte auch in dem Format posten, in dem Sie 153 Zeichen gezählt haben? Wie auch immer, Sie können 2 Zeichen sparen, indem Sie numerische Zeichen 1anstelle von Zeichenfolgen verwenden, '1'in die Sie sie sofort casteinfügen varchar. Das gibt mir 149 Zeichen: with t as(select 1n,cast(1as varchar(max))o union all select n+1,o+char(n+49)from t where n<8)select o+space(16-2*n)+reverse(o)from t order by o desc.
— Manatwork
@manatwork: Ich konnte die 153-Zahl nicht reproduzieren, weil ich immer niedriger wurde. Habe aber deinen Vorschlag umgesetzt. Vielen Dank!
— comfortablydrei
1

Haskell, 79

r n x|x>n=' '|True=x
t="87654321"
main=mapM(putStrLn.(`map`("12345678"++t)).r)t

Dies funktioniert, indem Zeichen> n durch ersetzt werden ' ', wobei Zeichen n aus "87654321" stammen (was zufällig das Ende der Zeichenfolge ist, an der die Ersetzung durchgeführt werden soll).

— Joey Adams
quelle
1

PHP: 61 Zeichen (oder 60 Zeichen, wenn Sie \ n durch eine echte ASCII-Zeile ersetzen)

(Inspiriert von der Antwort von GigaWatt und HamZa)

for($n=9;$n;$r[$n--]=" ")echo strtr("1234567887654321\n",$r);

http://ideone.com/FV1NXu

— bwoebi
quelle
1

PowerShell: 38

Golf Code

8..1|%{-join(1..$_+"  "*(8-$_)+$_..1)}

Komplettlösung

8..1|%{... }Pipe-Ganzzahlen von 8 bis 1 in eine ForEach-Object-Schleife.
-join(... )fügt die Ausgabe des verschachtelten Codes zu einer einzigen Zeichenfolge ohne Begrenzer zusammen.
1..$_gibt ganze Zahlen aus, die von 1 auf die aktuelle ganze Zahl in der Schleife aufsteigen.
+" "*(8-$_)Fügt der Ausgabe ein Doppel-Leerzeichen hinzu, multipliziert mit der Differenz zwischen 8 und der aktuellen Ganzzahl.
+$_..1Fügt der Ausgabe Ganzzahlen hinzu, die von der aktuellen Ganzzahl auf 1 absteigen.

— Iszi
quelle
1

Javascript mit Lambdas, 147

(s="12345678")[r="replace"](/./g,i=>s[r](RegExp(".{"+(i-1)+"}$"),Array(i*2-1).join(" ")))[r](/\d{1,8} */g,m=>m+(Array(m%10+1).join(m%10+1)-m)+"\n")

Kann in Firefox überprüft werden.

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