Imprimer tous les caractères alphanumériques ASCII sans les utiliser

51

Défi

Imprimez les caractères suivants:

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890

Le problème, c'est que vous ne pouvez en utiliser aucun dans votre code.

Vous pouvez les imprimer dans un ordre arbitraire, avec ou sans nouvelle ligne, mais vous ne pouvez imprimer aucun autre caractère.

Règles

  • Vous ne pouvez utiliser aucun caractère de l'ensemble mentionné ci-dessus
  • Vous pouvez utiliser d'autres caractères
  • Pas de tricherie
  • Lacunes standard interdites
  • C'est le , la réponse la plus courte gagne.

Des clarifications

  • Si votre langue utilise un jeu de caractères différent, vous ne pouvez pas utiliser de points de code correspondant à des caractères alphanumériques.
  • Le renvoi d'une chaîne d'une fonction est considéré comme une forme de sortie valide.
  • Vous pouvez retourner un tableau de caractères.
dkudriavtsev
la source
8
C'est un peu ambigu. Si vous voulez générer ces octets bruts sans ces octets dans votre code, vous devez alors spécifier que vous ne pouvez pas utiliser les points de code de ces caractères, même s'ils correspondent à un autre élément de la page de codes de votre langue.
FlipTack
11
Cela signifie donc que je ne peux utiliser aucune lettre ou chiffre dans mon code source. Cela supprime quasiment tout langage non ésotérique.
R. Kap
2
Que se passe-t-il si la langue n'est constituée que d'octets bruts (sous forme de codes d'opération) sans représentation? Suis-je libre d'utiliser des caractères?
FlipTack
1
@briantist c'est bien s'ils sont représentés en interne par ints, mais les caractères eux-mêmes doivent être imprimés.
dkudriavtsev
3
@ R.Kap Javascript pourrait fonctionner, à condition que vous ne pensiez pas qu'il soit eso
Destructible Lemon

Réponses:

19

V , 8 7 octets

1 octet enregistré grâce à @DJMcMayhem en le mettant dans une déclaration regex

¬/{Ó×ü_

Essayez-le en ligne!

Les sorties:

0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Note: ×n'est pas x ou X, c'est0xd7

Hexdump:

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

Explication

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

Maintenant, la sortie ressemble à:

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

Nous devons supprimer tous les caractères non alphanumériques et le _(puisqu'il n'est pas inclus dans \W), alors faisons-le en utilisant regex

Ó×ü_           " removes every character that is non-alphanumeric or an underscore _ 
               " vim equivalent of :s/\W\|_//g
Kritixi Lithos
la source
Incroyable! +1 pour m'avoir battu. :) Aussi, vous pourriez le simplifier jusqu'à un regex si vous le Ó×ü_:s/\W\|_//g
faisiez
50

Octave , 52 46 40 octets

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

Ceci est évalué à

9876543210ZYXWVUTSRQPONMLKJIHGFEDCBAabcdefghijklmnopqrstuvwxyz

Explication

Nous utilisons ici le fait que les caractères sont implicitement convertis en entiers lorsque des opérations arithmétiques telles que +-ou la fonction range :sont appliquées. Lorsqu'ils sont concaténés avec une chaîne vide ( [...,'']), les nombres sont à nouveau convertis en caractères.

Essayez-le en ligne!

flawr
la source
7
+1d'être le premier langage non ésotérique dans un défi très adapté aux esolangs.
DJMcMayhem
4
Un gros +1, pas pour utiliser Octave (c'est assez simple), mais pour très bien jouer au golf, et _comme variable! Je ne savais pas que c'était possible ... Bien!
Stewie Griffin
1
Lorsqu'ils sont concaténés avec une chaîne vide ([..., '']), les nombres sont à nouveau convertis en caractères .... très agréable
rahnema1
29

brainfuck , 77 76 75 72 octets

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

Essayez-le en ligne!

Comment ça fonctionne

L'interprète commence par une bande de 0 cellules.

++++++++

Cela définit la première cellule sur 8 , laissant la bande dans l'état suivant.

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

Cela incrémente la deuxième cellule une fois, la troisième cellule 6 fois, la quatrième cellule 4 fois, décrémente la cinquième cellule une fois, puis revient au début de la bande et décrémente la première cellule. Après 8 itérations, la bande ressemble à ce qui suit.

  0   8  48  32  -8
  ^
>++

Nous passons à la deuxième cellule et l'incrémentons deux fois pour nous préparer à imprimer les chiffres.

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

Cela imprime la troisième cellule, l’incrémente, puis revient à la deuxième cellule et la décrémente. Après 10 itérations, nous avons imprimé 0123456789et la bande ressemble à ce qui suit.

  0   0  58  32  -8
      ^
>>

Il est temps de préparer la bande pour les lettres! Nous commençons par avancer de deux cellules.

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

Cela incrémente la cinquième cellule une fois, la sixième cellule deux fois, la septième cellule trois fois, puis revient à la quatrième cellule et la décrémente. Après 32 itérations, la bande ressemble à ce qui suit.

  0   0  58   0  24  64  96
              ^
>++

Comme dernière étape avant d’imprimer les lettres, nous passons à la cinquième cellule et l’incrémentons deux fois.

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

Enfin, nous passons à la sixième cellule pour l'incrémenter et l'imprimer, faisons de même pour la septième cellule, puis revenons à la cinquième cellule et la décrémentons. Après 26 itérations, nous avons imprimé Aa...Zz.

Dennis
la source
Beau golf! Je vais vous lier à votre réponse
FlipTack
25

Ruby, 42 octets

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

Une fonction qui retourne un tableau de caractères. Un programme qui affiche uniquement les caractères est de 49 octets:

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

Ceci utilise simplement les caractères ascii de chaque côté des plages pertinentes pour définir une plage. Par exemple, ?/...?:signifie les caractères entre une barre oblique et un deux-points, sans compter la fin. Pour se débarrasser des débuts, on soustrait un tableau contenant les trois caractères de départ.

histocrate
la source
Bon travail. J'ai vu cela au moment même où je venais de publier ma version de 60 octets en utilisant la même idée.
AShelly
3
Vous pouvez enregistrer un octet avec des plages légèrement différentes: $> << ([ (? / ...? {)] - [* (?: ..? @)), * (? [..? `),? / ]) ''
AShelly
C'est vraiment joli. Bien, moche. Tu sais ce que je veux dire. Bien fait.
Wayne Conrad
22

6502 langage machine, 74 70 68 octets

Hex dump (les programmes 6502 ne sont généralement pas déplaçables; le code est stocké à partir de l'emplacement 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

Vous pouvez voir que cela n'utilise aucun des octets interdits: 41 $ à 5a $, 61 $ à 7a $ ou 30 $ à 39 $.

Il s'agit d'une fonction sans argument qui, lorsqu'elle est appelée, renvoie un pointeur sur le tableau de caractères "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" situé en haut de la pile, conformément aux conventions d'appel 6502.

En guise d’explication, voici un démontage:

Adresse Hexdump Disassembly
-------------------------------
0603 $ a9 24 LDA # 24 $
0605 $ 0a ASL A
0606 $ 8j 20 06 STA 0620 $
0609 $ 8j 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 NOP 
$ 061b aa taxe 
061c $ par personne NOP 
061d $ a8 TAY 
061e $ a9 00 LDA # 00 $
0620 $ ch. NOP 
0621 $ ch. NOP 
$ 0622 98 TYA 
0623 $ ch. NOP 
$ 0624 8a TXA 
0625 $ ch. 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 ADL # 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

Le code en langage machine se modifie automatiquement. Pour manipuler les piles, je devais utiliser PHA et PLA pour insérer et extraire l'accumulateur, mais ces instructions portent les codes d'opération $ 48 et $ 68, qui sont interdits (ce sont les codes ASCII des lettres "H" et "h"). Ainsi, pour PHA, je prends le nombre de 24 USD, fais un décalage arithmétique à gauche (ASL) et stocke les 48 USD obtenus dans les quatre emplacements du code où ils doivent être exécutés. Ensuite, pour PLA, j’utilise un OU au niveau des bits sur les 48 $ de l’accumulateur pour calculer 68 $ et les stocke dans les deux emplacements du code où cela est nécessaire.

Il y avait plusieurs instructions autres que PHA et PLA que je ne pouvais pas non plus utiliser car leurs opcodes étaient identiques à des lettres ou des chiffres ASCII, mais j'ai trouvé des solutions de contournement directes pour ces autres.

Le tableau de caractères souhaité est calculé et stocké à partir de l'emplacement 0 (peu importe l'endroit où il est stocké car nous devons simplement nous assurer qu'un pointeur sur ce point est renvoyé en haut de la pile).

Vous pouvez essayer ceci chez l'assembleur et l'émulateur de Nick Morgan 6502 . Voici une capture d'écran; le moniteur en bas affiche la chaîne de sortie (aux emplacements compris entre 00 $ et $ 3D) après l'exécution du programme.

Mitchell Spector
la source
16

Haskell , 75 72 63 58 56 octets

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

Essayez-le en ligne! Appeler avec __. Sortie:

0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Merci à xnor qui a suggéré __et en _'tant que noms de variables à deux octets au lieu de (!)ou similaires, en économisant 9 octets. J'aime particulièrement comment _'brise la coloration syntaxique. Et merci encore à xnor d’avoir généralisé les plages, sauvant encore 4 octets.
Edit: Je trouve que les caractères Unicode sont autorisés comme identifiants dans Haskell, donc par exemple ä, ö... peut également être utilisé comme deux identifiants d'octets. Puisqu'il restait un identifiant de trois octets dans le programme, je l'ai remplacé par ä, en enregistrant 2 autres octets.

Explication:

__et _'sont des noms de variables valides. A partir de la spécification de langue :

Un identifiant consiste en une lettre suivie de zéro ou plusieurs lettres, chiffres, traits de soulignement et guillemets simples. [...] Le trait de soulignement, _est traité comme une lettre minuscule et peut se produire partout où une lettre minuscule le peut. Cependant, _tout seul est un identificateur réservé, utilisé comme caractère générique dans les modèles.

Donc, le code est équivalent à

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

Dans la compréhension liste ase lie à '/'et bà ':'( "/:"est équivalent à ['/',':'], de sorte que le pattern matching réussit). Ensuite, la plage [a..]construit la chaîne de tous les caractères supérieurs '/':

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

Pour chaque caractère xde cette chaîne, il est ensuite vérifié si '/'<xet x<':', ce qui donne les caractères 0123456789. Alors aet bsont liés à, @ et [cédant les caractères ABCDEFGHIJKLMNOPQRSTUVWXYZet ainsi de suite.

Laikoni
la source
3
Vous pouvez utiliser __et _'comme variables.
xnor
@xnor Merci, je ne connaissais pas la Underscore is treated as a lower-case letterrègle.
Laikoni
1
Vous pouvez économiser des octets en généralisant les plages: _'_=[__|[_',__']<-["`{","@[","/:"],__<-[_'..],_'<__,__<__'](dans les variables normales z=[x|[a,b]<-["`{","@[","/:"],x<-[a..],a<x,x<b]).
xnor
@xnor Merci encore! Excellente idée de combiner le début et la fin des plages dans une chaîne. J'ai aussi essayé de généraliser les gammes, mais j'ai toujours fini plus longtemps sans cette idée. Un octet supplémentaire peut être sauvegardé en liant la chaîne à __au lieu de _'_ même si __est utilisé comme identifiant dans la liste de compréhension.
Laikoni
13

Perl (5.10 ou 5.12), 30 29 octets

Ce programme est principalement composé de caractères non imprimables, alors voici 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          ............"

Ce programme est très simple: nous regexons ( =~) un trait de soulignement ( _; merci @ Dennis pour nous avoir signalé que cela fonctionne) contre une expression rationnelle. La regex est spécifiée en tant qu'expression plutôt que littéralement; Plus précisément, nous prenons le complément bitwise ( ~) d'une chaîne. En inversant le complément au niveau du bit pour obtenir la chaîne sous-jacente, nous obtenons la regex suivante en cours d'exécution:

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

Dans les versions 5.10 et 5.12 de Perl, la (?{…})syntaxe était une syntaxe expérimentale permettant aux expressions rationnelles d'exécuter du code arbitraire au moment de l'exécution. Dans ce cas, nous l'utilisons pour exécuter un programme Perl simple afin d'imprimer le résultat souhaité. (Les versions antérieures à 5.10 ne peuvent pas être utilisées car elles ne le sont pas say.)

Les versions modernes de Perl ont été désactivées (?{…})par défaut pour des raisons de sécurité, mais si vous avez une telle version de Perl, vous pouvez désactiver le contrôle (et donc exécuter ce programme) via -Mre=evalun argument de ligne de commande (avec le standard -M5.010qui spécifie la version). du langage à implémenter, et qui ne compte pas dans le décompte).


la source
13

Actuellement 8 5 4 octets

'>┘▀

Comment ça fonctionne:

 '>    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]

L'impression est implicite à la fin du programme.

Édition 1: Remplacement de l’alphabet en minuscule / majuscule, puis dans la plage de chiffres (10) avec uniquement les caractères imprimables de la base 62.

Edit 2: changé ">" en '> grâce à Mego :) enregistré 1 octet.

Essayez-le en ligne!

Sarcelle
la source
'>est un octet plus court que ">".
Mego
@ Mego Oui, il est, édité :) merci.
Pélican sarcelle
11

PHP, 69 octets

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

Le code est stylisé sous Windows-1252 ici. Ci-dessous se trouve un xxd hexdump réversible .

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                                   ...";

Essayez-le en ligne!

Dennis
la source
10

Java (OpenJDK 9) , 277 octets

Oui, Java, vous avez bien lu!

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

Essayez-le en ligne!

Ceci affiche les plages, mais inversé, car l'ordre n'a aucune importance.

zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDCBA9876543210

J'ai joué sur l'absence de règle "pas d'entrée" pour définir implicitement ce charqui est nécessaire pour que tout fonctionne. Si c'est de la triche, dites-le s'il vous plaît.

Ungolfed & testing

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
la source
3
Attends quoi?? Je suis court que toutes les solutions JavaScript? o_O
Olivier Grégoire Le
C'est parce que JavaScript n'a pas char, sinon ce serait un morceau de gâteau. Et pour être juste, ma réponse est plus courte que votre réponse initiale. Jetez un coup d'œil à mon explication pour tous les frais généraux que je dois subir.
Patrick Roberts
2
@PatrickRoberts Pour être juste, nous devrions comparer l'édition initiale à l'édition initiale ou dernière édition à l'édition précédente, et non l'édition au dernier ...;) obtenir une réponse plus courte que tous les JS.
Olivier Grégoire
9

Brainfuck, 89 85 octets

Parce que brainfuck ignore de toute façon les caractères alphanumériques, il s’agit là d’un défi à sortie constante ... (Edit: voir la solution de Dennis pour une version plus courte de 10 octets)

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

Essayez-le en ligne!

Ce code est un bon exemple de boucles comptées de base dans le 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)

Notez que cela utilise des raccourcis d'habillage pour générer des nombres, ce qui signifie que l'interpréteur doit avoir des cellules d'habillage de 8 bits (telles que celle à laquelle je suis lié).

FlipTack
la source
5
Brainfuck était la première langue à laquelle j'ai pensé. Dommage que je ne le sache pas. Bonne réponse.
ElPedro
7

JavaScript (ES6), 983 octets

Il se trouve que dans ES6, vous pouvez utiliser beaucoup de caractères dans les noms de variables JavaScript ! Fonctionne très bien après avoir épuisé les six noms de variable de 1 à 2 octets avec $et _.

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

JavaScript, 1223 octets

C'était ma réponse avant que j'apprenne ce qui précède.

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

Je courus console.log('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890')par jjencode et le résultat manuellement joué au golf. Il y a certainement plus d'optimisations possibles.

Darrylyeo
la source
Hé, FYI, j'ai posté codegolf.stackexchange.com/a/105854/42091 parce que j'y ai mis beaucoup de travail et que je trouve cela suffisamment différent de votre réponse.
Patrick Roberts
Pas de problème, bien paraître!
darrylyeo
Agréable! Cette dernière mise à jour m'a aidé à obtenir plus de 100 octets du mien!
Patrick Roberts
1
Si vous modifiez votre codage en ISO8859-1 et le laissez exactement comme cela, ce sera 769 octets.
Patrick Roberts
7

Befunge, 73 72 59 57 55 53 octets

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

Essayez-le en ligne!

Il s’agit d’une boucle unique comptant à partir de {(c’est-à-dire un caractère après z). Lors de la première itération, la "{"<séquence place deux copies de {sur la pile, l’un étant le compteur de boucle initial et l’autre servant à décrémenter ce compteur à l’aide de la séquence !!-(deux NOTs 1, qui sont ensuite soustraits). Lors des itérations suivantes, le compteur de boucle est déjà sur la pile, il ne vous en faut donc qu'un {pour configurer la séquence de décrémentation.

Le reste du code est juste une longue expression booléenne calculant si le caractère est dans la plage. Si c'est le cas, la branche de la deuxième ligne se divise à gauche pour écrire la valeur. Sinon, la branche droite vérifie si nous avons atteint zéro et devrions nous arrêter. Les deux branches se confondent au milieu pour remonter et répéter la boucle. Notez que toutes les commandes de direction verticale vont vers le haut, car nous ne pouvons pas utiliser de v, mais c'est bien parce que le pointeur d'instruction se positionne automatiquement en haut du champ de lecture.

Merci à Mistah Figgins d’ avoir initialement trouvé une meilleure technique pour l’incrément de boucle.

Mais un merci tout spécial à Jo King pour une approche encore meilleure du décompte plutôt que de la hausse, ainsi que pour une configuration de branche plus compacte.

James Holderness
la source
1
S'il n'y a rien d'autre que le compteur sur la pile, vous pouvez changer votre partie d'incrémentation en \! + S'il y en a une, vous pouvez faire: !! +. pour des valeurs non nulles
MildlyMilquetoast le
-2 octets en réarrangeant le chèque au début de la ligne
Jo King le
@JoKing Bien repéré. Nous ne pouvons pas utiliser le vfichier car il s'agit d'une source restreinte, mais cela fonctionne tout aussi bien avec a ^. Merci.
James Holderness le
-2 octets en décomptant au lieu de monter, et en utilisant la copie supplémentaire du compteur sur la deuxième ligne pour vérifier si la boucle est terminée (souvenez-vous de la source restreinte cette fois;))
Jo King
@JoKing Wow, vous êtes vraiment mieux à ce golf que moi! Merci encore.
James Holderness
6

Gelée , 17 à 16 octets

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

Essayez-le en ligne!

Comment ça fonctionne

“:[{“/@`‘Ḷḟ"/ỌḊ€  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
la source
Parce que jelly a sa propre page de codes, il serait utile de joindre un hexdump pour vérifier facilement que vous n'utilisez pas les octets interdits
FlipTack
La page de codes de @FlipTack IIRC Jelly est compatible avec le format ASCII imprimable.
PurkkaKoodari
@FlipTack Pietu1998 a raison. Et même s'il ne l'était pas, la spécification interdit les caractères, pas les octets.
Dennis
@Dennis En fait, il interdit les octets en fonction des commentaires , même si cela reste valide (compatible ASCII).
Erik the Outgolfer
6

Brainfuck à modification automatique , 32 octets

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

Essayez-le en ligne!

xxd -rhexdump irréversible (contient des éléments non imprimables):

00000000: 3c5b 2d3c 2b2e 3e5d 3c3c 5b2d 3c2b 2e3e  <[-<+.>]<<[-<+.>
00000010: 5d3c 3c5b 2d3c 2b2e 3e5d 601a 401a 2f0a  ]<<[-<+.>]`.@./.
Erik l'Outgolfeur
la source
Qu'est-ce que le @/fait?
Yytsi
@TuukkaX Les 6 derniers caractères `\x1a@\x1a/\nsont là parce que leurs points de code sont vraiment utiles dans le golf. Vous ne pouvez pas les enlever.
Erik the Outgolfer
@ downvoter: Si vous tombez sur ce message, supprimez votre vote par défaut. Cela a été corrigé depuis.
Erik the Outgolfer
Je suis heureux de ne pas être le seul à utiliser SMBF. :)
mbomb007
@ mbomb007 En pratique :) Je pensais à BF, et les SMBF me sont venus à l'esprit, de sorte que j'ai les codes codés prêts. La restriction ne m'a pas coûté octets, comme je l'ai utilisé à la +.place de .+.
Erik the Outgolfer
6

C, 128 octets

Oui, C. Et même plus court que quelques ésotériques.

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

Appelez _un char *tampon suffisamment grand et vide .

Peut-être dépendant du compilateur. Testé avec GCC; Le fichier a été enregistré dans la page de codes 1252.

Anonyme
la source
6

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

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

Edit: En utilisant le codage ISO8859-1, cette solution contient 416 octets au lieu de 520 octets. Le programme complet compte 432 octets, en tenant compte des 16 octets supplémentaires pour

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

Ceci est une soumission de fonction, par opposition à un programme complet. JJEncode (pointe du chapeau à darrylyeo pour ça), j’ai passé beaucoup de temps à jouer au golf , mais au lieu de jouer au golf

console.log('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890')

J'ai joué au golf

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

Øest initialisé à ""dans la surcharge.

Réécrit avec les opérateurs de virgule convertis en nouvelles lignes:

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

Explication

Ce script commence par initialiser quelques types intégrés et les contraindre dans des chaînes. Les chaînes que nous pouvons obtenir sans utiliser de caractères alphanumériques sont:

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

À partir de ces chaînes et des chiffres nécessaires pour référencer des caractères individuels, nous pouvons obtenir les chaînes returnet constructor, qui peuvent être utilisées comme:

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

Le constructeur de l'objet est Object(), et son constructeur est Function(), que nous pouvons utiliser essentiellement comme eval().

Dans ce cas, le script codé à exécuter est la forboucle imbriquée concaténant tous les caractères alphanumériques dans une chaîne en utilisant leurs points de code et en les renvoyant.

Pour les caractères alphabétiques du script codé auxquels il est impossible d'accéder à l'aide des fonctions intégrées, JJEncode utilise des échappements octaux pour les représenter, puis décode la chaîne entière en la renvoyant à partir d'une fonction interne. La fonction externe peut ensuite être appelée pour exécuter le source.

Démo

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

Patrick Roberts
la source
5

Brain-Flak , 171 octets

Comprend +3 pour -A

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

Essayez-le en ligne!

(((((()()()){}){}){}){}) # 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

Il existe probablement un moyen de le faire sans avoir à répéter la fonction "add 1".

Riley
la source
5

Julia 0.4 , 46 bytes

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

C'est une fonction générique qui retourne un tableau de caractères.

Essayez-le en ligne!

Version alternative, 47 octets, uniquement ASCII

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

Essayez-le en ligne!

Dennis
la source
5

J, 171 octets

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

Ow ... mon cerveau me fait mal ... Essayez-le en ligne!

Pour que vous puissiez voir l’ensemble d’une ligne (elle ne fonctionnera pas, mais avec des sauts de ligne).

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

Garanti uniquement de fonctionner avec la version J j805/j64/linux/release/commercial/www.jsoftware.com/2016-12-11T08:02:52, dans cet ordre. (Seuls les 12 premiers caractères sont importants.)

Explication

La majeure partie du programme est consacrée à la génération constante. Avec ces constantes remplacées par leurs valeurs, le programme ressemble à ceci:

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

Avec quelques parenthèses supprimées et quelques chiffres plus agréables:

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

Ceci est composé d'un tas de ,et ,~s, qui ajoutent et ajoutent des arguments. Voici les valeurs séparées:

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

1est 26comme une chaîne.

9!:14'' génère la chaîne suivante sur TIO:

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

avec 2, nous obtenons le 10caractère th ( ide linux), et ajoutons un .à la fin de celui-ci, cédant i..

3et 5sont explicites.

4est la liste des nombres 65 97 48sous forme de chaîne.

6est similaire à 2, sauf que c'est le 12caractère th ( ude linux) et ajoute un :à la fin, cédant u:.

Tout cela cède u:,65 97 48+/i.26. ".évalue cela en nous donnant:

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789:;<=>?@ABCDEFGHI

(Note: +/addition tabulée.)

Ensuite, avec 62{., nous prenons les premiers 62personnages de ceci, nous donnant ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.

Conor O'Brien
la source
Vous pouvez obtenir la constante 14 à l'aide de <:<.^^*_laquelle enregistre un octet. En outre, j'ai essayé de générer la totalité de la plage et de supprimer les symboles pour obtenir ':;<=>?@[\]^_`'-.~".(':',~(+:+:>.^*_){(*:>.^*_)!:(<:<.^^*_)''),":(#@}.@}.@}.@,~(+#\)],,~)(*:@#$])'+++++'104 octets. Je suis sûr qu'il peut être beaucoup plus court
miles le
5

05AB1E , 18 15 11 octets

-4 grâce à Adnan, car si la taille en entrée est 1, 05AB1E utilisera 0 pour b sur la première commande.

•£•Ýç©á®þ«˜

Essayez-le en ligne!

•£•Ÿ            # 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. 

J'ai essayé tellement d'approches différentes, mais les points clés qui ont rendu la tâche difficile:

- 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.
Urne Magique De Pieuvre
la source
1
You may print them in arbitrary orderdit le défi.
AdmBorkBork
1
Est-ce que ça •£•Ýç©á®þ«˜marche aussi?
Adnan
@Adnan nice, je ne savais pas qu'il utilisait 0 lorsqu'il n'y avait pas b.
Urne Magique Octopus
5

Brainfuck, 55 octets

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

Sortie:

aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ0123456789

Essayez-le en ligne!


Initialise la bande à 3,2 n et fonctionne à partir de là.

+++[[<+>->++<]>]    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
la source
5

Perl 6 , 43 octets - sans compétition

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

Un lambda qui renvoie une liste de caractères.
Explication:

   '`'                                       # 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"

Dépend d'une correction de bug de l'interprète Rakudo Perl 6 qui était uniquement réservée au dépôt Git aujourd'hui, et ne fait pas encore partie d'une version officielle de Rakudo. En fait, j'ai rencontré le bogue en répondant à ce défi et j'ai réussi à le réparer avec l'aide de l'un des développeurs principaux de Perl 6. Les règles de ce site, telles que je les comprends, ne permettent pas aux réponses d'entrer en concurrence dans une telle situation, aussi je l'ai marqué comme non compétitif.

smls
la source
41 octets
Jo King
4

PHP 7.0+, 110 octets

Que Dieu bénisse les chaînes de bits!

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

Remplacez-la \npar une vraie nouvelle ligne de style NIX.
Il est présent dans le code pour éviter les problèmes de nouvelles lignes, mais n'est pas compté dans la partition.

Cela lance une série d’avertissements, mais ceux-ci pourraient être supprimés en ajoutant un @en face de chaque errant _.


Avertissement gratuit , 113 octets

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

65c02 langage machine + Apple] [ROM, 25 octets

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

Impressions abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.

Devrait commencer à $8000 .

Démontage

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   
nom_insertion_ici
la source
Ceci enfreint la règle des points de code - vous utilisez simplement les caractères d'un jeu de caractères différent. Les octets sont corrects tant qu'ils ne sont pas des itéraux ou lus par le code.
dkudriavtsev
@wat Ah, OK. J'ai modifié mon code afin qu'il n'utilise pas d'octets de code machine mappant des caractères alphanumériques en ASCII "normal" (positif) et n'utilise pas de littéraux alphanumériques ASCII positifs ou négatifs ; est-ce valide maintenant?
insert_name_here
Je suppose... ._.
dkudriavtsev
@wat Les points de code dans l'ordre croissant utilisé actuellement sont ceux 10, 15, 26, 32, 44, 96, 128, 162, 169, 175, 192, 202, 208, 224, 237, 249, 253qui correspondent aux caractères ↵.. ,`.¢©¯ÀÊÐàíùýoù les .s sont des caractères non imprimables. C'est valable
Patrick Roberts
3

bash (sur linux), 507 493 490 485 octets

cela stocke un tableau de caractères dans la variable globale __

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

il doit être exécuté sur une machine Linux fraîchement démarrée avec /proc, ou quelque chose comme un espace de noms pid

explication:

# {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}
__=(${__[@]} ${___[@]} ${___[@]^})

pour l'essayer, nous pouvons ajouter declare -p __à la fin pour afficher le résultat

$ 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
la source
+1 Je pense que vous devriez indiquer cela comme Bash sous Linux , contrairement aux autres systèmes d’exploitation (MacOS, par exemple) /proc. En fait, cela /procn’est pas strictement nécessaire sous Linux, même si vous auriez probablement du mal à trouver une distribution moderne sans elle.
Digital Trauma
3

Javascript, 1273 1351 1610 octets

Cette solution fonctionne essentiellement de la même façon que les deux autres réponses sur ce sujet ici et ici , où il utilise des lettres des true, false, undefinedet les [object Object]chaînes pour construire les fonctions dont il a besoin pour générer les autres lettres.

Puisqu'un bon nombre de lettres sont déjà insérées dans l'objet, j'ai essayé d'ajouter toutes les lettres minuscules restantes et les chiffres à l'objet, puis de les appliquer toUpperCaseà toutes les valeurs de l'objet pour générer les lettres majuscules manquantes.

Mise à jour:

J'ai pu améliorer la manière dont les valeurs octales étaient définies, mais elles prennent toujours 13 x 30 octets (ou elles seront de 30 octets chacune après que je change les nombres en différentes clés), chacune suit maintenant ce général motif: $.ž=\'\\'+$.一+$.七+$.二+'\';.

49 octets supplémentaires peuvent être facilement supprimés en commutant les touches pour les nombres en caractères de 2 octets.

Soumission actuelle:

$=~[];_={ť:!""+"",ň:![]+"",û:$._+'',ô:{}+"",ø:''};$={零:++$,ƒ:_.ň[$],ť:_.ť[$],一:++$,â:_.ň[$],ř:_.ť[$],ô:_.ô[$],ň:_.û[$],二:++$,ľ:_.ň[$],û:_.ť[$],ƅ:_.ô[$],ď:_.û[$],三:++$,ŝ:_.ň[$],ĵ:_.ô[$],四:++$,ě:_.ň[$],五:++$,ĉ:_.ô[$],î:_.û[$],六:++$,七:++$,八:++$,Ô:_.ô[$],九:++$};_.ĉ=$.ĉ+$.ô+$.ň+$.ŝ+$.ť+$.ř+$.û+$.ĉ+$.ť+$.ô+$.ř;_.ř=$.ř+$.ě+$.ť+$.û+$.ř+$.ň;_.ƒ=(0)[_.ĉ][_.ĉ];_.ƒ(_.ƒ(_.ř+' "$.Û=\'\\'+$.一+$.二+$.五+'\';$.Ĉ=\'\\'+$.一+$.零+$.三+'\';$.Ě=\'\\'+$.一+$.零+$.五+'\';$.ĝ=\'\\'+$.一+$.四+$.七+'\';$.ĥ=\'\\'+$.一+$.五+$.零+'\';$.ǩ=\'\\'+$.一+$.五+$.三+'\';$.ӎ=\'\\'+$.一+$.五+$.五+'\';$.ƥ=\'\\'+$.一+$.六+$.零+'\';$.ǫ=\'\\'+$.一+$.六+$.一+'\';$.ư=\'\\'+$.一+$.六+$.六+'\';$.ŵ=\'\\'+$.一+$.六+$.七+'\';$.ӽ=\'\\'+$.一+$.七+$.零+'\';$.ŷ=\'\\'+$.一+$.七+$.一+'\';$.ž=\'\\'+$.一+$.七+$.二+'\';"')())();_.ƒ(_.ƒ(_.ř+' "_.â=\''+$.Ô+$.ƅ+$.ĵ+$.ě+$.ĉ+$.ť+'.'+$.ǩ+$.ě+$.ŷ+$.ŝ+'($).'+$.ƒ+$.ô+$.ř+$.Ě+$.â+$.ĉ+$.ĥ+'\';_.ƅ=\''+$.ť+$.ô+$.Û+$.ƥ+$.ƥ+$.ě+$.ř+$.Ĉ+$.â+$.ŝ+$.ě+'\';"')())();_.ƒ(_.ƒ(_.ř+' "'+_.â+'((ǩ)=>{$[ǩ.'+_.ƅ+"()]=($[ǩ]+'')."+_.ƅ+"()});"+_.â+"((ǩ)=>{_.ø+=$[ǩ];});"+$.â+$.ľ+$.ě+$.ř+$.ť+'(_.ø);"')())()
Martin
la source
1
Cela semble intéressant, mais en l'état actuel, ce n'est pas très golfé. Supprimer simplement les espaces permettrait d'économiser 74 octets, des guillemets simples pourraient être utilisés pour les chaînes contenant des guillemets doubles et les caractères Unicode de 3 octets pourraient être remplacés par des caractères moins coûteux.
Dennis
@Dennis true, même si je pense que le principal problème de cette méthode à l'heure actuelle est qu'il y a tellement de caractères définis avec des codes octaux.
martin
3

C (clang) , 164 octets

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

Essayez-le en ligne!

C'est une fonction récursive qui obtient les caractères en commençant par une valeur de 1 (soustrayant de soi et en augmentant), et crée tous les autres nombres à partir de cela.

Ungolfed / Explaination:

é,ú,í,ó;
_(*$){ //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
la source
2

CJam , 15 octets

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

Essayez-le en ligne!

Explication

"{`[@:/" 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
la source
2

, 8 caractères / 19 octets

ᶐ+ᶛ+⩥Ⅹă⬯

Essayez-le ici!

est l'alphabet majuscule, l'alphabet minuscule et la ⩥Ⅹă⬯plage ( ) de 0à 10( , le chiffre romain unicode) moins 1, joint par ( ă) rien ( ).

Conor O'Brien
la source