Zeichnen Sie Folgendes in möglichst wenigen Bytes:

-------------------------
|       |  ABC  |  DEF  |
|   1   |   2   |   3   |
-------------------------
|  GHI  |  JKL  |  MNO  |
|   4   |   5   |   6   |
-------------------------
| PQRS  |  TUV  | WXYZ  |
|   7   |   8   |   9   |
-------------------------
|       |       |       |
|   *   |   0   |   #   |
-------------------------

pb , 240 Bytes

<[8]^w[Y!14]{w[X!24]{>[8]b[124]^b[124]v}vw[X!-8]{b[45]<}vv}>[12]^[12]b[49]>[12]w[T!8]{<[4]b[T+50]^<w[X%8!6]{b[65+T*3+X%8%3]>}>[10]vw[B!124]{<[24]vvv}t[T+1]}<[4]b[42]>[8]b[48]>[8]b[35]^[4]>w[B!0]{b[B+2]<}b[87]w[X!2]{<[5]w[B!0]{b[B+1]<}}b[80]

(Dieses Programm fordert zur Eingabe in der aktuellen Version von pbi auf, da es auf Y = -1 geht und die BVariable versucht, sich selbst zu aktualisieren. Selbst wenn Sie eine Eingabe eingeben, wird nichts kaputt gehen. Es ist ärgerlich, aber besser als die alte Version das forderte zur Eingabe auf, egal was.)

pb ist eine Sprache, in der das Terminal als 2D-Zeichenfläche behandelt wird. Um auszugeben, müssen Sie den "Pinsel" (einen Punkt, der durch die aktuellen Werte der X- und Y-Variablen dargestellt wird) an die Stelle bewegen, an der das Zeichen abgelegt werden soll, und ihn dort platzieren. Es ist umständlich für Dinge wie das Ausdrucken eines Wortes, aber für Kunst ist es oft bequem.

Dieses Programm zeichnet nicht genau das, was die Frage angibt. (Warte, stimme mich noch nicht ab! Lass es mich erklären!)

Das Zeichnen von Kisten mit Schleifen ist ziemlich einfach, aber es gibt einen Haken. Wenn Sie die folgende Form wiederholen:

--------
|
|

Sie erhalten zwar Kisten, aber die rechte und die untere sind offen. Sie können die zusätzlichen Seiten manuell zeichnen, dies kostet jedoch Bytes. Um dies zu umgehen, zeichnet mein Programm dies tatsächlich mit den offenen Kanten links und oben:

        |       |       |       |
        |       |       |       |
 --------------------------------
        |       |  ABC  |  DEF  |
        |   1   |   2   |   3   |
 --------------------------------
        |  GHI  |  JKL  |  MNO  |
        |   4   |   5   |   6   |
 --------------------------------
        | PQRS  |  TUV  | WXYZ  |
        |   7   |   8   |   9   |
 --------------------------------
        |       |       |       |
        |   *   |   0   |   #   |
 --------------------------------

Aber Einschienenbahn! Das steht nicht in der Spezifikation! Sie können nicht einfach etwas anderes zeichnen, weil es einfacher ist und Sie Lust dazu haben! Auch wenn ich Ihre Aufmerksamkeit habe, sind Sie sehr klug und süß.

Shh, shh, es ist okay. Mit pb können Sie auf einen Punkt auf der Leinwand mit einem oder mehreren negativen Werten in den Koordinaten "schreiben". Der Wert wird gespeichert, während das Programm ausgeführt wird, aber nur Punkte, an denen X und Y beide> = 0 sind, werden tatsächlich auf den Bildschirm geschrieben. Dieses Programm positioniert den Pinsel so, dass Bereiche, die in diesem Bild getönt sind, ein negatives X oder Y haben:

Obwohl zusätzliche Linien "gezeichnet" werden, werden sie nie gedruckt.

Nach dem Durchlaufen und Erstellen des Rasters füllt dieses Programm die oberen neun Felder aus. Die erste ist fest codiert, eine 1 wird geschrieben und das Programm geht weiter. Die anderen acht werden programmgesteuert generiert. Wenn Sie den Code zum Wechseln zum nächsten Feld ignorieren, feststellen, wann die Zeile leer ist usw. (vorausgesetzt, der Pinsel beginnt immer in der unteren Zeile des Felds und in der mittleren Spalte), wird dies acht Mal ausgeführt:

