Meydan okuma

Aşağıdaki karakterleri yazdırın:

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890

Buradaki kural, bunlardan herhangi birini kodunuzda kullanmamanızdır.

Onları baştaki veya sondaki yeni satırlı veya satırsız, rasgele sırayla yazdırabilirsiniz, ancak başka karakterler yazdıramazsınız.

kurallar

• Yukarıda belirtilen setten hiçbir karakter kullanamazsınız.
• Başka herhangi bir karakter kullanabilirsiniz
• Hile yok
• Standart boşluklar yasaklandı
• Bu kod golf , en kısa cevap kazanıyor.

Açıklamalar

• Diliniz farklı bir karakter kümesi kullanıyorsa, bu karakter setinde alfanümerik karakterlere karşılık gelen kod noktaları kullanamazsınız.
• İşlevden bir dize döndürmek geçerli bir çıktı biçimi olarak kabul edilir.
• Bir karakter dizisi döndürebilirsiniz.

V , 8 7 bayt

@DJMcMayhem sayesinde hepsini bir regex deyimine yerleştirerek 1 bayt kurtarıldı

¬/{Ó×ü_

Çevrimiçi deneyin!

Çıktılar:

0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Not: ×olduğu değil x ya Xöyle,0xd7

HexDump:

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

açıklama

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

Şimdi çıktı şöyle görünür:

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

Alfanümerik olmayan tüm karakterleri ve _(içine dahil edilmediğinden \W) kaldırmak zorundayız , öyleyse bunu regex kullanarak yapalım.

Ó×ü_           " removes every character that is non-alphanumeric or an underscore _ 
               " vim equivalent of :s/\W\|_//g

Octave , 52 46 40 bayt

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

Bu değerlendirir

9876543210ZYXWVUTSRQPONMLKJIHGFEDCBAabcdefghijklmnopqrstuvwxyz

açıklama

Burada, gibi karakteristik aritmetik işlemler +-veya range işlevi :uygulandığında karakterlerin örtük olarak tam sayılara dönüştürülmesi gerçeğini kullanıyoruz . Boş bir dizeyle ( [...,'']) birleştirildiğinde , sayılar tekrar karakterlere dönüştürülür.

Çevrimiçi deneyin!

brainfuck , 77 76 75 72 bayt

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

Çevrimiçi deneyin!

Nasıl çalışır

Tercüman, 0 hücrelik bir bantla başlar .

++++++++

Bu, ilk hücreyi 8'e ayarlayarak kaseti aşağıdaki durumda bırakır.

   8
   ^

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

Bu, ikinci hücreyi bir kez arttırır, üçüncü hücreyi 6 kez, dördüncü hücreyi 4 kez, beşinci hücreyi bir kez düşürür, ardından bandın başına geri döner ve ilk hücreyi azaltır. 8 tekrardan sonra , bant aşağıdaki gibi gözüküyor.

  0   8  48  32  -8
  ^

>++

İkinci hücreye ilerliyoruz ve iki kez artırıyoruz, rakamları yazdırmaya hazırlanıyoruz.

  0  10  48  32  -8
      ^

[>.+<-]

Bu, üçüncü hücreyi yazdırır, arttırır, sonra ikinci hücreye geri döner ve azaltır. 10 yinelemeden sonra , yazdırdık 0123456789ve kaset aşağıdaki gibi görünüyor.

  0   0  58  32  -8
      ^

>>

Mektuplara kaseti hazırlama zamanı! İki hücreyi ilerleterek başlıyoruz.

  0   0  58  32  -8   0   0
              ^

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

Bu, beşinci hücreyi bir kez arttırır, altıncı hücreyi iki kez, yedinci hücreyi üç kez dördüncü hücreye geri döndürür ve azaltır. 32 yinelemeden sonra , bant aşağıdaki gibi görünüyor.

  0   0  58   0  24  64  96
              ^

>++

Harfleri yazdırmadan önceki son adım olarak, beşinci hücreye ilerler ve iki kez artırırız.

  0   0  58   0  26  64  96
                  ^

[>+.>+.<<-]

Sonunda, arttırmak ve yazdırmak, yedinci hücre için de aynı şeyi yapmak, ardından beşinci hücreye geri dönmek ve azaltmak için altıncı hücreye ilerleriz. 26 yinelemeden sonra yazdırdık Aa...Zz.

Ruby, 42 bayt

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

Bir karakter dizisi döndüren bir işlev. Yalnızca karakterleri çıkaran bir program 49 bayttır:

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

Bu sadece bir aralığı tanımlamak için ilgili aralıkların iki tarafındaki ascii karakterlerini kullanır. Örneğin ?/...?:, uç hariç, eğik çizgi ile iki nokta arasındaki karakterler anlamına gelir. Başlangıçlardan kurtulmak için üç başlangıç ​​karakterini içeren bir dizi çıkarırız.

6502 makine dili, 74 70 68 bayt

Onaltılık döküm (6502 programları genellikle yeniden yerleştirilemez; kod burada 0603 $ 'dan başlayarak depolanır):

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

Bunun yasak baytların hiçbirini kullanmadığını görebilirsiniz: 41 - 5 ABD Doları, 61 - 7 ABD Doları veya 30 - 39 ABD Doları.

Bu, çağrıldığında, standart 6502 çağrı kurallarına uygun olarak, yığının en üstünde "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" karakter dizisine bir argüman döndürmeyen bir işlevdir.

Açıklama yoluyla, işte bir sökme:

Adres Hexdump Sökme
-------------------------------
0603 $ a9 24 LDA # 24 $
0605 $ 0a ASL A
0606 $ 8d 20 06 STA 0620 ABD Doları
0609 $ 8d 21 06 STA 0621 ABD Doları
060 $ 8d 23 06 STA 0623 ABD Doları
060 $ 8d 25 06 STA 0625 ABD Doları
0612 $ 09 20 ORA # 20 $
0614 TL 8d 1a 06 STA 061 ABD Doları
0617 $ 8d 1c 06 STA 061c $
NOP 061a 
061 milyar dolar a a VERGİ 
$ 061c ea NOP 
061 $ a8 TAY 
061e a9 00 LDA # 00
0620 ABD doları NOP 
0621 ABD doları 
0622 $ 98 TYA 
0623 ABD doları NOP 
0624 ABD doları 8a TXA 
0625 ABD doları NOP 
$ 0626 a2 ff LDX # $ ff
0628 $ a9 7b LDA # 7b $
062a dan a0 60 LDY # 60 $
$ 062c 20 3a 06 JSR 063a
A9 5b için 062 $ LDA
0631 $ a0 40 LDY # 40 $
0633 ABD Doları 20 3a 06 JSR ABD Doları 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
0646 ABD doları 60 RTS

Makine dili kodu kendi kendini değiştiriyor. Yığın manipülasyonu için akümülatörü itmek ve açmak için PHA ve PLA kullanmam gerekiyordu, ancak bu talimatlar yasaklanmış olan 48 ve 68 $ 'lık kodları kullandı (bunlar' H 've' h 'harflerinin ASCII kodlarıdır). Bu yüzden, PHA için, $ 24 sayısını alıyorum, sola aritmetik bir kayma (ASL) yapıyorum ve sonuçta elde edilen 48 doları, kodun çalıştırılması gereken koddaki dört noktada saklıyorum. Daha sonra, PLA için, $ 68'i hesaplamak için akümülatördeki 48 $ üzerinde bit cinsinden bir OR VEYA kullanıyorum ve kodun gerekli olduğu iki noktada saklıyorum.

PHA ve PLA dışında, kullanamadığım bazı talimatlar da vardı, çünkü onların kodları ASCII harfleri veya rakamları ile aynı oluyordu, fakat diğerleri için doğrudan geçici çözümler buldum.

İstenilen karakter dizisi, 0 konumundan başlayarak hesaplanır ve saklanır (nerede bir deponun üste döndürüldüğünden emin olmamız gerektiği için gerçekten nerede depolandığı önemli değildir).

Bunu Nick Morgan'ın 6502 montajcısı ve emülatöründe deneyebilirsiniz . İşte bir ekran görüntüsü; altındaki monitör kutusu, program çalıştırıldıktan sonra çıkış dizesini ($ 00 - $ 3D konumlarında) gösterir.

Haskell , 75 72 63 58 56 bayt

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

Çevrimiçi deneyin! İle arayın __. Çıktı:

0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Öneren __ve _'yerine iki bayt değişken adı öneren xnor sayesinde (!)9 bayt tasarruf sağlıyor. Özellikle _'sözdizimi vurgulamasının nasıl yapıldığını seviyorum . Ve tekrar aralıkları genelleştirmek için xnor'a teşekkürler, başka bir 4 byte daha tasarruf edin
Düzenleme: Öyle örneğin Unicode karakter Haskell tanımlayıcılar olarak izin verildiğini öğrendim ä, ö... ayrıca iki bayt tanımlayıcıları olarak kullanılabilir. Programda bir adet üç baytlık tanımlayıcı kaldığından, onun yerine ä2 byte daha tasarruf ettim .

Açıklama:

__ve _'geçerli değişken isimleridir. Gönderen dil şartname :

Bir tanımlayıcı, sıfır veya daha fazla harf, rakam, alt çizgi ve tek tırnaktan oluşan bir harften oluşur. [...] Alt çizgi,, _küçük harf olarak kabul edilir ve küçük harflerden oluşan bir yerde olabilir. Ancak, _tek başına, desenlerde joker olarak kullanılan ayrılmış bir tanımlayıcıdır.

Yani kod eşdeğerdir

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

Listede anlama abağlı olur '/'ve bhiç ':'( "/:"eşdeğerdir ['/',':'], böylece desen eşleştirme başarılı). Ardından aralık [a..], eşit olan tüm karakterlerin dizesini oluşturur '/':

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

xBu dizgideki her karakter için karakterlerin olup olmadığı '/'<xve x<':'sonuçlanıp sonuçlanmadığı kontrol edilir 0123456789. Sonra ave bbağlanmıştır @ ve [karakter veren, ABCDEFGHIJKLMNOPQRSTUVWXYZböylece ve.

Perl (5.10 veya 5.12), 30 29 bayt

Bu program çoğunlukla yazdırılamayan karakterlerden oluşur, bu yüzden burada bir 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          ............"

Bu program çok basit: Biz regexing ( =~) alt çizgi ( _; bu işe yaradığını işaret için teşekkürler @Dennis) regex karşı. Düzenli ifade, tam anlamıyla değil, ifade olarak belirtilir; özellikle ~bir dizgenin bitsel tamamlayıcısını ( ) alıyoruz . Alttaki dizgeye ulaşmak için bitsel tamamlayıcıyı ters çevirirseniz, yürütülmekte olan aşağıdaki ifadeyi alırız:

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

Perl 5.10 ve 5.12 sürümlerinde, (?{…})sözdizimi, regex'lerin çalışma zamanında rasgele kod çalıştırmalarına izin veren deneysel bir sözdizimiydi. Bu durumda, istenen çıktıyı yazdırmak için basit bir Perl programını çalıştırmak için kullanırız. (5.10'dan önceki sürümler kullanılamaz çünkü kullanılamazlar say.)

Perl'in modern versiyonları (?{…})güvenlik nedeniyle varsayılan olarak devre dışı bırakılmıştır , ancak eğer böyle bir Perl versiyonuna sahipseniz, kontrol -Mre=evalkomutunu devre dışı bırakabilir (ve böylece bu programı çalıştırabilirsiniz) komut satırı argümanı olarak ( -M5.010versiyonu belirleyen standart ile birlikte) Uygulanacak dilin ve bayt sayısına göre sayılmadığı).

Aslında 8 5 4 bayt

'>┘▀

Nasıl çalışır:

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

Program sonunda yazdırma çok açık.

Düzenleme 1: Alfabenin küçük / büyük harfle ve ardından sayı aralığının (10) sadece 62 tabanının basılabilir karakterlerini almasıyla değiştirildi.

Düzenleme 2: değiştirildi ">" ila '> sayesinde Mego :) kaydedildi 1 byte

Çevrimiçi deneyin!

PHP, 69 bayt

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

Kod burada Windows-1252 kullanılarak stilize edilmiştir. Aşağıda tersinir bir xxd hexdump var.

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

Çevrimiçi deneyin!

Java (OpenJDK 9) , 277 bayt

Evet, Java, bunu iyi okudun!

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

Çevrimiçi deneyin!

Bu, aralıkları yazdırır, ancak sıranın önemi olmadığı için tersine çevirir.

zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDCBA9876543210

Her charşeyin işe yaraması için gerekli olanı kesin olarak tanımlamak için "girdi yok" kuralının yokluğuyla oynadım . Bu hile yapıyorsa, lütfen söyle.

Ungolfed ve test

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('_'));
  }
}

