I simboli contro le lettere

I caratteri ASCII sono stati nuovamente divisi ! I tuoi set sono Le lettere e I simboli .

Le lettere

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

I simboli

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

Il compito è scrivere due programmi:

1. Stampa ciascuna delle lettere esattamente una volta senza usarne nessuna nel tuo programma.

2. Stampa ciascuno dei simboli esattamente una volta senza usarli nel tuo programma.

Regole

• Gli spazi bianchi possono essere visualizzati nel programma o nell'output.
• Non sono ammessi caratteri non ASCII.
• L'output passa allo standard out o ad un file come contenuto o nome del file.
• Nessun input
• L'output deve contenere solo caratteri ASCII di un set o dell'altro.
• I programmi possono essere scritti in diverse lingue o nella stessa lingua con una sola eccezione:
• La lingua degli spazi bianchi può essere utilizzata solo per uno dei programmi.
• Si applicano scappatoie standard .

punteggio

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

Il punteggio più basso vince!

Nota:

Per incoraggiare ulteriori invii, è comunque possibile pubblicare una risposta con una soluzione per uno solo dei programmi. Non sarai in grado di vincere, ma sarai comunque in grado di mostrare qualcosa di interessante.

Grazie a Hobby di Calvin per aver ispirato l'idea con la sua domanda precedente .

Totale: 53 caratteri

Totale in una sola lingua: 230 caratteri, Pyth

Parte 1: Golfscript, 15

91,65>123,97>++

Uscite:

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Spiegazione:

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

Uscite:

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

Spiegazione:

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

Soluzione bonus:

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

Spiegazione:

$"%\143"$=> "% c". $passa da e verso lo stile di analisi Python e, nell'analisi della stringa Python, \143è la sequenza di escape ottale per c. Questa risposta equivale quindi al seguente codice in stile Python:

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

Naturalmente, questo non funziona in Python, perché la stampa in Python lo utilizza print, ma la stampa in Pyth è implicita, quindi funziona.

Le soluzioni Pyth non utilizzano nessuna delle funzionalità aggiunte da quando è stata posta la domanda.

Python (Simboli, 87 82)

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

Adoro il modulo di stringa di Python ...

Modificare:

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

Produzione:

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

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

Soluzione FALSE:

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

DUP sollution (1 carattere più corto)

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

Uscita (per entrambi):

AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz

Interprete per FALSO.

Totale: 102

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

91,65>{.32+}%+

e

xxcxxcdddKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKDxxxccxxxxxxxxxxKxKxKxKxKxKDxxxcxxcxxKxKxKxK

Parti 1 e 2 in Ruby 2, 56 + 484 = 540

Parte 1:

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

Per ulteriori informazioni su questo stile di Ruby, dai un'occhiata a narfnme .

Parte 2 (questo bit è solo Ruby 2.0+, funziona perfettamente con ruby-2.1.0 ma può dare avvisi nelle versioni precedenti):

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

Quello è stato difficile. La chiamata di metodi Fixnum integrati come chre succrichiede l'apertura della classe Fixnum e la ridefinizione inspect, poiché posso attivare una chiamata x.inspectcon p x. Ho bisogno di ispezionare per tornare in nilmodo che pstamperà solo una nuova riga, qualsiasi stringa verrà racchiusa tra virgolette. Ma come effetto collaterale, si avvolge. Posso terminare il primo e il secondo loop usando un confronto di stringhe per vedere quando ho raggiunto un intervallo di lettere, ma poiché non riesco a scrivere una stringa letterale, devo ottenerne una chiamando String()il simbolo restituito (in Ruby 2) dalla defparola chiave. Dal momento che questa è una sintassi multilinea e posso solo fare il confronto delle stringhe tramitecase, che non può assumere espressioni multilinea, devo racchiudere il valore letterale in un metodo (dal momento che ovviamente non riesco a svolgere il compito). L'ultimo loop è più difficile da terminare. Ne ho bisogno per fermarmi a ~. Fortunatamente, dei caratteri ASCII in quell'intervallo, per rilevare quando sono alla fine e interrompere il loop.~ è l'unico che può essere chiamato su un Fixnum senza argomenti senza generare un errore, quindi posso usarlo send chr

Non è il miglior punteggio in questa discussione, ma finora l'unico che usa la stessa lingua per entrambe le parti. Yay Ruby.

Parte 2 in Applescript, 654

aspetta ... dov'è la pagina " suggerimenti per giocare a golf in 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

Produzione:

CJam + AlphaBeta , 62 byte

Lettere, CJam , 12 byte

"[{"{,-26>}/

Provalo online!

Produzione

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Come funziona

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

Simboli, AlphaBeta , 50 byte

ZaaAccctFUaCLOrEbbCLbCLbCLbCLdddACLbCLbCLgDLgDLgDL

Provalo online!

L'interprete ufficiale C ++ ha un bug che rende impossibili i loop e non riesco a capire come usare l'interprete Lua. Ho corretto quel bug. È possibile verificare che funzioni come previsto eseguendo i programmi di esempio dalla pagina EsoLang.

Produzione

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

Come funziona

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 in BrainFuck: 80 74 byte

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

Totale 318 byte

Speravo davvero di trovare una risposta con entrambi i programmi nella stessa lingua, ma finora niente. Ecco invece questo:

Parte 1: bash puro, 129 byte

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

Produzione:

$ ./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 cc, 189 byte

zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzzzzzzzzzzzzzzzzzzzzzzzzzzzPzzPzzPzzPzzPzzPzzBDPBEdPBFPdkvZP

Produzione:

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

Beh, sai, qualcuno dovrebbe farlo andare avanti.

Parte 1 in BrainFuck: 174 byte

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

Parte 1: Ruby, 45 byte

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

Spiegazione

• Un intervallo contenente az ( ?@...?[) e un intervallo contenente AZ ( ?`...?{) diventano gli elementi dell'array_ usando l'operatore splat (* ).
• Il 0 ° elemento ( "@") e il 27 ° elemento ( "`") dell'array _sono impostati su nil.
• La matrice _viene unita usando Array#*e stampata su stdout ( $>)