Die Symbole gegen die Buchstaben

Die ASCII - Zeichen wurden einmal geteilt wieder ! Deine Sets sind Die Buchstaben und Die Symbole .

Die Buchstaben

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Die Symbole

!"#$%&'()*+,-./0123456789:;<=>?@[\]^_`{|}~

Die Aufgabe besteht darin, zwei Programme zu schreiben:

1. Drucken Sie jeden Buchstaben genau einmal aus, ohne ihn in Ihrem Programm zu verwenden.

2. Drucken Sie jedes der Symbole genau einmal aus, ohne eines davon in Ihrem Programm zu verwenden.

Regeln

• In Ihrem Programm oder in der Ausgabe wird möglicherweise ein Leerzeichen angezeigt.
• Nicht-ASCII-Zeichen sind nicht zulässig.
• Die Ausgabe erfolgt als Standardausgabe oder in eine Datei als Inhalt oder Name der Datei.
• Keine Eingabe.
• Die Ausgabe darf nur ASCII-Zeichen aus dem einen oder anderen Satz enthalten.
• Die Programme können mit einer Ausnahme in verschiedenen Sprachen oder in derselben Sprache geschrieben werden:
• Die Whitespace-Sprache darf nur für eines der Programme verwendet werden.
• Es gelten Standardlücken .

Wertung

# of characters in program 1 +# of characters in program 2 =Score

Die niedrigste Punktzahl gewinnt!

Hinweis:

Um mehr Einsendungen zu ermutigen, können Sie immer noch eine Antwort mit einer Lösung für nur eines der Programme posten. Sie werden nicht gewinnen können, aber Sie werden trotzdem in der Lage sein, etwas Cooles zu zeigen.

Vielen Dank an Calvins Hobbys , die die Idee mit seiner vorherigen Frage inspiriert haben .

Gesamt: 53 Zeichen

Insgesamt in einer Sprache: 230 Zeichen, Pyth

Teil 1: Golfscript, 15

91,65>123,97>++

Ausgänge:

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Erläuterung:

91,           Make the list, [0 1 .. 90]
65>           Take elements after the 65th, [65 66 .. 90]
123,97>       Same, but [97 98 .. 122]
+             Add the list above to the newline character that is automatically pushed to 
              the stack. List + str coerces to string by ascii encoding.
+             Same, for the other list.

Teil 2: Pyth , 38

JhCeGLjkmCdbsrCdCPhGsrhCPeGChGsrJhhhhJ

Ausgänge:

 !"#$%&'()*+,-./0123456789:;<=>?@