b[T+50]
^<w[X%8!6]{b[65+T*3+X%8%3]>}
t[T+1]

Selbst wenn Sie wissen, dass dies bder Befehl zum Schreiben eines Zeichens ist, ^v<>bewegen Sie den Pinsel und führen Sie w[a!b]{}den Code in geschweiften Klammern aus, bis a != bdies schwer zu befolgen ist. Als erstes ist zu beachten, dass Sie in pb keine Variablen definieren können. In jedem Programm gibt es sechs, und Sie müssen lernen, mit ihnen zu leben. Zweitens Tist dies die einzige Variable, die Sie tatsächlich so verwenden können, wie Sie es von Variablen gewohnt sind. einen Wert zuweisen und später lesen. Jede andere Variable kann entweder nicht festgelegt werden und sagt nur etwas über den Punkt auf der Leinwand aus, auf dem Sie sich befinden, oder sie kann nur indirekt und mit Nebenwirkungen festgelegt werden ( ^v<>ändern Xund Y, wodurch sich auch die Pinselposition ändert.c Sätze Pzu(P+1)%8, wodurch auch die Ausgabefarbe geändert wird). Es ist einfach unmöglich, einen Zähler dafür zu führen, welche Zahl geschrieben werden muss und welche Buchstaben. Stattdessen verfolgt dieser Code nur die Nummer und ermittelt die darauf basierenden Buchstaben. Hier ist wie:

b[T+50]                       # We start printing at box 2 with T==0, 0+50=='2'
^<                            # Go up and to the left of the number
w[X%8!6]{                     # Take the X coordinate mod 8 so it's like we're in
                              # the leftmost box. Until hitting the sixth cell:
    b[                          # Write this character:
      65                          # 'A'
      + T * 3                     # Number of current box - 2 (letters start at
                                  # 2) * 3 (3 letters per box)
      + X % 8 % 3                 # X % 8 makes every box behave like it's on the
                                  # left, % 3 puts 0 at the point where the first
                                  # letter goes, then 1, then 2. This is how each
                                  # letter is made different in a box.
    ]
    >                           # Move to the right
}
t[T+1]                        # Box is done, increase counter

Dies ist nicht perfekt, da nur 3 Buchstaben in die Felder 7 und 9 eingegeben werden. Nach dem Füllen der unteren Zeile (einfache Hardcodierung) wird jeder Buchstabe in Feld 9 um 2 erhöht und das W manuell platziert. In ähnlicher Weise wird jeder Buchstabe in den Feldern 7 und 8 um 1 erhöht und das P wird manuell platziert.

Ungolfed:

<[8]^                         # Go to (-8, -1)
w[Y!14]{                      # While the brush is not on Y=14:
    w[X!24]{                      # While the brush is not on X=24:
        >[8]                          # Go right 8
        b[124]^b[124]v                # Draw a pipe at the current location and above it
    }
    vw[X!-8]{b[45]<}              # Go down and draw hyphens all the way until X=-8
    vv                            # Go down by 2 to start drawing next row
}
>[12]^[12]b[49]               # Write a 1 in the first box
>[12]                          # Go to the bottom pipe on the right of box 2       
w[T!8]{                       # While T is not 8:
    <[4]                          # Go to center cell of the box
    b[T+50]                       # Write the number that belongs there
    ^<w[X%8!6]{b[65+T*3+X%8%3]>}  # Write the letters
    >[10]v                        # Go to the next box
    w[B!124]{                     # If the next box isn't there:
        <[24]vvv                      # Go down a row
    }
    t[T+1]                        # Increase counter
}
<[4]b[42]>[8]b[48]>[8]b[35]   # Put the asterisk, 0 and hash in their boxes
^[4]>w[B!0]{b[B+2]<}          # Increase all letters in the 9th box by 2
b[87]                         # Put a W in the 9th box
w[X!2]{<[5]w[B!0]{b[B+1]<}}   # Increase all letters in the 7th/8th box by 1
b[80]                         # Put a P in the 7th box

