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!

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.

GolfScript (25 Zeichen)

8,{.~10,<1>\' '*.2$-1%n}/

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

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

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

JavaScript, 71

s='1234567887654321',i=10;while(--i)console.log(s=s.split(i).join(' '))

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

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,' ')

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'

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];

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

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

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

PHP, 76

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

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"

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>

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)

Brainfuck: 542 Bytes

-[----->+<]>--.+.+.+.+.+.+.+..-.-.-.-.-.-.-.>++++++++++.[->+++++
<]>-.+.+.+.+.+.+.+[-->+<]>++++..----[->++<]>-.-.-.-.-.-.-.>++++++++++.[->+++++
<]>-.+.+.+.+.+.[-->+<]>+++++....-----[->++<]>.-.-.-.-.-.>++++++++++.[->+++++
<]>-.+.+.+.+.--[--->++<]>--......-----[->++<]>-.-.-.-.-.>++++++++++.[->+++++
<]>-.+.+.+.-[--->++<]>--........++[-->+++<]>+.-.-.-.>++++++++++.[->+++++
<]>-.+.+.[--->++<]>--..........++[-->+++<]>.-.-.>++++++++++.[->+++++
<]>-.+.--[--->++<]>............[-->+++<]>++.-.>++++++++++.[->+++++
<]>-.-[--->++<]>..............[-->+++<]>+.

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]

R: 52

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

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.

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

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

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"    

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

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).

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

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.

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.

CJam, 22 Zeichen

Keine gültige Antwort (da die Sprache nach der Frage entwickelt wurde) und auch nicht die kürzeste, aber hier geht es weiter:

8,{S*_,9-~,:)\_2$W%N}%

Probieren Sie es hier online aus

Lua, 62

s='1234567887654321'for i=8,1,-1 do print(s)s=s:gsub(i,' ')end