Los símbolos contra las letras

¡Los caracteres ASCII se han dividido una vez más ! Sus conjuntos son las letras y los símbolos .

Las cartas

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Los símbolos

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

La tarea es escribir dos programas:

1. Imprime cada uno de cartas exactamente una vez sin utilizar ninguna de ellas en su programa.

2. Imprime cada uno de los símbolos exactamente una vez sin usar ninguno de ellos en su programa.

Reglas

• Los espacios en blanco pueden aparecer en su programa o en la salida.
• No se permiten caracteres no ASCII.
• La salida va a la salida estándar o a un archivo como el contenido o el nombre del archivo.
• Sin entrada.
• La salida solo debe contener caracteres ASCII de un conjunto u otro.
• Los programas se pueden escribir en diferentes idiomas o en el mismo idioma con una excepción:
• El lenguaje de espacios en blanco solo se puede usar para uno de los programas.
• Se aplican lagunas estándar .

Puntuación

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

¡La puntuación más baja gana!

Nota:

Para alentar más presentaciones, aún puede publicar una respuesta con una solución para solo uno de los programas. No podrás ganar, pero aún podrás mostrar algo genial.

Gracias a Calvin's Hobbies por inspirar la idea con su pregunta anterior .

Total: 53 caracteres

Total en un solo idioma: 230 caracteres, Pyth

Parte 1: Golfscript, 15

91,65>123,97>++

Salidas:

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Explicación:

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.

Parte 2: Pyth , 38

JhCeGLjkmCdbsrCdCPhGsrhCPeGChGsrJhhhhJ

Salidas:

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

Explicación:

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

Solución extra:

Parte 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

Explicación:

$"%\143"$=> "% c". $cambia hacia y desde el estilo de análisis de Python, y en el análisis de cadenas de Python, \143es la secuencia de escape octal para c. Por lo tanto, esta respuesta es equivalente al siguiente código de estilo Python:

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

Por supuesto, esto no funciona en Python, porque la impresión en Python usa print , pero la impresión en Pyth es implícita, por lo que funciona.

Las soluciones Pyth no usan ninguna de las características agregadas ya que se hizo la pregunta.

Python (Símbolos, 87 82)

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

Me encanta el módulo de cadena de Python ...

Editar:

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

Salida:

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

FALSO (Letras, 21) DUP (Letras, 20):

FALSA solución:

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

Solución DUP (1 char más corto)

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

Salida (para ambos):

AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz

Intérprete para FALSO.

Total: 102

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

91,65>{.32+}%+

y

xxcxxcdddKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKDxxxccxxxxxxxxxxKxKxKxKxKxKDxxxcxxcxxKxKxKxK

Partes 1 y 2 en Ruby 2, 56 + 484 = 540

Parte 1:

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

Para más información sobre este estilo de Ruby, mira narfnme .

Parte 2 (este bit es solo Ruby 2.0+, funciona perfectamente con ruby-2.1.0 pero puede dar advertencias en versiones anteriores):

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

Ese fue duro. Llamar a los métodos Fixnum incorporados como chry succrequiere abrir la clase Fixnum y redefinir inspect, ya que puedo activar una llamada x.inspectcon . Afortunadamente, de los caracteres ascii en ese rango,p x . Necesito inspeccionar para regresar nilpara que psolo se imprima una nueva línea, cualquier cadena se enmarcará entre comillas dobles. Pero como efecto secundario, se repite. Puedo terminar el primer bucle y el segundo bucle usando una comparación de cadenas para ver cuándo he alcanzado un rango de letras, pero como no puedo escribir un literal de cadena, necesito obtener uno llamando String()al símbolo devuelto (en Ruby 2) por el , que no puede tomar expresiones de varias líneas, necesito ajustar el literal en un método (ya que obviamente no puedo hacer la asignación). El último ciclo es más difícil de terminar. Necesito que pare endef palabra clave Como esa es una sintaxis multilínea y solo puedo hacer una comparación de cadenas a través decase~~ es el único que se puede invocar en un Fixnum sin argumentos sin generar un error, por lo que puedo usar send chrpara detectar cuándo estoy al final y detener el bucle.

No es el mejor puntaje en este hilo, pero hasta ahora es el único que usa el mismo lenguaje para ambas partes. Yay Ruby

Parte 2 en Applescript, 654

espera ... ¿dónde está la página " consejos para jugar golf en Applescript "?

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

Salida:

CJam + AlphaBeta , 62 bytes

Letras, CJam , 12 bytes

"[{"{,-26>}/

Pruébalo en línea!

Salida

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Cómo funciona

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

Símbolos, AlphaBeta , 50 bytes

ZaaAccctFUaCLOrEbbCLbCLbCLbCLdddACLbCLbCLgDLgDLgDL

Pruébalo en línea!

El intérprete oficial de C ++ tiene un error que hace que los bucles sean imposibles y no puedo entender cómo usar el intérprete de Lua. Arreglé ese error. Puede verificar que funciona según lo previsto ejecutando los programas de ejemplo desde la página EsoLang.

Salida

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

Cómo funciona

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.

Parte 1 en BrainFuck: 80 74 bytes

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

Total 318 bytes

Realmente esperaba encontrar una respuesta con ambos programas en el mismo idioma, pero hasta ahora nada. Aquí está esto en su lugar:

Parte 1: bash puro, 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,,}

Salida:

$ ./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
$ 

Parte 2: GNU dc, 189 bytes

zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzzzzzzzzzzzzzzzzzzzzzzzzzzzPzzPzzPzzPzzPzzPzzBDPBEdPBFPdkvZP

Salida:

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

Bueno, ya sabes, alguien debería ponerlo en marcha.

Parte 1 en BrainFuck: 174 bytes

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

Parte 1: Ruby, 45 bytes

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

Explicación

• Un rango que contiene az ( ?@...?[) y un rango que contiene AZ ( ?`...?{) se convierten en los elementos de la matriz _utilizando el operador splat ( *).
• El elemento 0 ( "@") y el elemento 27 ( "`") de la matriz _se establecen en nil.
• La matriz _se une Array#*e imprime en stdout ( $>)