Brainfuck, 565 Zeichen (212 Bytes)

 1 +++++[>+++++>>>>+++++++++>>>>+++++++++++++<<<<<<<<<-]    //initialize
 2 >[->>+++++>>>>+++++<<<<<<]                               //initialize
 3 >>>++++++++[-<<<++++++>++++>>>>>>++++<<<<]               //initialize
 4 ++++++++++<->>>>-<<                                      //initialize
 5
 6 //print first block (123)
 7 >+++++[-<.....>]<<.>>>.>.......<.<++[->>..>.+.+.+<..<.<]<<.<.>>>+++[-<<<<...<+.>...>.>>>]<<.
 8 //print second block (456)
 9 >>+++++[-<.....>]<<.>>>.<+++[->>..>.+.+.+<..<.<]<<.<.>>>+++[-<<<<...<+.>...>.>>>]<<.
10 //print third block (789)
11 >>+++++[-<.....>]<<.>>>.>.>.+.+.+.+<..<.>..>.+.+.+<..<.>.>.+.+.+.+<..<.<<<.<.>>>+++[-<<<<...<+.>...>.>>>]<<.
12 //print fourth block (*0#)
13 >>+++++[-<.....>]<<.>>>.<+++[->>.......<.<]<<.<.<...<---------------.>...>.<...<++++++.>...>.<...<-------------.>...>.>>><<.
14 //print last block (the remaining dashes)
15 >>+++++[-<.....>]

Einfacher Code:

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

Bubblegum , 103 Bytes

Hexdump:

00000000: d3d5 c501 b86a 1420 0048 3b3a 3983 6917  .....j. .H;:9.i.
00000010: 5737 200d 9631 84c8 2818 4169 6310 cd85  W7 ..1..(.Aic...
00000020: cb30 b069 ee1e 9e60 b55e de3e 60da d7cf  .0.i...`.^.>`...
00000030: 1f66 9a09 d414 5328 6d46 d0b4 80c0 a060  .f....S(mF.....`
00000040: b0da 90d0 3010 1d1e 1119 0533 cd1c 6a8a  ....0......3..j.
00000050: 0594 b624 ec36 984f 5169 b08c 1654 c400  ...$.6.OQi...T..
00000060: 4a2b e337 0d00 04                        J+.7...

Langweilig und praktisch.

Python 2, 147 Bytes

print(("|%s"*3+"|\n")*2).join(["-"*25+"\n"]*5)%tuple(x.center(7)for x in" ABC DEF 1 2 3 GHI JKL MNO 4 5 6 PQRS TUV WXYZ 7 8 9    * 0 #".split(' '))

Ein kurzer Entwurf einer grundlegenden Strategie. Verwendet die Zeichenfolgenformatierung, um die Beschriftungen einzufügen, die in einer langen Zeichenfolge fest codiert sind.

C 160 Bytes

j,k,l,m,n=65;main(i){for(i=325;i--;i%25||puts(""))l=i-139,putchar((k=i/25%3)?(j=i%25%8)?k-2?j-4?32:"123456789*0#"[m++]:j/3-1&&l*l!=64||i%290<75?32:n++:'|':45);}

Es ist sinnvoll, die Tatsache zu nutzen, dass die Buchstaben der Reihe nach sind. Dieser Code durchläuft die 325 Zeichen der Tastatur und druckt nach Bedarf entweder ein Leerzeichen oder den nächsten Buchstaben.

Ungolfed

i,    //main loop variable
j,    //x position within key
k,    //y position within key
l,    //distance from character 139 (the space immediately left of T)
m,    //symbol counter
n='A';//letter counter

main(){
  for(i=325;i--;i%25||puts(""))             //loop through 325 characters. puts() adds a newline at the end of each line of 25 
    l=i-139,                                //calculate l. if it is 8, we need to print P or W
    putchar((k=i/25%3)?                     //if row not divisible by 3
      (j=i%25%8)?                             //if position on row not a |
         k-2?                                   //if row mod 3 = 1
           j-4?' ':"123456789*0#"[m++]            //print a space or a character from the string (increment m for next time)
         :                                      //else row mod 3 must = 2
           j/3-1&&l*l!=64||i%290<75?' ':n++       //print a space or a letter according to formula (increment n to the next letter)
      :'|'                                    //else print |
    :
    '-')                                    //else print -
;}

// j/3-1 returns a 0 when in any of the three columns where letters are generally found
// l*l!=64 returns a 0 at the correct place fo P and W
// i%290<75 returns a 1 for keys 1,*,0,#, supressing the printing of letters/symbols

Java, 296 Bytes

Golf:

class a{static void main(String[]a){System.out.println("-\n|&|  ABC  |  DEF  |\n|$1$|$2$|$3$|\n-\n|  GHI  |  JKL  |  MNO  |\n|$4$|$5$|$6$|\n-\n| PQRS  |  TUV  | WXYZ  |\n|$7$|$8$|$9$|\n-\n|&|&|&|\n|$*$|$0$|$#$|\n-".replace("&","       ").replace("$","   ").replace("-","--------------------"));}}

Ungolfed:

public class AsciiPhoneKeypad{
    public static void main(String []args){
        // - for twenty-five dashes
        // $ for three spaces
        // & for seven spaces
        System.out.println("-\n|&|  ABC  |  DEF  |\n|$1$|$2$|$3$|\n-\n|  GHI  |  JKL  |  MNO  |\n|$4$|$5$|$6$|\n-\n| PQRS  |  TUV  | WXYZ  |\n|$7$|$8$|$9$|\n-\n|&|&|&|\n|$*$|$0$|$#$|\n-"
        .replace("&","       ").replace("$","   ").replace("-","--------------------"));
     }
}

Lua, 209 Bytes

Golf:

a=("-\n|&|  ABC  |  DEF  |\n123|\n-\n|  GHI  |  JKL  |  MNO  |\n456|\n-\n| PQRS  |  TUV  | WXYZ  |\n789|\n-\n|&|&|&|\n*0#|\n-"):gsub("&","       "):gsub("([0-9*#])","|   %1   "):gsub("-",("-"):rep(25))print(a)

Ungolfed:

-- "&" for seven spaces
-- "1" -> "|   1   "
-- "-" -> twenty-five dashes

a="-\n|&|  ABC  |  DEF  |\n123|\n-\n|  GHI  |  JKL  |  MNO  |\n456|\n-\n| PQRS  |  TUV  | WXYZ  |\n789|\n-\n|&|&|&|\n*0#|\n-"

a = a:gsub("&","       ")

a = a:gsub("([0-9*#])","|   %1   ")

a = a:gsub("-",("-"):rep(25))

print(a)

JavaScript (ES6), 184 182 Bytes

f=
_=>`-
! |  ABC  |  DEF  |
!1!2!3|
-
|  GHI  |  JKL  |  MNO  |
!4!5!6|
-
| PQRS  |  TUV  | WXYZ  |
!7!8!9|
-
! ! ! |
!*!0!#|
-`.replace(/-|!./g,s=>s<`-`?`|   ${s[1]}   `:s.repeat(25))
;document.write('<pre>'+f());

Die Strichreihen sind offensichtlich komprimierbar und die Ziffern auch, aber ich konnte mit den Buchstaben nichts anfangen. Bearbeiten: 1 von 2 Bytes dank @Shaggy gespeichert.

CJam, 128 Bytes

'-25*N+:A" ABC DEF GHI JKL MNO PQRS TUV WXYZ   "S/3/{['|\{_,5\-S*\"  |"}%N]:+:+}%"123456789*0#"1/3/{['|\{S3*_@@'|}%N]:+:+}%.+A*A

Probieren Sie es online aus.

Perl, 142 + 1 = 143 Bytes

$ perl -MCompress::Zlib x.pl
$ cat x.pl
print uncompress(<DATA>)
__DATA__
x<9c><d3><d5><c5>^A<b8>j^T ^@H;:9<83>i^WW7 ^M<96>1<84><c8>(^XAic<10><cb>0<b0>i<ee>^^<9e>`<b5>^<de>>`<da><d7><cf>^_f<9a> <d4>^TS(mFд<80> `<b0>ڐ<d0>0^P^]^^^Q^Y^E3<cd>^\j<8a>^E<94><b6>$<ec>6<98>OQi<b0><8c>^VT<c4>^@J+<e3>7^M^@^D:@k

Nicht druckbare Zeichen, daher ist die uuencodierte Version unten.

$ cat x.pl.uue
begin 664 x.pl
M<')I;G1?=6YC;VUP<F5S<R@\1$%403XI"E]?1$%405]?"GB<T]7%`;AJ%"``
M2#LZ.8-I%U<W(`V6,83(*!A!:6,0S87+,+!I[AZ>8+5>WCY@VM?/'V::"=04
M4RAM1M"T@,"@8+#:D-`P$!T>$1D%,\T<:HH%E+8D[#:83U%IL(P65,0`2BOC
(-PT`!#I`:PH`
`
end
$

Python 3.5 - 240 Bytes:

k=' ABC DEF 1 2 3 GHI JKL MNO 4 5 6 PQRS TUV WXYZ 7 8 9    * 0 #'.split(' ')
for _ in range(8):
 print('\n',end='')
 if _%2==0:print("-"*27+'\n',end='')
 [print('|{}|'.format(g.center(7)),end='')for g in k[:3:1]];del k[:3:1]
print('\n'+"-"*27)

Druckt genau das, was das OP will, obwohl es etwas lang sein kann.

Python 2, 200

r=str.replace;print r(r(r(r(r("""-.|  ABC`DEF`
,1=,2=,3 `-|  GHI`JKL`MNO`
,4=,5=,6 `-| PQRS`TUV`WXYZ |
,7=,8=,9 `-...|
,*=,0=,# `-""","-","\n"+"-"*25+"\n"),".",",= "),",","|="),"`","  |  "),"=","   ")

Einfache Ersetzungsstrategie.

Python 2, 168 Bytes

Eine einfache Methode ohne integrierte Komprimierung:

for i in range(13):print['-'*25,'|'+'|'.join(["123456789*0#"," ABC DEF GHI JKL MNO PQRS TUV WXYZ   ".split(' ')][i%3%2][i/3%4*3+m].center(7)for m in[0,1,2])+'|'][i%3>0]

/// , 154 Zeichen

/%/=====//=/-----//?/ ! //!/}  //{/ }//}/  |//(/|   /%
(  !ABC!DEF}
(1?2?3{
%
|  GHI!JKL!MNO}
(4?5?6{
%
| PQRS!TUV} WXYZ}
(7?8?9{
%
(  !   !   }
(*?0?#{
%

GML (Game Maker Language) 8.0, 269 Bytes

a='-------------------------'b='   |   'c='  |#|   'draw_text(0,0,a+"#|       |  ABC  |  DEF"+c+"1"+b+"2"+b+"3   |#"+a+"#|  GHI  |  JKL  |  MNO"+c+"4"+b+"5"+b+"6   |#"+a+"#| PQRS  |  TUV  | WXYZ"+c+"7"+b+"8"+b+"9   |#"+a+"#|    "+b+" "+b+"  "+c+"*"+b+"0"+b+"\#   |#"+a)

In Game Maker #ist der Newline-Charakter und es kann durch entkommen\#

Python 2, 134 Bytes

Diese Quelle enthält nicht druckbare Zeichen und wird daher als Hexdump dargestellt, mit dem dekodiert werden kann xxd -r.

00000000: efbb bf70 7269 6e74 2778 01d3 c505 b86a  ...print'x.....j
00000010: 1420 5c30 483b 3a39 8369 1757 3720 5c72  . \0H;:9.i.W7 \r
00000020: 9631 84c8 2818 4169 6310 cd85 d734 770f  .1..(.Aic....4w.
00000030: 4fb0 5a2f 6f1f 30ed ebe7 0f33 cd04 6a8a  O.Z/o.0....3..j.
00000040: 2994 3623 685a 4060 5030 586d 4868 1888  ).6#hZ@`P0XmHh..
00000050: 0e8f 888c 8299 660e 35c5 024a 5b12 345c  ......f.5..J[.4\
00000060: 7202 3068 b08c 1654 c45c 304a 2be3 375c  r.0h...T.\0J+.7\
00000070: 725c 3004 3a40 6b27 2e64 6563 6f64 6528  r\0.:@k'.decode(
00000080: 277a 6970 2729                           'zip')

05AB1E , 91 Bytes (nicht konkurrierend)

•O«ò•3B7ô'-7×.ø'|ìε3×}'|«D¦Ð)˜»A3ô5£ðý"pqrs tuvwxyz"‚J5úR12úRv0y.;}1ð:2'A:9LJ"*0#"«v'Ay.;}u

Probieren Sie es online aus!

J , 105 103 Bytes

9!:7'|'9}11#'-'
echo'PW'(7 2;7 18)}":_3;/\(12{.'',8 3$65{26-.&'PW'\a.),:&(5|.7{.])"1' ',.'123456789*0#'

Probieren Sie es online aus!