Les symboles contre les lettres

Les caractères ASCII ont été divisés une fois de plus ! Vos ensembles sont les lettres et les symboles .

Les lettres

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Les symboles

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

La tâche consiste à écrire deux programmes:

1. Imprimez chacune des lettres exactement une fois sans en utiliser aucune dans votre programme.

2. Imprimez chacun des symboles exactement une fois sans en utiliser aucun dans votre programme.

Règles

• Des espaces peuvent apparaître dans votre programme ou dans la sortie.
• Les caractères non ASCII ne sont pas autorisés.
• La sortie passe à la sortie standard ou à un fichier en tant que contenu ou nom du fichier.
• Pas d'entrée.
• La sortie ne doit contenir que des caractères ASCII d'un ensemble ou de l'autre.
• Les programmes peuvent être écrits dans différentes langues ou dans la même langue à une exception près:
• La langue des espaces blancs ne peut être utilisée que pour l'un des programmes.
• Des échappatoires standard s'appliquent.

Notation

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

Le score le plus bas gagne!

Remarque:

Pour encourager plus de soumissions, vous pouvez toujours publier une réponse avec une solution pour un seul des programmes. Vous ne pourrez pas gagner, mais vous pourrez toujours montrer quelque chose de cool.

Merci à Calvin's Hobbies d' avoir inspiré l'idée avec sa question précédente .

Total: 53 caractères

Total dans une seule langue: 230 caractères, Pyth

Partie 1: Golfscript, 15

91,65>123,97>++

Les sorties:

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Explication:

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.

Partie 2: Pyth , 38

JhCeGLjkmCdbsrCdCPhGsrhCPeGChGsrJhhhhJ

Les sorties:

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

Explication:

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

Solution bonus:

Partie 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

Explication:

$"%\143"$=> "% c". $bascule vers et depuis le style d'analyse Python, et dans l'analyse de chaîne Python, \143est la séquence d'échappement octale pour c. Cette réponse est donc équivalente au code de style Python suivant:

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

Bien sûr, cela ne fonctionne pas en Python, car l'impression en Python utilise print, mais l'impression en Pyth est implicite, donc cela fonctionne.

Les solutions Pyth n'utilisent aucune des fonctionnalités ajoutées depuis la question posée.

Python (symboles, 87 82)

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

J'adore le module de chaîne de Python ...

Éditer:

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

Production:

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

FAUX (lettres, 21) DUP (lettres, 20):

FAUX solution:

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

DUP sollution (1 caractère plus court)

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

Sortie (pour les deux):

AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz

Interprète pour FAUX.

Total: 102

GolfScript (14 caractères) + Deadfish x (116 caractères) = 130 caractères

91,65>{.32+}%+

et

xxcxxcdddKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKDxxxccxxxxxxxxxxKxKxKxKxKxKDxxxcxxcxxKxKxKxK

Parties 1 et 2 en Ruby 2, 56 + 484 = 540

Partie 1:

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

Pour en savoir plus sur ce style de Ruby, consultez narfnme .

Partie 2 (ce bit est Ruby 2.0+ uniquement, fonctionne parfaitement avec ruby-2.1.0 mais peut donner des avertissements dans les versions antérieures):

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

Celui-là était dur. L'appel de méthodes Fixnum intégrées comme chret succnécessite l'ouverture de la classe Fixnum et la redéfinition inspect, car je peux déclencher un appel à x.inspectavec p x. J'ai besoin d'inspecter pour revenir nilafin que pne s'affiche qu'une nouvelle ligne, toute chaîne sera encadrée de guillemets doubles. Mais comme effet secondaire, il boucle. Je peux terminer la première boucle et la deuxième boucle en utilisant une comparaison de chaînes pour voir quand j'ai atteint une plage de lettres, mais comme je ne peux pas écrire un littéral de chaîne, je dois en obtenir une en appelant String()le symbole renvoyé (dans Ruby 2) par le defmot - clé. Étant donné que c'est une syntaxe multiligne et que je ne peux comparer les chaînes que viacase, qui ne peut pas prendre d'expressions multilignes, j'ai besoin d'encapsuler le littéral dans une méthode (car je ne peux évidemment pas faire d'affectation). La dernière boucle est plus difficile à terminer. J'en ai besoin pour m'arrêter ~. Heureusement, parmi les caractères ascii de cette plage, ~c'est le seul qui peut être appelé sur un Fixnum sans arguments sans déclencher d'erreur, donc je peux utiliser send chrpour détecter quand je suis à la fin et arrêter la boucle.

Pas le meilleur score dans ce fil, mais jusqu'à présent le seul qui utilise le même langage pour les deux parties. Yay Ruby.

Partie 2 dans Applescript, 654

attendez ... où sont les " conseils pour jouer au golf dans 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

Production:

CJam + AlphaBeta , 62 octets

Lettres, CJam , 12 octets

"[{"{,-26>}/

Essayez-le en ligne!

Production

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Comment ça fonctionne

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

Symboles, AlphaBeta , 50 octets

ZaaAccctFUaCLOrEbbCLbCLbCLbCLdddACLbCLbCLgDLgDLgDL

Essayez-le en ligne!

L'interpréteur C ++ officiel a un bogue qui rend les boucles impossibles et je ne peux pas comprendre comment utiliser l'interpréteur Lua. J'ai corrigé ce bogue. Vous pouvez vérifier qu'il fonctionne comme prévu en exécutant les exemples de programmes à partir de la page EsoLang.

Production

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

Comment ça fonctionne

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.

Partie 1 dans BrainFuck: 80 74 octets

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

Total 318 octets

J'espérais vraiment trouver une réponse avec les deux programmes dans la même langue, mais jusqu'à présent rien. Voici ceci à la place:

Partie 1: Pure bash, 129 octets

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

Production:

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

Partie 2: GNU dc, 189 octets

zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzzzzzzzzzzzzzzzzzzzzzzzzzzzPzzPzzPzzPzzPzzPzzBDPBEdPBFPdkvZP

Production:

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

Eh bien, vous savez, quelqu'un devrait commencer.

Partie 1 dans BrainFuck: 174 octets

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

Partie 1: Ruby, 45 octets

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

Explication

• Une plage contenant az ( ?@...?[) et une plage contenant AZ ( ?`...?{) deviennent les éléments du tableau _à l'aide de l'opérateur splat (* ).
• Le 0ème élément ( "@") et le 27ème élément ( "`") du tableau _sont définis sur nil.
• Le tableau _est joint à l'aide de Array#*et imprimé sur stdout ( $>)