Brainfuck, 89 85 bayt

Brainfuck yine alfanümerik karakterler yok sayar çünkü bu sadece bir sabit çıkış mücadeledir ... (Düzenleme: Bkz Dennis'in Çözüm 10 bayt kısa bir versiyonu için)

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

Çevrimiçi deneyin!

Bu kod, beyin fırtınasındaki temel sayılmış döngülere iyi bir örnektir:

+[-[--<]>>--]   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)

Bunun sayı üretmek için kaydırma kısayolları kullandığını, yani yorumlayıcının 8 bitlik sarma hücrelerine (bağlı olduğum gibi) sahip olması gerektiğini unutmayın.

JavaScript (ES6), 983 bayt

ES6’da JavaScript değişken adlarında kullanabileceğiniz birçok karakter var ! Altı 1-2 baytlık değişken isimlerini $ve ile kullandıktan sonra harika çalışır _.

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

JavaScript, 1223 bayt

Yukarıdakileri öğrenmeden önce bu benim cevabımdı.

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

Koştum console.log('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890')yoluyla jjencode ve elle sonucu golfed. Yapılabilecek kesinlikle daha fazla optimizasyon var.

Befunge, 73 72 59 57 55 53 bayt

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

Çevrimiçi deneyin!

Bu, geri sayım yapan tek bir döngüdür {(örneğin bir karakter sonra z). İlk yinelemede, "{"<sıra {, yığının üzerine iki kopyayı iter - bunlardan biri ilk döngü sayacıdır, diğeri ise diziyi kullanarak bu sayacı azaltmak için kullanılır !!-( 1sonradan çıkarılmış olan iki NOT ). Sonraki yinelemelerde, döngü sayacı zaten yığındadır, bu nedenle {azaltma sırasını ayarlamak için yalnızca bir tane gerekir.

Kodun geri kalanı, karakterin aralık dahilinde olup olmadığını hesaplayan uzun bir boolean ifadesidir. Eğer öyleyse, ikinci satırdaki dal, değeri yazmak için sola bölünür. Değilse, doğru dal sıfıra ulaştığımızı ve sonlandırmamız gerektiğini test etmek için etrafına sarılır. İki dal ortada birleşerek döngüyü tekrar eder. Tüm dikey yön komutlarının a kullanamadığımızdan yukarıya doğru gittiğini unutmayın v, ancak talimat imleci otomatik olarak oyun alanının en üstüne kaydırılır.

Mistah Figgins , başlangıçta ilmek artışı için daha iyi bir teknikle ortaya çıktığı için teşekkürler .

Fakat Jo King'e , saymak yerine geri sayımın daha iyi bir yaklaşımı ve ayrıca daha kompakt bir dal düzeni için özel teşekkürler .

Jöle , 17 16 bayt

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

Çevrimiçi deneyin!

Nasıl çalışır

“:[{“/@`‘Ḷḟ"/ỌḊ€  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 '`').

Kendi kendini değiştiren Brainfuck , 32 bayt

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

Çevrimiçi deneyin!

xxd -r- geri dönüşümlü hexdump (yazdırılamaz içerir):

00000000: 3c5b 2d3c 2b2e 3e5d 3c3c 5b2d 3c2b 2e3e  <[-<+.>]<<[-<+.>
00000010: 5d3c 3c5b 2d3c 2b2e 3e5d 601a 401a 2f0a  ]<<[-<+.>]`.@./.

C, 128 bayt

Evet, C. Ve hatta birkaç ezoterik olandan daha kısa.

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

_Yeterince geniş, boş bir char *arabellek çağırın .

_{Bağımlı bir teensy wee bit derleyici olabilir. GCC kullanılarak test edilmiştir; dosya 1252 kod sayfasında kaydedildi.}

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

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

Düzenleme: ISO8859-1 kodlamasını kullanarak, bu çözüm 520 bayt yerine 416 bayttır. Tam program 432 bayttır, fazladan 16 bayt hesaba katılır.

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

Bu tam bir programın aksine, bir fonksiyon sunumu. JJEncode ( bunun için darrylyeo için şapka ucu) golf oynamak , ancak uzun bir süre geçirdim

console.log('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890')

Golf oynadım

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

burada Øiçin başlatılır ""yükü.

Yeni satırlara dönüştürülen virgül operatörleri ile yeniden yazıldı:

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

açıklama

Bu komut dosyası, birkaç yerleşik tür başlatıp bunları dizelere zorlayarak başlar. Alfanümerik karakterleri kullanmadan elde edebileceğimiz dizeler şunlardır:

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

Bu karakter dizilerinden returnve tek tek karakterlere atıfta bulunmak için gerekli rakamlardan, karakter dizilerini elde edebiliriz ve constructorbunlardan hangisi gibi kullanılabilir:

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

Nesnenin kurucusu Object()ve kurucusu, Function()esasen kullanabileceğimizdir eval().

Bu durumda, yürütülecek kodlanmış komut dosyası, fortüm alfanümerik karakterleri kod noktalarını kullanarak ve onu döndürerek bir dizeye birleştiren iç içe döngülerdir.

Kodlanmış komut dosyasındaki yerleşikler kullanılarak erişilemeyen alfabetik karakterler için JJEncode, onları temsil etmek için sekizli çıkışlar kullanır, ardından dizenin tamamını bir iç işlevden döndürerek şifresini çözer. Dış işlev daha sonra kaynağı çalıştırmak için çağrılabilir.

gösteri

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

Brain-Flak , 171 bayt

İçin +3 içerir -A

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

Çevrimiçi deneyin!

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

Bunu, muhtemelen "1" işlevini ekle 1 'i tekrarlamak zorunda kalmadan yapmanın bir yolu vardır.

Julia 0.4 , 46 bayt

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

Bu, karakter dizisini döndüren genel bir işlevdir.

Çevrimiçi deneyin!

Alternatif sürüm, 47 bayt, yalnızca ASCII

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

Çevrimiçi deneyin!

J, 171 bayt

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

Ow ... beynim ağrıyor ... Çevrimiçi deneyin!

İşte tüm satırları tek satırda görebilmeniz için (satır sonları ile birlikte olsa bile çalışmaz).

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

Sadece J versiyonuyla j805/j64/linux/release/commercial/www.jsoftware.com/2016-12-11T08:02:52bu sırada çalışacağınız garanti edilir . (Sadece ilk 12 karakter önemlidir.)

açıklama

Programın çoğu sürekli üretime adanmıştır. Değerleri ile değiştirilen sabitlerle, program şöyle görünür:

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

Bazı parantezler kaldırılmış ve bazı sayılar daha iyi hale getirilmiştir:

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

Bu, argüman ekleyen ve hazırlayan bir demet ,ve ,~s'den oluşur . İşte ayrı değerler:

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

1olduğu 26bir dize olarak.

9!:14'' TIO'da aşağıdaki dizgiyi oluşturur:

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

ile 2, 10th karakterini ( ifrom linux) alırız .ve sonuna bir a ekleriz i..

3ve 5kendini açıklayıcıdır.

465 97 48dize olarak sayıların listesidir .

6Buna benzer 2, çünkü 12th karakteri ( ufrom linux) ve :sonuna kadar a ekler u:.

Bu, hep birlikte, verim u:,65 97 48+/i.26. ".bunu değerlendirerek bize şunları veriyor:

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789:;<=>?@ABCDEFGHI

(Not: +/eklenmiş tablo eklenmiştir.)

Ardından 62{.ilk 62karakterlerini bizden alarak bize veriyoruz ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.

05AB1E , 18 15 11 bayt

-4 sayesinde Adnan, çünkü eğer giriş büyüklüğü 1 ise, 05AB1E ilk komutta b için 0 kullanır.

•£•Ýç©á®þ«˜

Çevrimiçi deneyin!

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

Çok farklı yaklaşımlar denedim, ama buradaki önemli noktalar onu zorlaştırdı:

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

Brainfuck, 55 bayt

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

Çıktı:

aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ0123456789

Çevrimiçi deneyin!

Kaseti 3 · 2 ^{n olarak} başlatır ve oradan çalışır.

+++[[<+>->++<]>]    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 |
                                          ^

Perl 6 , 43 bayt - rekabetçi olmayan

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

Bir karakter listesi döndüren bir lambda.
Açıklama:

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

Bugün yalnızca git repo'ya bağlı olan ve henüz resmi bir Rakudo sürümünün parçası olmayan Rakudo Perl 6 yorumlayıcısına yapılan bir hata düzeltmesine bağlı. Aslında, bu zorluğa cevap verirken hatayla karşılaştım ve Perl 6'nın temel geliştiricilerinden birinin yardımı ile çözülmeyi başardım. Bu sitenin kuralları, onları anladığım gibi, cevapların böyle bir durumda rekabet etmesine izin vermiyor, bu yüzden onu rakipsiz olarak işaretledim.

PHP 7.0+, 110 bayt

Tanrı bitsel dizeleri korusun!

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

\nGerçek bir * NIX tarzı yeni satırla değiştirin .
Yeni satırlarla ilgili sorunlardan kaçınmak için kodda bulunur, ancak puanda sayılmaz.

Bu bir sürü uyarı verir, ancak bunlar @her yolunun önüne ekleyerek bastırılabilir _.

Ücretsiz , 113 bayt uyarı

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

65c02 makina dili + Elma] [ROM, 25 bayt

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

Yazdırır abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.

Başlamalı $8000.

sökme

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   

bash (linux'ta), 507 493 490 485 bayt

bu, global değişkende bir karakter dizisini saklar. __

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

yeni açılmış bir linux makinesinde /procya da pid ad alanı gibi bir şeyde yürütülmesi gerekiyor

açıklama:

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

denemek declare -p __için sonucu görüntülemek için sonuna ekleyebiliriz

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

Javascript, 1273 1351 1610 bayt

Bu çözüm, bu iş parçacığı üzerinde diğer iki yanıt olarak temelde aynı şekilde çalışır burada ve burada o mektuplar kullanır true, false, undefined, ve [object Object]diğer harfleri oluşturmak gerekiyor fonksiyonları inşa etmek dizeleri.

Çok sayıda harf zaten nesneye konulduğundan, kalan tüm eksi harfleri ve sayıları nesneye eklemeye çalıştım ve sonra nesnenin içindeki toUpperCasetüm değerlere, eksik majuscule harfleri oluşturmak için uygulanmaya çalıştım .

Güncelleme:

Sekizlik değerlerin ayarlanma şeklini geliştirebildim, ancak yine de 13 x 30 bayt alıyorlar (veya sayıları farklı anahtarlara değiştirdikten sonra her biri 30 bayt olacak), şimdi her biri bu genel durumu izliyor kalıbı: $.ž=\'\\'+$.一+$.七+$.二+'\';.

Sayıların tuşlarını 2 baytlık karakterlere çevirerek 49 bayt daha kolayca çıkarılabilir.

Mevcut gönderim:

$=~[];_={ť:!""+"",ň:![]+"",û:$._+'',ô:{}+"",ø:''};$={零:++$,ƒ:_.ň[$],ť:_.ť[$],一:++$,â:_.ň[$],ř:_.ť[$],ô:_.ô[$],ň:_.û[$],二:++$,ľ:_.ň[$],û:_.ť[$],ƅ:_.ô[$],ď:_.û[$],三:++$,ŝ:_.ň[$],ĵ:_.ô[$],四:++$,ě:_.ň[$],五:++$,ĉ:_.ô[$],î:_.û[$],六:++$,七:++$,八:++$,Ô:_.ô[$],九:++$};_.ĉ=$.ĉ+$.ô+$.ň+$.ŝ+$.ť+$.ř+$.û+$.ĉ+$.ť+$.ô+$.ř;_.ř=$.ř+$.ě+$.ť+$.û+$.ř+$.ň;_.ƒ=(0)[_.ĉ][_.ĉ];_.ƒ(_.ƒ(_.ř+' "$.Û=\'\\'+$.一+$.二+$.五+'\';$.Ĉ=\'\\'+$.一+$.零+$.三+'\';$.Ě=\'\\'+$.一+$.零+$.五+'\';$.ĝ=\'\\'+$.一+$.四+$.七+'\';$.ĥ=\'\\'+$.一+$.五+$.零+'\';$.ǩ=\'\\'+$.一+$.五+$.三+'\';$.ӎ=\'\\'+$.一+$.五+$.五+'\';$.ƥ=\'\\'+$.一+$.六+$.零+'\';$.ǫ=\'\\'+$.一+$.六+$.一+'\';$.ư=\'\\'+$.一+$.六+$.六+'\';$.ŵ=\'\\'+$.一+$.六+$.七+'\';$.ӽ=\'\\'+$.一+$.七+$.零+'\';$.ŷ=\'\\'+$.一+$.七+$.一+'\';$.ž=\'\\'+$.一+$.七+$.二+'\';"')())();_.ƒ(_.ƒ(_.ř+' "_.â=\''+$.Ô+$.ƅ+$.ĵ+$.ě+$.ĉ+$.ť+'.'+$.ǩ+$.ě+$.ŷ+$.ŝ+'($).'+$.ƒ+$.ô+$.ř+$.Ě+$.â+$.ĉ+$.ĥ+'\';_.ƅ=\''+$.ť+$.ô+$.Û+$.ƥ+$.ƥ+$.ě+$.ř+$.Ĉ+$.â+$.ŝ+$.ě+'\';"')())();_.ƒ(_.ƒ(_.ř+' "'+_.â+'((ǩ)=>{$[ǩ.'+_.ƅ+"()]=($[ǩ]+'')."+_.ƅ+"()});"+_.â+"((ǩ)=>{_.ø+=$[ǩ];});"+$.â+$.ľ+$.ě+$.ř+$.ť+'(_.ø);"')())()

C (clang) , 164 bayt

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

Çevrimiçi deneyin!

Bu, 1 değerinden başlayarak karakterleri alan (özden çıkarma ve artan) özyinelemeli bir işlevdir ve ondan diğer tüm sayıları oluşturur.

Ungolfed / Açıklama:

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

CJam , 15 bayt

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

Çevrimiçi deneyin!

açıklama

"{`[@:/" 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.

8, 8 karakter / 19 bayt

ᶐ+ᶛ+⩥Ⅹă⬯

Burada dene!

ᶐbüyük harftir ᶛ, küçük harftir ve ⩥Ⅹă⬯( ⩥) 0ile 10( Ⅹunicode romen rakamı) eksi arasında 1( ă) hiçbiri ( ⬯) ile birleştirilir.