Imprima todos los caracteres alfanuméricos ASCII sin usarlos

51

Desafío

Imprima los siguientes caracteres:

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890

El problema es que no puede usar ninguno de ellos en su código.

Puede imprimirlos en orden arbitrario, con o sin una nueva línea inicial o posterior, pero no puede imprimir ningún otro carácter.

Reglas

  • No puede usar ningún personaje del conjunto mencionado anteriormente
  • Puedes usar cualquier otro personaje
  • Sin trampa
  • Lagunas estándar prohibidas
  • Este es el , gana la respuesta más corta.

Aclaraciones

  • Si su idioma usa un juego de caracteres diferente, no puede usar puntos de código en ese juego de caracteres que correspondan a caracteres alfanuméricos.
  • Devolver una cadena de una función se considera una forma válida de salida.
  • Puede devolver una matriz de caracteres.
dkudriavtsev
fuente
8
Esto es algo ambiguo. Si te refieres a la salida de esos bytes sin esos bytes en tu código, entonces debes especificar que no puedes usar los puntos de código de estos caracteres, incluso si se asignan a otra cosa en la página de códigos de tu idioma.
FlipTack
11
Así que esto significa que no puedo usar cualquier letras o números en mi código fuente. Bueno, eso prácticamente elimina cualquier lenguaje no esotérico.
R. Kap
2
¿Qué sucede si el idioma son solo bytes sin procesar (como códigos de operación) que no tienen una representación? ¿Soy libre de usar algún personaje?
FlipTack
1
@briantist está bien si están representados internamente por ints, pero los caracteres en sí tienen que imprimirse.
dkudriavtsev
3
@ R.Kap Javascript podría funcionar, siempre que no lo pienses como eso
Destructible Lemon

Respuestas:

19

V , 8 7 bytes

1 byte guardado gracias a @DJMcMayhem al ponerlo todo en una declaración regex