[\]^_`
{|}~

Erläuterung:

G = "abcdefghijklmnopqrstuvwxyz"   Implicit.
k = ""                             Implicit.
d = " "                            Implicit.
JhCeG                              J = 1 + chr(end(G))          # J = 123
L                                  def d(b): return
 jk                                                k.join(
   m                                                      map(lambda d:
    Cd                                                                 chr(d),
    b                                                                  b))
s                                  print(s(                    #print is implicit.
 rCd                               range(chr(d),                 # chr(d) = 32
 CPhG                                    chr(upper(head(G))))    # chr("A") = 65
srhCPeGChG                         print(s(range(1+chr(upper(end(G))),chr(head(G)))
srJhhhhJ                           print(s(range(J, 1+1+1+1+J)))

Bonuslösung:

Teil 1: Pyth, 192

%*$"%\143"$52(65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122

Erläuterung:

$"%\143"$=> "% c". $Wechselt zum und vom Python-Parsing-Stil. Beim Python-String-Parsing \143ist dies die oktale Escape-Sequenz für c. Diese Antwort entspricht daher dem folgenden Python-Code:

("%c" * 52) % (65, 66, 67, ...)

Natürlich funktioniert dies in Python nicht, da das Drucken in Python verwendet wird print, aber das Drucken in Python ist implizit, sodass es funktioniert.

Pyth-Lösungen verwenden keine der Funktionen, die hinzugefügt wurden, seit die Frage gestellt wurde.

Python (Symbole, 87 82)

from string import punctuation
from string import digits
print digits
print punctuation

Ich liebe Pythons String-Modul ...

Bearbeiten:

from string import punctuation as p
from string import digits as d
print d
print p

Ausgabe:

0123456789
!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~

FALSCH (Buchstaben, 21) DUP (Buchstaben, 20):

FALSCHE Lösung:

65[$91\>][$,$32+,1+]#

DUP sollution (1 Zeichen kürzer)

65[$91<][$,$32+,1+]#

Ausgabe (für beide):

AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz

Dolmetscher für FALSE.

Gesamt: 102

GolfScript (14 Zeichen) + Deadfish x (116 Zeichen) = 130 Zeichen

91,65>{.32+}%+

und

xxcxxcdddKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKDxxxccxxxxxxxxxxKxKxKxKxKxKDxxxcxxcxxKxKxKxK

Teile 1 und 2 in Ruby 2, 56 + 484 = 540

Teil 1:

__=->_{(91..96)===_||$><<(''<<_);_>121||__[-~_]}
__[65]

Weitere Informationen zu diesem Ruby-Stil finden Sie unter narfnme .

Teil 2 (dieses Bit ist nur Ruby 2.0+ und funktioniert perfekt mit Ruby-2.1.0, kann aber in früheren Versionen Warnungen ausgeben):

class Fixnum
def c
String def a
end
end
def b
String def A
end
end
def x
String def z
end
end
def y
String def Z
end
end
def inspect
case chr
when c
when b
when y
p succ
else
print chr
p succ
end
p
rescue
p
end
end
def x
String def z
end
end
def y
String def Z
end
end
class String
def inspect
p size
p
end
end
p String p
class String
def inspect
p ord
p
end
end
p y
class Fixnum
def inspect
case chr
when x
p succ
else
send chr
print chr
p
end
p
rescue
print chr
p succ
p
end
end
p x

Das war schwer. Das Aufrufen von eingebauten Fixnum-Methoden gefällt chrund succerfordert das Öffnen der Fixnum-Klasse und das Neudefinieren inspect, da ich einen Aufruf von x.inspectmit auslösen kann p x. Ich muss inspizieren, um zurückzukehren nil, pdamit nur eine neue Zeile gedruckt wird. Jede Zeichenfolge wird in doppelte Anführungszeichen gesetzt. Aber als Nebeneffekt schleift es. Ich kann die erste und die zweite Schleife mit einem Zeichenfolgenvergleich beenden, um festzustellen, wann ich einen Buchstabenbereich erreicht habe. Da ich jedoch kein Zeichenfolgenliteral schreiben kann, muss ich eines durch Aufrufen String()des zurückgegebenen Symbols abrufen (in Ruby 2). nach dem defSchlüsselwort. Da das eine mehrzeilige Syntax ist und ich nur einen Stringvergleich über machen kanncase, die keine mehrzeiligen Ausdrücke aufnehmen können, muss ich das Literal in eine Methode einschließen (da ich offensichtlich keine Zuweisung machen kann). Die letzte Schleife ist schwerer zu beenden. Ich muss damit aufhören ~. Glücklicherweise ist eines der ASCII-Zeichen in diesem Bereich ~das einzige, das auf einem Fixnum ohne Argumente aufgerufen werden kann, ohne einen Fehler auszulösen, sodass ich erkennen kann send chr, wann ich am Ende bin, und die Schleife beenden kann.

Nicht die beste Punktzahl in diesem Thread, aber bisher die einzige, die für beide Teile dieselbe Sprache verwendet. Yay Ruby.

Teil 2 in Applescript, 654

Warten Sie ... Wo sind die " Tipps zum Golfen in Applescript " -Seite?

global a
global b
global c
global s
on f at n
set end of b to a
end
on g at n
f at a
f at a
end
on h at n
g at a
g at a
end
on i at n
h at a
h at a
end
on j at n
repeat with t in system info
f at a
end
end
on m at n
set end of b to a
set c to count of b
set end of s to ASCII character c
end
on n at n
m at a
m at a
m at a
end
on o at n
repeat with t in system info
m at a
end
end
set a to random number
set b to a as list
j at a
j at a
set c to count of b
set s to ASCII character c
set s to s as list
o at a
n at a
n at a
n at a
n at a
n at a
j at a
i at a
g at a
f at a
n at a
m at a
m at a
j at a
i at a
g at a
n at a
m at a
display dialog s as text

Ausgabe:

CJam + AlphaBeta , 62 Bytes

Buchstaben, CJam , 12 Bytes

"[{"{,-26>}/

Probieren Sie es online!

Ausgabe

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Wie es funktioniert

"[{"{     }/   For each of the characters "[" and "{",
     ,         push an array of all ASCII characters before it
      -26>     and discard all but the last 26 characters.

Symbole, AlphaBeta , 50 Bytes

ZaaAccctFUaCLOrEbbCLbCLbCLbCLdddACLbCLbCLgDLgDLgDL

Probieren Sie es online!

Der offizielle C ++ - Interpreter hat einen Fehler, der Schleifen unmöglich macht, und ich kann nicht herausfinden, wie der Lua-Interpreter verwendet wird. Ich habe diesen Fehler behoben. Sie können überprüfen, ob es wie beabsichtigt funktioniert, indem Sie die Beispielprogramme auf der EsoLang-Seite ausführen.

Ausgabe

!"#$%&'()*+,-./0123456789:;<=>?@~}|{]\[^_`

