Os Símbolos vs. As Letras

Os caracteres ASCII foram divididos mais uma vez ! Seus conjuntos são As letras e Os símbolos .

As cartas

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Os Símbolos

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

A tarefa é escrever dois programas:

1. Imprima cada uma das cartas exatamente uma vez sem usar nenhuma delas em seu programa.

2. Imprima cada um dos símbolos exatamente uma vez sem usar nenhum deles em seu programa.

Regras

• Espaço em branco pode aparecer no seu programa ou na saída.
• Caracteres não ASCII não são permitidos.
• A saída vai para a saída padrão ou para um arquivo como o conteúdo ou o nome do arquivo.
• Sem entrada.
• A saída deve conter apenas caracteres ASCII de um conjunto ou do outro.
• Os programas podem ser escritos em diferentes idiomas ou no mesmo idioma, com uma exceção:
• O idioma Whitespace pode ser usado apenas para um dos programas.
• Aplicam-se brechas padrão .

Pontuação

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

Menor pontuação ganha!

Nota:

Para incentivar mais envios, você ainda pode postar uma resposta com uma solução para apenas um dos programas. Você não será capaz de vencer, mas ainda poderá mostrar algo legal.

Agradecemos ao Calvin's Hobbies por inspirar a idéia com sua pergunta anterior .

Total: 53 caracteres

Total em um único idioma: 230 caracteres, Pyth

Parte 1: Golfscript, 15

91,65>123,97>++

Saídas:

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Explicação:

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: Pitão , 38

JhCeGLjkmCdbsrCdCPhGsrhCPeGChGsrJhhhhJ

Saídas:

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

Explicação:

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

Solução bônus:

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

Explicação:

$"%\143"$=> "% c". $alterna de e para o estilo de análise Python e, na análise de seqüência de caracteres Python, \143é a sequência de escape octal para c. Esta resposta é, portanto, equivalente ao seguinte código no estilo Python:

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

Obviamente, isso não funciona no Python, porque a impressão no Python usa print, mas a impressão no Pyth está implícita, por isso funciona.

As soluções Pyth não usam nenhum dos recursos adicionados desde que a pergunta foi feita.

Python (Símbolos, 87 82)

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

Eu simplesmente amo o módulo de strings do Python ...

Editar:

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

Resultado:

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

FALSE (Cartas, 21) DUP (Cartas, 20):

Solução FALSE:

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

Solução DUP (1 caractere mais curto)

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

Saída (para ambos):

AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz

Intérprete para FALSO.

Total: 102

GolfScript (14 caracteres) + Peixe morto x (116 caracteres) = 130 caracteres

91,65>{.32+}%+

e

xxcxxcdddKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKDxxxccxxxxxxxxxxKxKxKxKxKxKDxxxcxxcxxKxKxKxK

Partes 1 e 2 no Ruby 2, 56 + 484 = 540

Parte 1:

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

Para saber mais sobre esse estilo de Ruby, confira narfnme .

Parte 2 (esse bit é apenas Ruby 2.0+, funciona perfeitamente com o ruby-2.1.0, mas pode fornecer avisos nas versões 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

Aquele foi difícil. Chamar métodos Fixnum internos como chre succrequer a abertura da classe Fixnum e a redefinição inspect, pois posso acionar uma chamada x.inspectcom p x. Preciso inspecionar para retornar, nilpara que papenas imprima uma nova linha, qualquer sequência será enquadrada entre aspas duplas. Mas como efeito colateral, ele faz um loop. Posso finalizar o primeiro loop e o segundo loop usando uma comparação de strings para ver quando atingi um intervalo de letras, mas como não consigo escrever um literal de strings, preciso obtê-lo chamando String()o símbolo retornado (em Ruby 2) pela defpalavra - chave. Como essa é uma sintaxe multilinha, eu só posso fazer comparação de strings viacase, que não pode aceitar expressões com várias linhas, preciso agrupar o literal em um método (já que obviamente não posso fazer a atribuição). O último loop é mais difícil de terminar. Eu preciso que pare às ~. Felizmente, dos caracteres ascii nesse intervalo, ~é o único que pode ser chamado em um Fixnum sem argumentos sem gerar um erro, para que eu possa usar send chrpara detectar quando estou no final e parar de executar o loop.

Não é a melhor pontuação neste segmento, mas até agora o único que usa o mesmo idioma para ambas as partes. Yay Ruby.

Parte 2 no Applescript, 654

espere ... onde está a página " dicas para jogar golfe no 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

Resultado:

CJam + AlphaBeta , 62 bytes

Cartas, CJam , 12 bytes

"[{"{,-26>}/

Experimente online!

Resultado

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Como 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

Experimente online!

O intérprete oficial do C ++ possui um bug que impossibilita os loops e não consigo descobrir como usar o intérprete Lua. Eu consertei esse bug. Você pode verificar se ele funciona conforme o esperado, executando os programas de exemplo na página EsoLang.

Resultado

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

Como 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 no BrainFuck: 80 74 bytes

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

Total 318 bytes

Eu realmente esperava encontrar uma resposta com os dois programas no mesmo idioma, mas até agora nada. Aqui está isso:

Parte 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,,}

Resultado:

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

Resultado:

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

Bem, alguém deve seguir em frente.

Parte 1 no BrainFuck: 174 bytes

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

Parte 1: Ruby, 45 bytes

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

Explicação

• Um intervalo contendo az ( ?@...?[) e um intervalo contendo AZ ( ?`...?{) tornam-se os elementos da matriz _usando o operador splat ( *).
• O 0º elemento ( "@") e o 27º elemento ( "`") da matriz _estão definidos como nil.
• A matriz _é unida usandoArray#* e impressa em stdout ( $>)