Göreviniz tam yazdırılabilir ASCII uzayda karakterleri (yazdırır (sadece yazdırılabilir ASCII karakterleri ve / veya sekmeleri ve yeni satır kullanarak) bir program oluşturmaktır 0x20için 0x7e) yok ancak, herhangi bir sırada (programınızın kaynak kodunda görünür İstediğin çoğu

Herhangi bir dilde bunu yapmak için en kısa kod kazanır.

GolfScript, 15 12 karakter

{`),32>^.}.~

Dayanarak Jan Dvorak'ın cevap birkaç katlanmış ile ve ayrıca tarzında Peter Taylor'ın biri .

Polyglot, 95

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

• Perl
• Perl 6
• Herhangi * nx benzeri kabuk ( tclsh, bash, sh, ksh, vs.)
• Awk (GNU / POSIX)
• Brainfuck , Brian & Chuck , diğer türevler
• Yakut
• coffeescript
• Golfscript
• piton
• R,
• Julia
• Beyaz boşluk
• rk
• Gaot ++
• İSA'DAN önce
• jq
• Sevinç
• Tcl
• 99
• V (FMota)
• Acc !!
• C - main()gerekli değilse . Urogen sayesinde
• Muhtemelen daha fazla.

Hiç birşey yapmıyor.

PHP 5.2, 4

<?<<

Adlı bir dosya olarak kaydetme NYUIOMK()'DEAQRWVX[Z]\^@CBGFJqwv{z}|~`bgfkj203547698;=>!#"%$&+*-.phpbir yerlerde /home. short_open_tagolması gerekir OnGözlerinde farklı php.ini.

Çıktı:

PHP Parse error:  syntax error, unexpected T_SL in /home/wherever/NYUIOMK()'DEAQRWVX[Z]\^@CBGFJqwv{z}|~`bgfkj203547698;=>!#"%$&+*-.php on line 1

JavaScript - 88

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

"bcdfghijkmnpquvxyz" yazdırır

Boşluk, 61 57 karakter

En kısa değil ama muhtemelen en basit mantığa sahip (gerçekten sadece bir döngü).

Burada S tamamen boşluk bırakıldı, T sekmeli, L satır beslemeli:

SSSTSSSSSL     # push 0x20
LSSSL          # label S
SSSTL          # push 1
TSSS           # add
SLS            # duplicate top of stack
SLS            # duplicate again
TLSS           # output ASCII character
SSSTTTTTTSL    # push 0x7E
TSST           # subtract (result - 0x7E)
LTTSL          # branch to label S if top of stack is negative
LLL            # end

Yukarıdakileri düzeltmek için @rese teşekkürler (şube talimatı için ek kopya gerekir) ve daha küçük sayıları yığına itmek için.

C, 83 74 69 karakter

main(z) {for(;++z<96;"\33iE!vk?}GkRP8z"[z/7]&1<<z%7&&putchar(z+32));}

Gerçekten 80 karakterin altına indirmeye çalıştım, ancak henüz başaramadım. Sonunda elimden gelenleri göndermeye karar verdim, benim (veya başkasının) bunu gönderdikten on dakika sonra 79 karakterli bir çözüm bulacağım. Tamam, on dakika değildi, ama prensip olarak işe yaradı.

Gerçekten kaynak kodunda boş bir alana sahip olması gerekmeyen bir sürümü yayınlamak istedim, ancak bir avuç çözüm arasında zıplayan garip bir çekicinin yörüngesine indi. Onlardan birini kararlı bir çözüme sokmaya çalıştıktan birkaç dakika sonra pes ettim ve alanı ekledim.

Golfscript, 26 24 karakter

"126,32>''+".~\-'.~\-"'-

Bir aralık oluşturma komut dosyasını alır, çoğaltır, yürütür, sonucundan çıkarır, ardından sonuç çıkarma kodunu ve diğer alıntı karakterini çıkarır.

Balık - 80

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

Balık hataları çıktığında "bir şey balık kokuyor ...". Z hatalı bir komut olduğundan, hemen hata veriyor

Yarışma kazanmadığını biliyorum. Sadece normalde kullanılmayan bir dilde denemek istedim, sadece tekmeler için.

Java - 209 195 152 140 karakter

class a{public static void main(String[]a){for(char c=0;;c++)System.out.print("publicas{tvodmn(Srg[])h=0;w+ye.\"\\xO<?:}".indexOf(c)<0?c:"");}}

Satır sonları ve sekmelerle

class a{
    public static void main(String[]a) {
        for(char c=0;;c++)
            System.out.print("publicas{tvodmn(Srg[])h=0;w+ye.\"\\xO<?:} ".indexOf(c)<0?c:"");
    }
}

Çalıştıysanız dikkatli olun: program sonlandırılmaz. haha

açıklama

1. for(char c=0;;c++): A bir chargibi değerlendirilebildiğinden int, buradaki avantajımı, tüm olası değerlerini artırmak için kullanıyorum c. Programın sonlandırılması gerektiği belirtilmediğinden, karakterlerden tasarruf etmek için döngüdeki sonlandırma koşulunu (iki noktalı virgül arasına girecek olan) atlarım. :)
2. "publicas{tvodmn(Srg[])h=0;w+ye.\"\\xO<?:} ".indexOf(c)<0?c:"": Ne yazık ki, çok şık bir yaklaşım değil, ama işi halleder. Kaynak kodunda bulunan her karakteri Stringdeğişmez olarak manuel olarak listeleyin , ardından akımın char ciçinde olup olmadığını kontrol edin indexOf(). Eğer indexOf()çağrı geri gelirse, -1mevcut olmaz ve bu yüzden yazdırmalıyız. Geri kalan kısım sadece karakter ve alan kazanmak için üçlü operatörü kullanır.

Perl, 49 karakter

say grep/[^+-246\[-^aceghmprsy]/,map chr,041..126

Bu ilginç bir zorluk - bu bir çeşit anti-quine ve programda görünen karakter aralığını artırarak programı birkaç kez kısaltmayı başardım .

Ruby, 81 78 68 66 62 57

(?!..?~).map{|a|$><<a if/[()ifmap{}|?!.~\/\\\[\]$><]/!~a}

Basitçe kendini kontrol eder. Yinelenen karakterler el ile kaldırıldı.

4 karakter kaydettiğin için Josh'a ve 5 karakter kaydettiğin için minitech'e teşekkürler!

Befunge (48)

<|::-1,+*88:<+3*87
6<@.**85
9>"()~&"/%$ |!#';=?}

Çıktılar: {zyxwvutsrqponmlkjihgfedcba` _ ^] [ZYXWVUTSRQPONMLKJIHGFEDCBA240

Çok ciddi değil, ama gitmem gerekti:

JSFuck (138152)

(burada derlenmiş kaynak)

Orjinal kaynak:

for(x=0x7e;x>0x19;x--){
    console.log(String.fromCharCode(x).replace(/[\[\]!\+\(\)]/ig, ''))
}

() + [] Hariç tüm karakterleri yazdırır !

Göreviniz bir program oluşturmak (yalnızca yazdırılabilir ASCII karakterlerini ve / veya sekmeleri ve yeni satırları kullanarak)

Tanrım, APL için zorlaştırdın (Bu kasıtlı mı?)
Bu yüzden Tüm Kuralları Yoksaymaya karar verdim !!!

APL (Dyalog), 3 10

⎕AV

Atomik vektörü yazdırır (tüm yazdırılabilir ASCII karakterlerini içerir)

Anladığım kadarıyla "olmadan" kısmını unuttum ...
Ama bu kolay bir düzeltme

⎕AV~'AV'''

~'AV'''exclude ( ~), A, V karakterleri ve tekli teklif (iki misli tekli tırnak işareti olarak kaçılır) anlamına gelir.

ASCII olmayan baskıyla ilgili olarak, Tüm Kuralları Yoksayım.

GolfScript ( 18 16 karakter)

"),@`^^32>#.~".~

Doğruluk kontrolü yapan ve hatalı karakter sayısını gösteren ekstra bir satıra sahip çevrimiçi demo .

(Çeşitli eşdeğer alternatiflerim var. @`^İle değiştirilebiliyor \\`; #değiştirilebiliyor `veya değiştirilebiliyor ]. Doğru kombinasyon Howard'ın hilesiyle 15 puanını eşitlemek için kullanılabiliyor, çünkü ters eğik çizgiler dize değişmezlerinde olduğu gibi bloklar halinde kaçmak zorunda değil: {),\`^32>].~}.~Ancak Howard bu numara için krediyi hak ediyor).

Brainfuck, 173

+++++[->++++++<]>>>++[------<+>]<++++>>----[----<+>]>-[-------<+>]>-[---<+>]<------->>-[---<+>]<+++++++++>>--[-----<+>]<+++++>>+[---------<++>]+++++++++++++[<[.+<]>[>]<-]\=,

Çok uzun zaman sonra tekrar deneyebilirim.

J ( 5240 )

Düzenleme: Duh, unuttum e.

'''(-@.e#[)~95{32}a'(-.@e.#[)~95{.32}.a.

Eski versiyon:

(>@(*/@('(>@*/''&~:).#]32{95}a'&~:)&.>)#])95{.32}.a.

Diğer değişken (aynı uzunluk fakat daha az çıkış):

([#~*/"1@('([#~*/"1@''&:0)95{.32}a'&~:"0))95{.32}.a.

Python 3 - 68 61

x=r"print(*set(map(chr,range(32,127)))-set(x+'=\"'))"
exec(x)

... iyileştirmeler için @WolframH'e teşekkürler.

PowerShell: 96

Bir komut dosyası olarak kaydedilmeli ve çalıştırılmalıdır.

diff([char[]](gc $MyInvocation.InvocationName))([char[]](32..126))-Pa|?{$_.SideIndicator-eq'=>'}

diffiçin yerleşik bir takma addır Compare-Object.

gciçin yerleşik bir takma addır Get-Content.

$MyInvocation.InvocationName yürütülen betiğin tam yolunu alır.

32..126için ondalık eşdeğeridir 0x20..0x7eve bu nedenle aradığımız ondalık ASCII kodunun bir dizisini oluşturur.

[char[]]Bir sonraki nesnenin içeriğini alır ve onları bir diziye koyar, parçalar ve ASCII karakterlerine dönüştürür. Böylece, şimdi iki ASCII karakter dizisine sahibiz - biri bu senaryodan, diğeri ise meydan okuma kriterleriyle tanımlanmış.

-PaCompare-Object"Passthru" biçimine ayarlar , bu nedenle yalnızca girişler arasında farklı bulunan öğeler konsolda çıkarılır - hangi girişin nesnenin verilerinde hala girişin bulunduğu, ancak görüntülenmeyen göstergeler.

|?{$_.SideIndicator-eq'=>'}boruların Compare-Objectçıkışını Where-Object, yalnızca ikinci girişe özel olan öğelere filtreleyen çıkışlar .

PHP - 92

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

Çıktı:

hiçbir şey değil

OP kullanılmayan tüm karakterleri yazdırmayı istiyor, ben hepsini kullanıyorum

Javascript, 92

(function f(){for(i=32;126>i++;)!~(""+f).indexOf(c=String.fromCharCode(i))&&console.log(c)})()

Java - 126 karakter

minimize:

class hjq{public static void main(String...w){for(char z='"'|0;++z!='a';)if("'()+.0;=OS".indexOf(z)==~0)System.out.print(z);}}

unminimized:

class hjq {
    public static void main(String... w) { 
        for (char z = '"'|0; ++z != 'a';) {
            if ("'()+.0;=OS".indexOf(z) == ~0) {
                System.out.print(z);
            }
        }
    }
}

Bu ilginç bir sorundur, çünkü bireysel semboller karakterleri yeniden kullandığı için uzun formlarından faydalanabilir. Örneğin, normalde String[]daha kısa olur, ancak String...koşullu dizgede köşeli parantezlere olan ihtiyacı ortadan kaldırır.

İşin püf noktası, aralığın başında ve sonunda karakterleri denemek ve kullanmaktı, böylece sadece döngü başlangıcınızı ve sonunuzu değiştirerek onları çıktıların dışında tutabilirsiniz.

Java için dışlanacak anahtar bir karakterdir ", çünkü dizgede bunun olması kaçmak ister, ekleyen \dizeye gitmek için programınıza eklenir \\. "Koşullu dizginizden çıkardığınızda 4 karakter kaldırırsınız. Bu, kullandığınızdan ve !döngü baştan başladığınızdan emin olarak sağlanabilir #.

Bütün küçük harfler, yalnızca sona aralığının sonuna yakın görünen {, |, }ve ~peşlerinden. Java'nın ayrıntılarından dolayı, küçük harflerin çoğu sadece kazan için kullanılır. Aynı şekilde {ve }bir Java programı için de önemsizdir, çünkü kazan için bunlara ihtiyaç vardır.

|Bir şartınız veya koşulunuz varsa kullanılabilir, ancak sadece |bit bitli bir operatör olarak kullanmaktan daha kısa bir programa yol açan programdan yararlanmanın bir yolunu bulamadım . Bu |0beni biraz kirli hissetmeme neden oluyor, çünkü karaktere sahip olabilmek için bir tek parça bu.

~0Verimler -1kullanışlı, çünkü kullanmamız gereken kontrol budur indexOf. Bunu !=koşullu döngü için kullanmakla birleştirmek , <karakteri tamamen ortadan kaldırır; bu, koşullu dizginin içine girmesi gerekmediği anlamına gelir.

sh (47)

tr</dev/urandom -cd \[:print:]|tr -d "`cat $0`"

Kendi kendine referans yaklaşımını kullanır. /dev/urandomSonunda her sekizliyi en az bir kez çıkacak şekilde varsayar . Fesih değil.

Eğer bunun manyüklü olduğunu varsayarsak, bunun yerine man ascii(7)sayfasından faydalanabiliriz (ve böylece sonlandırma programına sahip olabiliriz) ( 44 karakter, teşekkürler Fennec).

man ascii|tr -cd \[:print:]|tr -d "`cat $0`"

BitShift , 1038 bayt

BitShift, yalnızca destekleyen 0ve 1sözdizimi olan bir dildir . Diğer tüm karakterleri yazdırmanın kolay olacağını düşündüm, ancak döngülemeyi gerçekten desteklemediği için hala büyük bir 1038 bayta ulaştı.
Bununla birlikte, bundan daha küçüğüne inanmanın mümkün olmadığını düşünüyorum.

101001100101011011010100110111010100100101011001101111010100100101011001000101011011010100101100110110101001001010110010001010110110101000001101010010010101100100010101101101010000010000011001010110110101000010000101011011010100110111010100100101011111100101011011010100110111010100100101011001101111010100100101011001000101011011010100000000011010100100101011001000101011011010100110010000101011011010100110111010100100101011001101001101010010010101100100010101101101010011001000010101101101010011011101010010010101111011111110010101101101010011011101010010010101100101100101011011010100010001010110110101001000010101101101010011011101010010010101110111110010101101101010011011101010010010101111111100101011011010100110111010100100101011111011110101001001010110010001010110110101001000100000101011011010100110111010100100101011111010011010100100101011001000101011011010100100000101011011010100110111010100100101011001101111010100100101011001000101011011010100010000010101101101010011011101010010010101101001101101010010010101101001101010

Baskılar

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

Burada dene

Kesinlikle buradaki en uzun çözüm, ancak Lino'da kodlama her zaman eğlencelidir:

L.in.oleum -655 523 karakter

"libraries"/arch/cpu/base;/hmi/conout;/data/bytes;/data/string/t2s;/data/heap;/data/heap/connect/mgrab;"stockfile"a;"directors"displaystatus=engage;"injection"c=524;b<-bytes.bytesizeconvert:c;b<-heap.alloc:b;a<-heap.alloc:c;[filecommand]=readfile;[filename]=stockfile;[fileposition]=0;[fileblocksize]=c;[fileblockpointer]=b;arch.fileread;[string.psource]=b;[string.ptarget]=a;string.t2s;b<-heap.alloc:7fh;c=32;d=b;"f"[d_32]=c;+c;+d;?c<7fh>f;"w"d=[a];+a;?d=0>y;?d<32>w;?d>7eh>w;e=b;e+d;[e]=33;^w;"y"b+32;"v"conout.say:b;bye;

Yorum yok, sadece ikilinin içine derlenmiş kaynağı okur. Farklı kaydet a.txtveya derlenmeyecek!

Brainfuck, 133 123 114 110 bayt

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

Eski bir çözümle ilgili biraz daha titizlikle (aşağıdakinin daha küçük olduğunu fark etmeden önce - bu durum biraz ağır optimizasyon yapmamdan önceydi). Bu, 4 ascii kümesini saklayarak ve onları zorlu bir ilmekle bastırarak çalışır ve daha sonra eksik karakterleri (yani geçersiz ascii sayıları arasında olanlar) verir.

Orijinal gönderim

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

Aşağıdakileri yapar:

• 11 içeren 4 kayıt oluşturun. 13, 28, 33
• Yazdırmaya başlamak için 31 değeriyle 5. yaratın
• Ascii yazdır 32-42 (11)
• Ascii 44 yazdır
• Baskı 47 - 59 (13)
• Ascii Yazdır
• Ascii Yazdır 63-90 (28)
• Ascii 92'yi yazdır
• Ascii yazdır 94-126 (33)

Haskell (70)

import Data.List
main=putStrLn$[' '..'~']\\" \\\"$'.=DLS[]aimnoprstu~"

Sondaj sıkıcı-karakter-in-in-dizede bir program, evrensel kümeden çıkarmak bir çözüm. Bir kod dövüşçünün kazananı olmaktan çok uzak olsa da, uzunluğu bakımından şaşırtıcı derecede okunaklı.

(Şimdi filter/ yerine liste çıkarma ile notWith)

J - 21

(u:32+i.97)-.1!:1<":5

bunu 5geçerli dizinde adı verilen bir dosyaya yaz . Sonra yükle komut dosyası ile çalıştırmak0!:1<'5'

Dosya numarası olmadan 25 veya:

(-.~".)'(":u:32+i.0-~95)'

Clojure (142, 106, 103)

(defn -main[](let[c"(fn[l](pr(reduce disj(set(map char(range 32 126)))l)));-\\\"o"]((load-string c)c)))

biçimlendirilmiş:

(defn -main []
  (let [c "(fn[l](pr(reduce disj(set(map char(range 32 126)))l)));-\\\"o"]
    ((load-string c) c)))

Bunun yaptığını düşünün, biraz tweaks gerekebilir. çıktı:

#{@ ` ! A B b # C $ D % E & F ' G H I * J + K k , L M . N / O 0 P Q q R S 4 T 5 U V v 7 W w 8 X x 9 Y y : Z z { < | = } > ^ ? _}

değerlendirilebilir clojure kodu olan dizeyi kendi üzerinde çalıştırır. Dize sonunda dize dışında kullanılan karakterleri almak için bazı yorumlar vardır (ana yöntem, vb.)

Python 2, 69

for x in range(38):print chr(x+59)#!"$%&'*,-./012467bdjklmqsuvwyz{|}~

En uzun (bulabildiğim) sürekli karakter dizisini yazdırabilir ve diğerlerini koddan sonra yorum olarak ekleyebilirim.