Wie es funktioniert

Z      Switch register 4 to the position register.
aa     Set registers 1 to 2.
A      Copy the value from register 1 to register 2.
ccc    Add 30 to register 1 (result: 31).
tF     Set register 2 to the product of registers 1 and 2 (result: 64).
U      Add 10 to the position register (result: 10, i.e., the position of the next byte).
aCL    Add 1 to register 1 and print the corresponding ASCII character.
O      If register 1 != register 2, go to the position in the position register.
rEb    Set register 1 to the sum of registers 1 and 2 minus 1 (result: 127).
bCL    Subtract 1 from register 1 and print the corresponding ASCII character.
bCL    Subtract 1 from register 1 and print the corresponding ASCII character.
bCL    Subtract 1 from register 1 and print the corresponding ASCII character.
bCL    Subtract 1 from register 1 and print the corresponding ASCII character.
ddd    Subtract 30 from register 1 (result: 93).
A      Copy the value from register 1 to register 2.
CL     Print the ASCII character corresponding to register 1.
bCL    Subtract 1 from register 1 and print the corresponding ASCII character.
bCL    Subtract 1 from register 1 and print the corresponding ASCII character.
gDL    Add 1 to register 2 and print the corresponding ASCII character.
gDL    Add 1 to register 2 and print the corresponding ASCII character.
gDL    Add 1 to register 2 and print the corresponding ASCII character.

Teil 1 in BrainFuck: 80 74 Bytes

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

Insgesamt 318 Bytes

Ich hatte wirklich gehofft, mit beiden Programmen in derselben Sprache eine Antwort zu finden, aber bisher nichts. Hier ist dies stattdessen:

Teil 1: Pure Bash, 129 Bytes

_0=`$ 2>&1`
_0=${_0##*:}
_1=${_0:5:1}
_5=${_0:1:1}$_1${_0:11:1}
. <($_5<<<_2=\({${_1^}..$_1}\))
_3=${_2[@]:0:26}
$_5<<<$_3${_3,,}

Ausgabe:

$ ./letsym.sh
A B C D E F G H I J K L M N O P Q R S T U V W X Y Za b c d e f g h i j k l m n o p q r s t u v w x y z
$ 

Teil 2: GNU DC, 189 Bytes

zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzzzzzzzzzzzzzzzzzzzzzzzzzzzPzzPzzPzzPzzPzzPzzBDPBEdPBFPdkvZP

Ausgabe:

$ dc symlet.dc
!"#$%&'()*+,-./0123456789:;<=>?@[\]^_`{|}~$ 

Weißt du, jemand sollte es in Gang bringen.

Teil 1 in BrainFuck: 174 Bytes

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+++++++
.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.

Teil 1: Ruby, 45 Bytes

_=[*?@...?[,*?`...?{]
_[0],_[27]=*$_
$><<_*''

Erläuterung

• Ein Bereich, der az ( ?@...?[) enthält, und ein Bereich, der AZ ( ?`...?{) enthält, werden _mit dem splat-Operator ( *) zu den Elementen des Arrays .
• Das 0. Element ( "@") und das 27. Element ( "`") des Arrays _werden auf gesetzt nil.
• Das Array _wird mit Array#*stdout zusammengefügt und gedruckt ($> )