¬/{Ó×ü_

Pruébalo en línea!

Salidas:

0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Nota: no× es o es xX0xd7

Hexdump:

00000000: ac2f 7bd3 d7fc 5f                        ./{..._

Explicación

¬/{            " inserts every character in the range / to {

Ahora la salida se ve así:

/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{

Tenemos que eliminar todos los caracteres no alfanuméricos y el _(ya que no está incluido en \W), así que hagámoslo usando expresiones regulares

Ó×ü_           " removes every character that is non-alphanumeric or an underscore _ 
               " vim equivalent of :s/\W\|_//g
Kritixi Lithos
fuente
¡Asombroso! +1 por vencerme. :) Además, podría simplificarlo a una expresión regular si lo hiciera Ó×ü_(que es equivalente a :s/\W\|_//g)
DJMcMayhem
50

Octava , 52 46 40 bytes

['['-('"':'+'),'{'-(_='!':':'),_+'@','']

Esto evalúa a

9876543210ZYXWVUTSRQPONMLKJIHGFEDCBAabcdefghijklmnopqrstuvwxyz

Explicación

Aquí estamos usando el hecho de que los caracteres se convierten implícitamente en enteros cuando se aplican operaciones aritméticas como +-o la función de rango :. Cuando se concatenan con una cadena vacía ( [...,'']), los números nuevamente se convierten en caracteres.

Pruébalo en línea!

falla
fuente
77
+1por ser el primer lenguaje no esotérico en un desafío muy adecuado para esolangs.
DJMcMayhem
44
¡Grande +1, no para usar Octave (es bastante sencillo), sino para jugar al golf muy bien y usar _como variable! No tenía idea de que era posible ... ¡Genial!
Stewie Griffin
1
Cuando se concatenan con una cadena vacía ([..., '']), los números nuevamente se convierten en caracteres ... muy agradable
rahnema1
29

brainfuck , 77 76 75 72 bytes

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

Pruébalo en línea!

Cómo funciona

El intérprete comienza con una cinta de 0 celdas.

++++++++

Esto establece la primera celda en 8 , dejando la cinta en el siguiente estado.

   8
   ^
[>+>++++++>++++>-<<<<-]

Esto incrementa la segunda celda una vez, la tercera celda 6 veces, la cuarta celda 4 veces, disminuye la quinta celda una vez, luego regresa al comienzo de la cinta y disminuye la primera celda. Después de 8 iteraciones, la cinta se ve como sigue.

  0   8  48  32  -8
  ^
>++

Avanzamos a la segunda celda y la incrementamos dos veces, preparándonos para imprimir los dígitos.

  0  10  48  32  -8
      ^
[>.+<-]

Esto imprime la tercera celda, la incrementa, luego regresa a la segunda celda y la disminuye. Después de 10 iteraciones, hemos impreso 0123456789y la cinta se ve de la siguiente manera.

  0   0  58  32  -8
      ^
>>

¡Es hora de preparar la cinta para las letras! Comenzamos avanzando dos celdas.

  0   0  58  32  -8   0   0
              ^
[>+>++>+++<<<-]

Esto incrementa la quinta celda una vez, la sexta celda dos veces, la séptima celda tres veces, luego regresa a la cuarta celda y la disminuye. Después de 32 iteraciones, la cinta se ve como sigue.

  0   0  58   0  24  64  96
              ^
>++

Como último paso antes de imprimir las letras, avanzamos a la quinta celda y la incrementamos dos veces.

  0   0  58   0  26  64  96
                  ^
[>+.>+.<<-]

Finalmente, avanzamos a la sexta celda para incrementarlo e imprimirlo, hacer lo mismo para la séptima celda, luego volver a la quinta celda y disminuirlo. Después de 26 iteraciones, hemos impreso Aa...Zz.

Dennis
fuente
Buen golf! Voy a vincular a su respuesta
FlipTack
25

Ruby, 42 bytes

->{[*?/...?:,*?@...?[,*?`...?{]-[?/,?@,?`]}

Una función que devuelve una matriz de caracteres. Un programa que genera solo los caracteres tiene 49 bytes:

$><<([*?/...?:,*?@...?[,*?`...?{]-[?/,?@,?`])*''

Esto simplemente usa los caracteres ascii a cada lado de los rangos relevantes para definir un rango. Por ejemplo, ?/...?:significa los caracteres entre una barra diagonal y dos puntos, excluyendo el final. Para deshacernos de los comienzos, restamos una matriz que contiene los tres caracteres iniciales.

histocrat
fuente
Buen trabajo. Vi esto justo cuando vine a publicar mi versión de 60 bytes usando la misma idea.
AShelly
3
Puede guardar un byte con rangos ligeramente diferentes: $> << ([ (? / ...? {)] - [* (?: ..? @), * (? [..? `),? / ]) ''
AShelly
Esto realmente es bonito. Bueno, feo. Sabes a lo que me refiero. Bien hecho.
Wayne Conrad el
22

6502 lenguaje máquina, 74 70 68 bytes

Volcado hexadecimal (los programas 6502 generalmente no son reubicables; el código aquí se almacena a partir de la ubicación $ 0603):

0600:          a9 24 0a 8d 20 06 8d 21 06 8d 23 06 8d 
0610: 25 06 09 20 8d 1a 06 8d 1c 06 ea aa ea a8 a9 00 
0620: ea ea 98 ea 8a ea a2 ff a9 7b a0 60 20 3a 06 a9 
0630: 5b a0 40 20 3a 06 a9 3a a0 2f 85 80 c8 e8 98 95 
0640: 00 c8 c4 80 d0 f7 60

Puede ver que esto no usa ninguno de los bytes prohibidos: $ 41 a $ 5a, $ 61 a $ 7a o $ 30 a $ 39.

Esta es una función sin argumentos que, cuando se llama, devuelve un puntero a la matriz de caracteres "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" en la parte superior de la pila, de acuerdo con las convenciones de llamadas estándar 6502.

A modo de explicación, aquí hay un desmontaje:

Dirección Desmontaje Hexdump
-------------------------------
$ 0603 a9 24 LDA # $ 24
$ 0605 0a ASL A
$ 0606 8d 20 06 STA $ 0620
$ 0609 8d 21 06 STA $ 0621
$ 060c 8d 23 06 STA $ 0623
$ 060f 8d 25 06 STA $ 0625
$ 0612 09 20 ORA # $ 20
$ 0614 8d 1a 06 STA $ 061a
$ 0617 8d 1c 06 STA $ 061c
$ 061a ea NOP 
$ 061b aa IMPUESTO 
$ 061c ea NOP 
$ 061d a8 TAY 
$ 061e a9 00 LDA # $ 00
$ 0620 ea NOP 
$ 0621 ea NOP 
$ 0622 98 TYA 
$ 0623 ea NOP 
$ 0624 8a TXA 
$ 0625 ea NOP 
$ 0626 a2 ff LDX # $ ff
$ 0628 a9 7b LDA # $ 7b
$ 062a a0 60 LDY # $ 60
$ 062c 20 3a 06 JSR $ 063a
$ 062f a9 5b LDA # $ 5b
$ 0631 a0 40 LDY # $ 40
$ 0633 20 3a 06 JSR $ 063a
$ 0636 a9 3a LDA # $ 3a
$ 0638 a0 2f LDY # $ 2f
$ 063a 85 80 STA $ 80
$ 063c c8 INY 
$ 063d e8 INX 
$ 063e 98 TYA 
$ 063f 95 00 STA $ 00, X
$ 0641 c8 INY 
$ 0642 c4 80 CPY $ 80
$ 0644 d0 f7 BNE $ 063d
$ 0646 60 RTS

El código del lenguaje de máquina se auto modifica. Para la manipulación de la pila, necesitaba usar PHA y PLA para empujar y hacer estallar el acumulador, pero estas instrucciones tienen códigos de operación $ 48 y $ 68, que están prohibidos (son los códigos ASCII para las letras 'H' y 'h'). Entonces, para PHA, tomo el número $ 24, hago un cambio aritmético a la izquierda (ASL) y almaceno los $ 48 resultantes en los cuatro puntos en el código donde debe ejecutarse. Luego, para PLA, uso un OR bit a bit en los $ 48 en el acumulador para calcular $ 68, y lo guardo en los dos puntos del código donde es necesario.

Hubo varias instrucciones además de PHA y PLA que tampoco pude usar porque sus códigos de operación son los mismos que las letras o dígitos ASCII, pero encontré soluciones directas para esos otros.

La matriz de caracteres deseada se calcula y almacena a partir de la ubicación 0 (realmente no importa dónde esté almacenada, ya que solo debemos asegurarnos de que un puntero a ella se devuelva en la parte superior de la pila).

Puede probar esto en el ensamblador y emulador 6502 de Nick Morgan . Aquí hay una captura de pantalla; el cuadro del monitor en la parte inferior muestra la cadena de salida (en ubicaciones de $ 00 a $ 3D) después de ejecutar el programa.

Mitchell Spector
fuente
16

Haskell , 75 72 63 58 56 bytes

__=[__|[_',ä]<-["/:","@[","`{"],__<-[_'..],_'<__,__<ä]

Pruébalo en línea! Llamada con __. Salida:

0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Gracias a xnor que sugirió __y _'como nombres de variables de dos bytes en lugar de (!)o similares, ahorrando 9 bytes. Me gusta especialmente cómo se _'rompe el resaltado de sintaxis. Y gracias nuevamente a xnor por generalizar los rangos, ahorrando otros 4 bytes.
Editar: descubrí que caracteres Unicode se permiten como identificadores en Haskell, así por ejemplo ä, ö, ... También puede ser utilizado como dos identificadores de bytes. Como quedaba un identificador de tres bytes en el programa, lo reemplacé ä, guardando otros 2 bytes.

Explicación:

__y _'son nombres de variables válidos. De la especificación del lenguaje :

Un identificador consiste en una letra seguida de cero o más letras, dígitos, guiones bajos y comillas simples. [...] El subrayado, _se trata como una letra minúscula y puede aparecer donde sea que pueda hacerlo una letra minúscula. Sin embargo, _por sí solo es un identificador reservado, utilizado como comodín en los patrones.

Entonces el código es equivalente a

s = [x|[a,b]<-["/:", "@[", "`{"], x<-[a..], a<x, x<b]

En la lista, la comprensión ase une a '/'y bpara ':'( "/:"es equivalente a ['/',':'], por lo que la coincidencia de patrones tiene éxito). Luego, el rango [a..]construye la cadena de todos los caracteres mayor igual '/':

"/0123456789:;<=>?@ABCDE ... \1114110\1114111"

Para cada carácter xen esta cadena, se verifica si '/'<xy x<':', lo que da como resultado los caracteres 0123456789. Entonces ay bestán obligados a @ y [, produciendo los caracteres ABCDEFGHIJKLMNOPQRSTUVWXYZy así sucesivamente.

Laikoni
fuente
3
Puedes usar __y _'como variables.
xnor
@xnor Gracias, no sabía sobre la Underscore is treated as a lower-case letterregla.
Laikoni
1
Puede guardar algunos bytes generalizando los rangos: _'_=[__|[_',__']<-["`{","@[","/:"],__<-[_'..],_'<__,__<__'](en variables normales z=[x|[a,b]<-["`{","@[","/:"],x<-[a..],a<x,x<b]).
xnor
@xnor Gracias de nuevo! Gran idea para combinar el inicio y el final de los rangos en una cadena. También intenté generalizar los rangos, pero siempre terminé más tiempo sin esta idea. Se puede guardar un byte adicional al vincular la cadena en __lugar de _'_ aunque __se utilice como identificador dentro de la comprensión de la lista.
Laikoni
13

Perl (5.10 o 5.12), 30 29 bytes

Este programa consiste principalmente en caracteres no imprimibles, así que aquí hay un hexdump:

00000000: 5f 3d 7e 7e 22 d7 c0 84 8c 9e 86 df 9e d1 d1 85 _=~~"...........
00000010: d3 be d1 d1 a5 d3 cf d1 d1 c6 82 d6 22          ............"

Este programa es muy simple: estamos regexing ( =~) un guión bajo ( _; gracias @Dennis por señalar que esto funciona) contra una regex. La expresión regular se especifica como una expresión, en lugar de literalmente; específicamente, estamos tomando el complemento bit a bit ( ~) de una cadena. Al invertir el complemento a nivel de bits para llegar a la cadena subyacente, obtenemos la siguiente expresión regular que se está ejecutando:

(?{say a..z,A..Z,0..9})

En las versiones 5.10 y 5.12 de Perl, la (?{…})sintaxis era una sintaxis experimental para permitir que las expresiones regulares ejecutaran código arbitrario en tiempo de ejecución. En este caso, lo usamos para ejecutar un programa sencillo de Perl para imprimir la salida deseada. (Las versiones anteriores a 5.10 no se pueden usar porque no tienen say).

Las versiones modernas de Perl se han deshabilitado (?{…})de forma predeterminada por razones de seguridad, pero si tiene una versión de Perl de este tipo, puede deshabilitar la verificación (y, por lo tanto, ejecutar este programa) mediante -Mre=evalun argumento de línea de comandos (junto con el estándar -M5.010que especifica la versión del lenguaje a implementar, y que no cuenta contra el bytecount).


fuente
13

En realidad 8 5 4 bytes

'>┘▀

Cómo funciona:

 '>    Pushes > onto the stack as a string
           STACK: [>]
    ┘  Converts the top item of the stack to it's ordinal
           STACK: [62]
     ▀ Push all digits from base n(top item of the stack)
           STACK: [012...xyz]

La impresión está implícita al final del programa.

Edición 1: se reemplazó poniendo el alfabeto en minúsculas / mayúsculas y luego el rango de números (10) con solo obtener los caracteres imprimibles de la base 62.

Edición 2: cambió ">" a '> gracias a Mego :) guardado 1 byte.

Pruébalo en línea!

Pelícano verde azulado
fuente
'>es un byte más corto que ">".
Mego
@Mego sí, editado :) gracias.
Teal pelican
11

PHP, 69 bytes

<?=~"ÏÎÍÌËÊÉÈÇƾ½¼»º¹¸·¶µ´³²±°¯®­¬«ª©¨§¦¥žœ›š™˜—–•”“’‘ŽŒ‹Š‰ˆ‡†…";

El código está estilizado usando Windows-1252 aquí. A continuación se muestra un xdux hexdump reversible .

00000000: 3c 3f 3d 7e 22 cf ce cd cc cb ca c9 c8 c7 c6 be  <?=~"...........
00000010: bd bc bb ba b9 b8 b7 b6 b5 b4 b3 b2 b1 b0 af ae  ................
00000020: ad ac ab aa a9 a8 a7 a6 a5 9e 9d 9c 9b 9a 99 98  ................
00000030: 97 96 95 94 93 92 91 90 8f 8e 8d 8c 8b 8a 89 88  ................
00000040: 87 86 85 22 3b                                   ...";

Pruébalo en línea!

Dennis
fuente
10

Java (OpenJDK 9) , 277 bytes

Sí, Java, ¡lo leíste bien!

$->""+($='='+'=')+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+($='-'+'-')+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+($='_'-'&')+--$+--$+--$+--$+--$+--$+--$+--$+--$

Pruébalo en línea!

Esto imprime los rangos, pero se invierte, ya que el orden no tiene importancia.

zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDCBA9876543210

Jugué con la ausencia de la regla "sin entrada" para definir implícitamente una charque se requiere para que todo funcione. Si eso es trampa, por favor dilo.

Sin golf y pruebas

public class PCG105781 {
  interface X { String apply(char x); }

  public static void main(String[] args) {
    X x = $
        -> "" // Force the result as a String.
        // The line below appends "zyxwvutsrqponmlkjihgfedcba"
        // '=' + '=' is 122 as int. $=122 casts 122 as a char, 'z'
        + ($ = '=' + '=') + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$
        // The line below appends "ZYXWVUTSRQPONMLKJIHGFEDCBA"
        // '-' + '-' is 90 as int. $=90 casts 90 as a char, 'Z'
        + ($ = '-' + '-') + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$
        // The line below appends "9876543210"
        // '_' - '&' is 57 as int. $=57 casts 57 as a char, '9'
        + ($ = '_' - '&') + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$
      ;

    System.out.println(x.apply('_'));
  }
}
Olivier Grégoire
fuente
3
¿¿Esperar lo?? Soy pequeño que todas las soluciones de JavaScript? o_O
Olivier Grégoire
Eso es porque JavaScript no tiene char, de lo contrario sería pan comido. Y para ser justos, mi respuesta es más corta que su respuesta inicial. Echa un vistazo a mi explicación de todos los gastos generales que tengo que pasar.
Patrick Roberts el
2
@PatrickRoberts Para ser justos, debemos comparar la edición inicial con la edición inicial o la última edición con la última edición, no la edición inicial con la última ...;) Leí cuidadosamente lo que se hizo para JavaScript, especialmente porque no entendía cómo podía obtenga una respuesta más corta que todas las JS.
Olivier Grégoire
9

Brainfuck, 89 85 bytes

Debido a que Brainfuck ignora los caracteres alfanuméricos de todos modos, esto es solo un desafío de salida constante ... (Editar: vea la solución de Dennis para una versión que es 10 bytes más corta)

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

Pruébalo en línea!

Este código es un buen ejemplo de bucles contados básicos en brainfuck:

+[-[--<]>>--]   Create value 47: char just before '0'
++++++++++      Set adjacent cell to 10: to be used as a counter

[               While the counter is not 0:
 <+.              Increment and print the char
    >-            Decrement the counter
       ]        (End loop: Exits when all digits have been printed)


<++++++++>           The char is now at '9' so add 8 to make it 'A'
+[-[---<]>>-]<-      In another cell create lowercase 'a'
<<+++++[>+++++<-]>+  Create 26: the number of times to loop

[                While the counter is not 0:
 >.+               Print and increment the lowercase char
    <<<.+          Print and increment the uppercase char
         >>-       Decrement the counter
            ]    (End loop: Exits when all letters have been printed)

Tenga en cuenta que esto utiliza accesos directos de ajuste para generar números, lo que significa que el intérprete necesita tener celdas de ajuste de 8 bits (como la que he vinculado).

FlipTack
fuente
55
Brainfuck fue el primer idioma que pensé. Es una pena no lo sé. Buena respuesta.
ElPedro
7

JavaScript (ES6), 983 bytes

Resulta que en ES6 hay muchos caracteres que puedes usar en los nombres de variables de JavaScript . Funciona muy bien después de agotar los seis nombres de variables de 1-2 bytes con $y _.

_=~[]
$={}
Á=++_
À=![]+""
Â=À[_]
Ã=++_
Ä=À[_]
Å=++_
Æ=($+"")[_]
Ç=(_[_]+"")[_]
È=++_
É=(!""+"")[_]
Ë=++_
Ì=++_
Ê=($+"")[_]
Í=++_
µ=++_
Î=++_
Ï=++_
_="\\"
Ð=$.$
È_=(!""+"")[Ã]
Å_=$+""
Ñ=Å_[Ã]
Ò=(Ð+"")[Ã]
__=Å_[Í]
Ó=(!""+"")[Å]
$_=Å_[Ì]+Ñ+Ò+(!$+"")[È]+__+È_+Ó+Å_[Ì]+__+Ñ+È_
$$=È_+(!""+"")[È]+__+Ó+È_+Ò
$=Á[$_][$_]
$($($$+"\""+Ê+Ñ+_+Ã+Ì+Í+_+Ã+Í+È+Ñ+À[Å]+É+"."+À[Å]+Ñ+_+Ã+Ë+µ+"('"+Ä+Æ+Ê+Ç+É+Â+_+Ã+Ë+µ+_+Ã+Ì+Á+_+Ã+Ì+Ã+_+Ã+Ì+Å+_+Ã+Ì+È+À[Å]+_+Ã+Ì+Ì+_+Ã+Ì+Í+Ñ+_+Ã+Í+Á+_+Ã+Í+Ã+_+Ã+Í+Å+_+Ã+Í+È+__+Ó+_+Ã+Í+Í+_+Ã+Í+µ+_+Ã+µ+Á+_+Ã+µ+Ã+_+Ã+µ+Å+_+Ã+Á+Ã+_+Ã+Á+Å+_+Ã+Á+È+_+Ã+Á+Ë+_+Ã+Á+Ì+_+Ã+Á+Í+_+Ã+Á+µ+_+Ã+Ã+Á+_+Ã+Ã+Ã+_+Ã+Ã+Å+_+Ã+Ã+È+_+Ã+Ã+Ë+_+Ã+Ã+Ì+_+Ã+Ã+Í+_+Ã+Ã+µ+_+Ã+Å+Á+_+Ã+Å+Ã+_+Ã+Å+Å+_+Ã+Å+È+_+Ã+Å+Ë+_+Ã+Å+Ì+_+Ã+Å+Í+_+Ã+Å+µ+_+Ã+È+Á+_+Ã+È+Ã+_+Ã+È+Å+Ã+Å+È+Ë+Ì+Í+µ+Î+Ï+Á+"')\"")())()

JavaScript, 1223 bytes

Esta fue mi respuesta antes de conocer lo anterior.

_=~[]
$={}
___=++_
____=![]+""
$$$$=____[_]
__$=++_
$_$_=____[_]
_$_=++_
$_$$=($+"")[_]
$$_$=(_[_]+"")[_]
_$$=++_
$$$_=(!""+"")[_]
$__=++_
$_$=++_
$$__=($+"")[_]
$$_=++_
$$$=++_
$___=++_
$__$=++_
_="\\"
_$_$=$.$
_$$_=(!""+"")[__$]
_$__=$+""
_$=_$__[__$]
__$_=(_$_$+"")[__$]
__=_$__[$$_]
___$=(!""+"")[_$_]
$_=_$__[$_$]+_$+__$_+(!$+"")[_$$]+__+_$$_+___$+_$__[$_$]+__+_$+_$$_
$$=_$$_+(!""+"")[_$$]+__+___$+_$$_+__$_
$=___[$_][$_]
$($($$+"\""+$$__+_$+_+__$+$_$+$$_+_+__$+$$_+_$$+_$+____[_$_]+$$$_+"."+____[_$_]+_$+_+__$+$__+$$$+"('"+$_$_+$_$$+$$__+$$_$+$$$_+$$$$+_+__$+$__+$$$+_+__$+$_$+___+_+__$+$_$+__$+_+__$+$_$+_$_+_+__$+$_$+_$$+____[_$_]+_+__$+$_$+$_$+_+__$+$_$+$$_+_$+_+__$+$$_+___+_+__$+$$_+__$+_+__$+$$_+_$_+_+__$+$$_+_$$+__+___$+_+__$+$$_+$$_+_+__$+$$_+$$$+_+__$+$$$+___+_+__$+$$$+__$+_+__$+$$$+_$_+_+__$+___+__$+_+__$+___+_$_+_+__$+___+_$$+_+__$+___+$__+_+__$+___+$_$+_+__$+___+$$_+_+__$+___+$$$+_+__$+__$+___+_+__$+__$+__$+_+__$+__$+_$_+_+__$+__$+_$$+_+__$+__$+$__+_+__$+__$+$_$+_+__$+__$+$$_+_+__$+__$+$$$+_+__$+_$_+___+_+__$+_$_+__$+_+__$+_$_+_$_+_+__$+_$_+_$$+_+__$+_$_+$__+_+__$+_$_+$_$+_+__$+_$_+$$_+_+__$+_$_+$$$+_+__$+_$$+___+_+__$+_$$+__$+_+__$+_$$+_$_+__$+_$_+_$$+$__+$_$+$$_+$$$+$___+$__$+___+"')\"")())()

Corrí a console.log('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890')través de jjencode y jugué el resultado manualmente. Definitivamente hay más optimizaciones que se pueden hacer.

Darrylyeo
fuente
Oye, para tu información, publiqué codegolf.stackexchange.com/a/105854/42091 porque trabajé mucho y creo que es lo suficientemente diferente de tu respuesta.
Patrick Roberts
No hay problema, se ve bien!
darrylyeo
¡Agradable! ¡Esa última actualización me ayudó a obtener más de 100 bytes del mío!
Patrick Roberts el
1
Si cambia su codificación a ISO8859-1, y la deja exactamente así, será de 769 bytes.
Patrick Roberts el
7

Befunge, 73 72 59 57 55 53 bytes

"{"< ^+`"`"\+*`\":"\`"/":\*`\"["\`"@":::::-!!
#@_^,_!

Pruébalo en línea!

Este es un solo ciclo de cuenta atrás desde {(es decir, un carácter después z) En la primera iteración, la "{"<secuencia empuja dos copias de {la pila: una es el contador de bucle inicial y la otra se usa para disminuir ese contador usando la secuencia !!-(dos NOTs 1que luego se restan). En iteraciones posteriores, el contador de bucle ya está en la pila, por lo que solo {se necesita uno para configurar la secuencia de disminución.

El resto del código es solo una expresión booleana larga que calcula si el carácter está dentro del rango. Si es así, la rama en la segunda línea se divide a la izquierda para escribir el valor. Si no, la rama derecha se ajusta para probar si hemos llegado a cero y debería terminar. Las dos ramas se fusionan en el medio para subir y repetir el ciclo. Tenga en cuenta que todos los comandos de dirección vertical van hacia arriba, ya que no podemos usar a v, pero eso está bien porque el puntero de instrucción se ajusta automáticamente en la parte superior del campo de juego.

Gracias a Mistah Figgins por haber ideado inicialmente una mejor técnica para el incremento de bucle.

Pero gracias especiales a Jo King por un enfoque aún mejor para la cuenta atrás en lugar de hacia arriba, así como un diseño de rama más compacto.

James Holderness
fuente
1
Si no hay nada más que el contador en la pila, puede cambiar su parte de incremento a \! + Si lo hay, puede hacer: !! +. para valores distintos de cero
MildlyMilquetoast
-2 bytes reorganizando el cheque al comienzo de la línea
Jo King
@JoKing Bien visto. No podemos usar el vya que es de fuente restringida, pero aún funciona igual de bien con a ^. Gracias.
James Holderness
-2 bytes contando hacia atrás en lugar de hacia arriba, y usando la copia adicional del contador en la segunda línea para verificar si el ciclo ha terminado (recordado sobre la fuente restringida esta vez;))
Jo King
@JoKing Wow, ¡realmente eres mucho mejor en este golf que yo! Gracias de nuevo.
James Holderness
6

Jalea , 17 16 bytes

“:[{“/@`‘Ḷḟ"/ỌḊ€

Pruébalo en línea!

Cómo funciona

“:[{“/@`‘Ḷḟ"/ỌḊ€  Main link. No arguments.

“:[{“/@`‘         Yield [[58, 91, 123], [47, 64, 96]].
         Ḷ        Unlength; map each n to [0, ..., n-1].
          ḟ"/     Reduce by vectorizing filter-false.
                  This yields [[47, ..., 57], [64, ..., 90], [96, ..., 122]].
             Ọ    Unordinal; replace each n with the corr. Unicode character.
              Ḋ€  Deqeue each; remove the first character of each of the three
                  generated strings ('/', '@', and '`').
Dennis
fuente
Debido a que jelly tiene su propia página de códigos, sería útil si adjuntara un volcado hexadecimal, para verificar fácilmente que no está utilizando los bytes prohibidos
FlipTack
La página de códigos de @FlipTack IIRC Jelly es compatible con ASCII imprimible.
PurkkaKoodari
@FlipTack Pietu1998 tiene razón. E incluso si no fuera así, la especificación prohíbe los caracteres, no los bytes.
Dennis
@Dennis De hecho, prohíbe los bytes por los comentarios , aunque esto todavía es válido (compatible con ASCII).
Erik the Outgolfer
6

Brainfuck auto modificable , 32 bytes

<[-<+.>]<<[-<+.>]<<[-<+.>]`@/

Pruébalo en línea!

xxd -rhexdump reversible (contiene no imprimibles):

00000000: 3c5b 2d3c 2b2e 3e5d 3c3c 5b2d 3c2b 2e3e  <[-<+.>]<<[-<+.>
00000010: 5d3c 3c5b 2d3c 2b2e 3e5d 601a 401a 2f0a  ]<<[-<+.>]`.@./.
Erik el Outgolfer
fuente
¿Qué hace el @/?
Yytsi
@TuukkaX Los últimos 6 caracteres `\x1a@\x1a/\nestán allí porque sus puntos de código son realmente útiles en el golf. No puedes eliminarlos.
Erik the Outgolfer
@downvoter: Si te topas con esta publicación, elimina tu voto negativo. Esto ha sido arreglado desde entonces.
Erik the Outgolfer
Me alegro de no ser el único que usa SMBF. :)
mbomb007
@ mbomb007 Practicidad :) Estaba pensando en BF, y me vinieron a la mente SMBF, así que tengo listos los puntos de código. La restricción no me costó bytes, como usé en +.lugar de .+.
Erik el Outgolfer
6

C, 128 bytes

Sí, C. E incluso es más corto que algunos de los esotéricos.

__($$,_,$,_$,$_){$>_$?_$=_$?!$:$,$=*(""-_+$_++)&*"{":_;_$?*(""-_+$$++)=$++:_;$&&__($$,_,$,_$,$_);}_(_){__(_,"",_,!!_,"½´ÞÅþå");}

Llame _a un char *búfer vacío suficientemente grande .

Puede ser un pequeño compilador dependiente. Probado con GCC; El archivo se guardó en la página de códigos 1252.

Anónimo
fuente
6

JavaScript (ES6), 812 745 657 650 536 520 416 bytes

(À=(Á=!($={})+(Ø=""))[Â=_=+[]],Ã=(Ä=!_+Ø)[Å=++_],Æ=(Ç=$+Ø)[_],È=(É=$.$+Ø)[_],Ê=Ä[Ë=++_],Ì=Ä[Í=++_],Î=++_,Ï=Ç[Ð=++_],Ñ=Ç[Ò=++_],Ó=++_,$=$[Ô=Ï+Æ+È+Á[Í]+Ñ+Ã+Ê+Ï+Ñ+Æ+Ã][Ô],$($((Õ=Ã+Ä[Í]+Ñ+Ê+Ã+È)+`"${Ù=($=À)+Æ+(Ö=Ô[Ð])}($ ${[Æ+$+"[["+Î+ ++_,Ø+Ð+_+"],["+Ò+Ð,Ø+ ++_+Å+"],["+_+Ó,Ú=Ø+Å+Ë+Í]}]])${Ù}(_=$[Â];_<$[Å];)Ø+=${(_="\\")+Ú+Ñ+Ö+(Û=(_=_+Å)+Ð)+Å+Ô[Ë]+_+Î+Ó}.${$+Ö+Æ+Û+Ð+_+Â+Í+Û+Â+Á[Å]+Ö+_+Â+Í+Æ+É[Ë]+Ì}(_++);${Õ} Ø"`)()))

Editar: con la codificación ISO8859-1, esta solución tiene 416 bytes en lugar de 520 bytes. El programa completo tiene 432 bytes, teniendo en cuenta los 16 bytes adicionales para

f=\r\n
416 byte submission here\r\n
alert(f())

Esta es una presentación de función, a diferencia de un programa completo. Pasé mucho tiempo jugando al golf JJEncode (de punta a punta para darrylyeo por eso), pero en lugar de jugar al golf

console.log('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890')

Yo golf

for($ of[[48,58],[65,91],[97,123]])for(_=$[0];_<$[1];)Ø+=String.fromCharCode(_++);return Ø

donde Øse inicializa ""en la sobrecarga.

Reescrito con operadores de coma convertidos a nuevas líneas:

À=(Á=!($={})+(Ø=""))[Â=_=+[]]
Ã=(Ä=!_+Ø)[Å=++_]
Æ=(Ç=$+Ø)[_]
È=(É=$.$+Ø)[_]
Ê=Ä[Ë=++_]
Ì=Ä[Í=++_]
Î=++_
Ï=Ç[Ð=++_]
Ñ=Ç[Ò=++_]
Ó=++_
$=$[Ô=Ï+Æ+È+Á[Í]+Ñ+Ã+Ê+Ï+Ñ+Æ+Ã][Ô]
// function that returns string
$($((Õ=Ã+Ä[Í]+Ñ+Ê+Ã+È)+`"${Ù=($=À)+Æ+(Ö=Ô[Ð])}($ ${[Æ+$+"[["+Î+ ++_,Ø+Ð+_+"],["+Ò+Ð,Ø+ ++_+Å+"],["+_+Ó,Ú=Ø+Å+Ë+Í]}]])${Ù}(_=$[Â];_<$[Å];)Ø+=${(_="\\")+Ú+Ñ+Ö+(Û=(_=_+Å)+Ð)+Å+Ô[Ë]+_+Î+Ó}.${$+Ö+Æ+Û+Ð+_+Â+Í+Û+Â+Á[Å]+Ö+_+Â+Í+Æ+É[Ë]+Ì}(_++);${Õ} Ø"`)())

Explicación

Este script comienza inicializando algunos tipos incorporados y obligándolos a formar cadenas. Las cadenas que podemos obtener sin usar caracteres alfanuméricos son:

{}+""     -> "[object Object]"
!{}+""    -> "false"
!+[]+""   -> "true"
{}[{}]+"" -> "undefined"

A partir de estas cadenas y los dígitos necesarios para hacer referencia a caracteres individuales, podemos obtener las cadenas returny constructor, que se pueden usar como:

$={}[Ô="constructor"][Ô]
$(("return"+`"encoded script"`)())

Constructor del objeto es Object(), y su constructor es Function(), que podemos utilizar como esencialmente eval().

En este caso, el script codificado que se ejecutará son los forbucles anidados que concatenan todos los caracteres alfanuméricos a una cadena usando sus puntos de código y devolviéndolos.

Para los caracteres alfabéticos en la secuencia de comandos codificada a los que no se puede acceder utilizando los elementos integrados, JJEncode usa escapes octales para representarlos, luego decodifica la cadena completa devolviéndola desde una función interna. Entonces se puede llamar a la función externa para ejecutar la fuente.

Manifestación

f=
(À=(Á=!($={})+(Ø=""))[Â=_=+[]],Ã=(Ä=!_+Ø)[Å=++_],Æ=(Ç=$+Ø)[_],È=(É=$.$+Ø)[_],Ê=Ä[Ë=++_],Ì=Ä[Í=++_],Î=++_,Ï=Ç[Ð=++_],Ñ=Ç[Ò=++_],Ó=++_,$=$[Ô=Ï+Æ+È+Á[Í]+Ñ+Ã+Ê+Ï+Ñ+Æ+Ã][Ô],$($((Õ=Ã+Ä[Í]+Ñ+Ê+Ã+È)+`"${Ù=($=À)+Æ+(Ö=Ô[Ð])}($ ${[Æ+$+"[["+Î+ ++_,Ø+Ð+_+"],["+Ò+Ð,Ø+ ++_+Å+"],["+_+Ó,Ú=Ø+Å+Ë+Í]}]])${Ù}(_=$[Â];_<$[Å];)Ø+=${(_="\\")+Ú+Ñ+Ö+(Û=(_=_+Å)+Ð)+Å+Ô[Ë]+_+Î+Ó}.${$+Ö+Æ+Û+Ð+_+Â+Í+Û+Â+Á[Å]+Ö+_+Â+Í+Æ+É[Ë]+Ì}(_++);${Õ} Ø"`)()))
console.log(f())

Patrick Roberts
fuente
5

Brain-Flak , 171 bytes

Incluye +3 para -A

(((((()()()){}){}){}){})(((()()())){}{}){({}[()]<(({})())>)}{}(({})(()()()()){})(((((()()()){}){}){}())<{({}[()]<(({})())>)}{}(({})(()()()){}())>){({}[()]<(({})())>)}{}

Pruébalo en línea!

(((((()()()){}){}){}){}) # push 48
(((()()())){}{})         # push 9
{({}[()]<                # for 9..0
(({})())                 # pop a, push a, push a+1
>)}{}                    # end for
(({})(()()()()){})       # pop a, push a, push a + 8
(((((()()()){}){}){}())< # push 26 and save a 26 for later
{({}[()]<                # for 26..0
(({})())                 # pop a, push a, push a+1
>)}{}                    # end for
(({})(()()()){}())       # pop a, push a, push a + 7
>)                       # push that 26 that we held
{({}[()]<                # for 26..0
(({})())                 # pop a, push a, push a+1
>)}{}                    # end for

Probablemente haya una manera de hacerlo sin tener que repetir la función "agregar 1".

Riley
fuente
5

Julia 0.4 , 46 bytes

_()=['¥':'®';'¶':'Ï';'Ö':'ï'].-['~'-'	']

Esta es una función genérica que devuelve una matriz de caracteres.

Pruébalo en línea!

Versión alternativa, 47 bytes, solo ASCII

_(_=_==_)=['/'+_:':'-_;'@'+_:'['-_;'`'+_:'{'-_]

Pruébalo en línea!

Dennis
fuente
5

J, 171 bytes

(+:>.+:^^*_){.".(':',~(+:+:>.^*_){(*:>.^*_)!:(+:<.^+:*_)''),',',(":(>:*:+:+:+:*_),(<.^<:^<:^*_),<:*:<.^+:*_),'+/',('.',~(+:<.+:^*_){(*:>.^*_)!:(+:<.^+:*_)''),":+:<.*:>:^*_

Ow ... me duele el cerebro ... ¡ Pruébalo en línea!

Aquí está para que pueda verlo todo en una línea (sin embargo, no se ejecutará con saltos de línea).

(+:>.+:^^*_){.".(':',~(+:+:>.^*_){(*:>.^*_)!:(+:<.^+:*_)''),',',(":(>:*:+:+:+:*_),(<.^<:^<:^*
_),<:*:<.^+:*_),'+/',('.',~(+:<.+:^*_){(*:>.^*_)!:(+:<.^+:*_)''),":+:<.*:>:^*_

Solo se garantiza que funcione con la versión J j805/j64/linux/release/commercial/www.jsoftware.com/2016-12-11T08:02:52, en ese orden. (Solo importan los primeros 12 caracteres).

Explicación

La mayor parte del programa está dedicado a la generación constante. Con esas constantes reemplazadas por sus valores, el programa se ve así:

(62){.".(':',~(12){(9)!:(14)''),',',(":(65),(97),48),'+/',('.',~(10){(9)!:(14)''),":26

Con algunos paréntesis eliminados y algunos números mejorados:

62{.".(':',~12{9!:14''),',',(":65 97 48),'+/',('.',~10{9!:14''),":26

Este se compone de un grupo de ,y ,~s, que de agregación y de argumentos Prefijo. Aquí están los valores separados:

  1. ":26
  2. ('.',~10{9!:14'')
  3. '+/'
  4. (":65 97 48)
  5. ','
  6. (':',~12{9!:14'')

1es 26como una cuerda

9!:14'' genera la siguiente cadena en TIO:

j805/j64/linux/release/commercial/www.jsoftware.com/2016-12-11T08:02:52

con 2, obtenemos el 10carácter th ( ide linux), y agregamos .a al final del mismo, rindiendo i..

3y 5se explican por sí mismos.

4es la lista de números 65 97 48como una cadena.

6es similar a 2, excepto que es el 12carácter th ( ufrom linux) y agrega un :al final, cediendo u:.

Esto, todo junto, rinde u:,65 97 48+/i.26. ".evalúa esto, dándonos:

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789:;<=>?@ABCDEFGHI

(Nota: +/es una adición tabulada).

Luego, con 62{., tomamos los primeros 62personajes de esto, dándonos ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.

Conor O'Brien
fuente
Puede obtener el uso constante de 14 <:<.^^*_que guarda un byte. Además, intenté generar todo el rango y eliminar los símbolos para obtener ':;<=>?@[\]^_`'-.~".(':',~(+:+:>.^*_){(*:>.^*_)!:(<:<.^^*_)''),":(#@}.@}.@}.@,~(+#\)],,~)(*:@#$])'+++++'104 bytes. Estoy seguro de que puede ser mucho más corto
millas del
5

05AB1E , 18 15 11 bytes

-4 gracias a Adnan, porque si el tamaño de entrada es 1, 05AB1E usará 0 para b en el primer comando.

•£•Ýç©á®þ«˜

Pruébalo en línea!

•£•Ÿ            # Push [0..122] using implicit 0 and the base-214 of `£`.
    ç           # Convert to ASCII chars.
     ©          # Store full array in register.
      á         # Push the same array with ONLY letters.
       ®        # Push contents of register (char)[0..122].
        þ       # Push only the digits.
         «˜     # Concat to list, flatten it. 

Intenté muchos enfoques diferentes, pero los puntos clave aquí lo hicieron difícil:

- Basic commands will not work, only extended and a select few of the basics.
- Extended commands are pretty complex.
- Eval (.V) will not work.
- To push numbers you can do a base 214 compression.
- ALL sequence pushes (E.G. žK) won't work.
- ALL number pushes won't work, except for compression and the -1 an empty register pushes.
Urna de pulpo mágico
fuente
1
You may print them in arbitrary orderdice el reto.
AdmBorkBork
1
¿ •£•Ýç©á®þ«˜También funciona?
Adnan
@Adnan agradable, no sabía que usa 0 cuando no hay b.
Urna mágica del pulpo el
5

Brainfuck, 55 bytes

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

Salida:

aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ0123456789

Pruébalo en línea!


Inicializa la cinta a 3 · 2 n , y trabaja desde allí.

+++[[<+>->++<]>]    initialize the tape
                    |   0 |   3 |   6 |  12 |  24 |  48 |  96 | 192 | 128 |   0 |   0 |
                                                                                    ^
<<[-<->]            subract 128 from 192
                    |   0 |   3 |   6 |  12 |  24 |  48 |  96 |  64 |   0 |   0 |   0 |
                                                                        ^
<<<<++              increment 24 twice
                    |   0 |   3 |   6 |  12 |  26 |  48 |  96 |  64 |   0 |   0 |   0 |
                                                ^
[->>+.>+.<<<]       output aAbBcC ~ zZ
                    |   0 |   3 |   6 |  12 |   0 |  48 | 122 |  90 |   0 |   0 |   0 |
                                                ^
<--[->>.+<<]        decrement 12 twice; output 0 ~ 9
                    |   0 |   3 |   6 |   0 |   0 |  58 | 122 |  90 |   0 |   0 |   0 |
                                          ^
primo
fuente
5

Perl 6 , 43 bytes - sin competencia

{|('`'^..^'{'),|('@'^..^'['),|('/'^..^':')}

Una lambda que devuelve una lista de caracteres.
Explicación:

   '`'                                       # The character before "a" (in Unicode order)
          '{'                                # The character after "z"
      ^..^                                   # Endpoint-exclusive range between them
 |(          )                               # Slip the range into the outer list
               |('@'^..^'[')                 # Same thing for "A" to "Z"
                             |('/'^..^':')}  # Same thing for "0" to "9"

Depende de una corrección de errores para el intérprete Rakudo Perl 6 que solo se comprometió con el repositorio de git hoy, y aún no forma parte de un lanzamiento oficial de Rakudo. De hecho, me encontré con el error al responder a este desafío y logré solucionarlo con la ayuda de uno de los desarrolladores principales de Perl 6. Las reglas de este sitio, tal como las entiendo, no permiten que las respuestas compitan en tal situación, por lo que lo marqué como no competitivo.

smls
fuente
41 bytes
Jo King
4

PHP 7.0+, 110 bytes

¡Dios bendiga las cuerdas bit a bit!

<?=($__='`@`@'^'*/).')(($_='->.<:'^'__@[_')('>'^_,'%'^_)),$__($_('|'^'=','|'^'&')),$__($_(':'^"\n",';'^']'^_));

Reemplace el \ncon una nueva línea de estilo * NIX real.
Está presente en el código para evitar problemas con las nuevas líneas, pero no se cuenta en el puntaje.

Esto arroja un montón de advertencias, pero esas podrían suprimirse agregando un @frente a cada parásito _.


Advertencia libre , 113 bytes

<?=($__='`@`@'^'*/).')(($_='->.<:'^'__@[_')('>'^@_,'%'^@_)),$__($_('|'^'=','|'^'&')),$__($_(':'^"\n",';'^']'^@_));
Ismael Miguel
fuente
3

Lenguaje de máquina 65c02 + Apple] [ROM, 25 bytes

A9 E0 20 0F 80 A9 C0 20 0F 80 A2 0A A9 AF 2C A2 1A 1A 20 ED FD CA D0 F9 60

Impresiones abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.

Debería comenzar a las $8000.

Desmontaje

8000-   A9 E1       LDA   #$E0
8002-   20 0F 80    JSR   $800F
8005-   A9 C1       LDA   #$C0
8007-   20 0F 80    JSR   $800F
800A-   A2 0A       LDX   #$0A
800C-   A9 B0       LDA   #$AF
800E-   2C          HEX   2C     ; SKIPS NEXT 2 BYTES
800F-   A2 1A       LDX   #$1A
8011    1A          INC   
8012-   20 ED FD    JSR   $FDED
8015-   CA          DEX   
8016-   D0 F9       BNE   $8011
8018-   60          RTS   
insert_name_here
fuente
Esto viola la regla del punto de código: solo está usando los caracteres en un conjunto de caracteres diferente. Los bytes están bien siempre que no sean iterativos o leídos por el código.
dkudriavtsev
@wat Ah, está bien. He editado mi código para que no utiliza ningún código de máquina bytes que se asignan a caracteres alfanuméricos en ASCII (positivo) "normal" y no utiliza ningún positivo o negativo ASCII alfanuméricos literales ; ¿es válido ahora?
insert_name_here
Supongo que sí... ._.
dkudriavtsev
@wat Los puntos de código en orden ascendente utilizados actualmente son 10, 15, 26, 32, 44, 96, 128, 162, 169, 175, 192, 202, 208, 224, 237, 249, 253, que se asignan a los caracteres ↵.. ,`.¢©¯ÀÊÐàíùýdonde los .s son caracteres no imprimibles. Es válido
Patrick Roberts el
3

bash (en linux), 507 493 490 485 bytes

esto almacena una matriz de caracteres en la variable global __

: {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_
__=(/????/????/??/??)
___=${__%??}
__=(${__[@]#$___?})
____=${___#/*/?}
____=${____%?/*/}
_____=${____%?}
____=${____#?}
___=${___%??/}
______=($___*_??)
______=${______#$___???????}
______=${______%??_*}
_______=($___$_____???*)
_______=${_______#$___??}
_______=${_______%????}
___=$#
___=$((++___))$((___+++++___+___--))$___
$_____$_______$______$____{,} ___="\({$______..$'\\$___'}\)"
__=(${__[@]} ${___[@]} ${___[@]^})

debe ejecutarse en una máquina Linux recién iniciada con /proc, o algo así como un espacio de nombres pid

explicación:

# {var}>file opens a file descriptor >= 10 to that file
: {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_
# at startup no pid is > 999 so there's no other /proc/pid/fd/??
__=(/????/????/??/??)                                 # /proc/self/fd/1[0-9]
___=${__%??}                                          # /proc/self/fd/
__=(${__[@]#$___?})                                   # {0..9}
____=${___#/*/?}                                      # elf/fd/
____=${____%?/*/}                                     # el
_____=${____%?}                                       # e
____=${____#?}                                        # l
___=${___%??/}                                        # /proc/self/
______=($___*_??)                                     # /proc/self/timerslack_ns
______=${______#$___???????}                          # ack_ns
______=${______%??_*}                                 # a
_______=($___$_____???*)                              # /proc/self/environ
_______=${_______#$___??}                             # viron
_______=${_______%????}                               # v

___=$#                                                # 0
___=$((++___))$((___+++++___+___--))$___              # 172 (z in octal)

# eval eval                   ___="\({a..$'\172'}\)"
$_____$_______$______$____{,} ___="\({$______..$'\\$___'}\)"
#   {0..9}   {a..z}    {A..Z}
__=(${__[@]} ${___[@]} ${___[@]^})

para probarlo podemos agregar declare -p __al final para mostrar el resultado

$ sudo unshare --fork --pid --mount-proc bash golf
declare -a __=([0]="0" [1]="1" [2]="2" [3]="3" [4]="4" [5]="5" [6]="6" [7]="7" [8]="8" [9]="9" [10]="a" [11]="b" [12]="c" [13]="d" [14]="e" [15]="f" [16]="g" [17]="h" [18]="i" [19]="j" [20]="k" [21]="l" [22]="m" [23]="n" [24]="o" [25]="p" [26]="q" [27]="r" [28]="s" [29]="t" [30]="u" [31]="v" [32]="w" [33]="x" [34]="y" [35]="z" [36]="A" [37]="B" [38]="C" [39]="D" [40]="E" [41]="F" [42]="G" [43]="H" [44]="I" [45]="J" [46]="K" [47]="L" [48]="M" [49]="N" [50]="O" [51]="P" [52]="Q" [53]="R" [54]="S" [55]="T" [56]="U" [57]="V" [58]="W" [59]="X" [60]="Y" [61]="Z")
izabera
fuente
+1. Creo que debería indicar esto como Bash en Linux como otros sistemas operativos (por ejemplo, MacOS) no tienen /proc. De hecho, /procno es estrictamente necesario en Linux, aunque probablemente sería difícil encontrar una distribución moderna sin ella.
Trauma digital
3

Javascript, 1273 1351 1610 bytes

Esta solución funciona esencialmente de la misma manera que las otras dos respuestas en este hilo aquí y aquí , donde utiliza cartas de los true, false, undefined, y [object Object]cuerdas para construir las funciones que necesita para generar las otras letras.

Dado que un buen número de las letras ya están colocadas en el objeto, intenté agregar todas las letras minúsculas y los números restantes al objeto, y luego apliqué toUpperCasea todos los valores en el objeto para generar las letras mayúsculas faltantes.

Actualizar:

Pude mejorar la forma en que se establecían los valores octales, pero todavía ocupan 13 x 30 bytes (o serán 30 bytes cada uno después de cambiar los números a diferentes claves), cada uno ahora sigue este general patrón: $.ž=\'\\'+$.一+$.七+$.二+'\';.

Se pueden extraer fácilmente 49 bytes adicionales cambiando las teclas de los números a caracteres de 2 bytes.

Presentación actual:

$=~[];_={ť:!""+"",ň:![]+"",û:$._+'',ô:{}+"",ø:''};$={零:++$,ƒ:_.ň[$],ť:_.ť[$],一:++$,â:_.ň[$],ř:_.ť[$],ô:_.ô[$],ň:_.û[$],二:++$,ľ:_.ň[$],û:_.ť[$],ƅ:_.ô[$],ď:_.û[$],三:++$,ŝ:_.ň[$],ĵ:_.ô[$],四:++$,ě:_.ň[$],五:++$,ĉ:_.ô[$],î:_.û[$],六:++$,七:++$,八:++$,Ô:_.ô[$],九:++$};_.ĉ=$.ĉ+$.ô+$.ň+$.ŝ+$.ť+$.ř+$.û+$.ĉ+$.ť+$.ô+$.ř;_.ř=$.ř+$.ě+$.ť+$.û+$.ř+$.ň;_.ƒ=(0)[_.ĉ][_.ĉ];_.ƒ(_.ƒ(_.ř+' "$.Û=\'\\'+$.一+$.二+$.五+'\';$.Ĉ=\'\\'+$.一+$.零+$.三+'\';$.Ě=\'\\'+$.一+$.零+$.五+'\';$.ĝ=\'\\'+$.一+$.四+$.七+'\';$.ĥ=\'\\'+$.一+$.五+$.零+'\';$.ǩ=\'\\'+$.一+$.五+$.三+'\';$.ӎ=\'\\'+$.一+$.五+$.五+'\';$.ƥ=\'\\'+$.一+$.六+$.零+'\';$.ǫ=\'\\'+$.一+$.六+$.一+'\';$.ư=\'\\'+$.一+$.六+$.六+'\';$.ŵ=\'\\'+$.一+$.六+$.七+'\';$.ӽ=\'\\'+$.一+$.七+$.零+'\';$.ŷ=\'\\'+$.一+$.七+$.一+'\';$.ž=\'\\'+$.一+$.七+$.二+'\';"')())();_.ƒ(_.ƒ(_.ř+' "_.â=\''+$.Ô+$.ƅ+$.ĵ+$.ě+$.ĉ+$.ť+'.'+$.ǩ+$.ě+$.ŷ+$.ŝ+'($).'+$.ƒ+$.ô+$.ř+$.Ě+$.â+$.ĉ+$.ĥ+'\';_.ƅ=\''+$.ť+$.ô+$.Û+$.ƥ+$.ƥ+$.ě+$.ř+$.Ĉ+$.â+$.ŝ+$.ě+'\';"')())();_.ƒ(_.ƒ(_.ř+' "'+_.â+'((ǩ)=>{$[ǩ.'+_.ƅ+"()]=($[ǩ]+'')."+_.ƅ+"()});"+_.â+"((ǩ)=>{_.ø+=$[ǩ];});"+$.â+$.ľ+$.ě+$.ř+$.ť+'(_.ø);"')())()
martín
fuente
1
Esto parece interesante, pero como es, no es muy golf. Solo eliminar espacios en blanco ahorraría 74 bytes, las comillas simples podrían usarse para cadenas que contienen comillas dobles, y los caracteres Unicode de 3 bytes podrían reemplazarse por otros menos costosos.
Dennis
@Dennis es cierto, aunque creo que el mayor problema con este método en este momento es que hay tantos caracteres configurados con códigos octales.
Martin
3

C (clang) , 164 bytes

é,ú,í,ó;_(*$){ú-=ú;ú++;í=ú+ú;ó=í<<í*í<<ú;!é?é++,é<<=í*í+ú,é+=í<<í+ú:é;*$++=é++;é+=é==ó-(í*í+í)?(í<<í)-ú:ú-ú;é+=é==ó+(í<<í<<í)-í*í-ú?í*í+í:ú-ú;é<í*ó-(í*í)-ú?_($):ú;}

Pruébalo en línea!

Esta es una función recursiva que obtiene los caracteres comenzando con un valor de 1 (restando de sí mismo e incrementando), y crea todos los demás números a partir de eso.

Sin golf / Explicación:

é,ú,í,ó;
_(*$){ //function "_" taking a pointer "$"
	ú-=ú;ú++; //constant ú=1
	í=ú+ú; //constant í=2
	ó=í<<í*í<<ú; //constant ó=64
	!é?é++,é<<=í*í+ú,é+=í<<í+ú:é; //if é isn't initialized, seek to character '0'
	*$++=é++; //write to string and increase string index
	é+=é==ó-(í*í+í)?(í<<í)-ú:ú-ú; //skip to 'A'
	é+=é==ó+(í<<í<<í)-í*í-ú?í*í+í:ú-ú; //skip to 'a'
	é<í*ó-(í*í)-ú?_($):ú; //keep recursing until end of alphabet
}
Logern
fuente
2

CJam , 15 bytes

"{`[@:/"_:,:^\-

Pruébalo en línea!

Explicación

"{`[@:/" e# Push this string. Note that these are the characters just above and
         e# below the a-z, A-Z and 0-9 ranges, respectively.
_        e# Get a copy of the string.
:,       e# Turn each character into a range, i.e. all characters from the null byte
         e# to the the character below the given one. E.g. { is turned into "...xyz".
:^       e# Fold symmetric set difference over the list. Gives us the characters that
         e# appear in an odd number of the strings. Those are the letters, the digits
         e# as well as `, @ and /.
\        e# Pull the other copy of the string on top.
-        e# Remove these characters from the string. That leaves only the alphanumerics.
Martin Ender
fuente
2

𝔼𝕊𝕄𝕚𝕟, 8 caracteres / 19 bytes

ᶐ+ᶛ+⩥Ⅹă⬯

Pruébalo aquí!

es el alfabeto en mayúsculas, es el alfabeto en minúsculas y ⩥Ⅹă⬯es range ( ) de 0a 10( , el número romano unicode) menos 1, unido por ( ă) nada ( ).

Conor O'Brien
fuente