Bu meydan okuma ilk ezoterik dilim Backhand !

Backhand doğrusal olmayan bir işaretçi akışı olan tek boyutlu bir dildir. İşaretçi bir seferde üç adım hareket eder, yalnızca her üç talimatı uygular.

Program 1..1..+..O..@sonlandırmadan önce 1 + 1 ve çıkış 2 ekleyecektir. Ara talimatlar atlanır, dolayısıyla 1<>1()+{}O[]@tam olarak aynı programdır.

İşaretçi, bandın ucundan çıkmak üzereyken, bunun yerine yönü tersine çevirir ve başka bir şekilde adım atar 1.@1.O+., aynı programdır. Son talimatı yalnızca bir kez saydığını unutmayın. Bu, çoğu doğrusal programı1O+1@

Buradaki zorluk, bir dizge alan bir program veya işlev yazmak ve program Backhand gibi yorumlanırsa yürütülecek talimatları çıkarmaktır (gerçek Backhand talimatlarını kullanmanıza gerek yoktur). Yalnızca işaretçi dizenin son karakterine gelene kadar çıktı almalısınız (bu noktada yürütme normalde geriye doğru gider).

Ama bekleyin , hepsi bu değil! Programınızın kendisi bu şekilde yorumlandığında, ortaya çıkan kod aşağıdakilerden birini vermelidir:

• (Mostly) works
• Turing complete
• 'Recreational' (tırnak işaretleri ya olabilir ya 'da "her ikisi birden olamaz)
• Perfectly okay
• Only a few bugs

Örneğin, kaynak kodunuz ise code 2 backhand, program ce cankb od2ahdbu ifadelerden birini çıktılamalıdır.

Test senaryoları:

"1  1  +  O  @"  -> "11+O@"
"1O+1@"          -> "11+O@"
"HoreWll dlo!"   -> "Hello World!"
"abcdefghijklmnopqrstuvwxyz" -> "adgjmpsvyxurolifcbehknqtwz"
"0123456789"     -> "0369"  (not "0369630369")
"@"              -> "@"
"io"             -> "io"  (Cat program in Backhand)
"!?O"            -> "!?O" (Outputs random bits forever in Backhand)
"---!---!"       -> "-!-----!"

Ve elbette Backhand ile yazılmış bir referans programı ( bu biraz buggy olabilir Tamam, sanırım düzelttim).

Kurallar.

• Standart Loopholes yasaktır
• İlk programın girişi yalnızca yazdırılabilir ASCII ve yeni satırlar (bayt 0x20- 0x7Eyanı sıra 0x0A) içerecektir.
• İkinci programınızın ilk bayttan mı yoksa UTF-8 karakterlerinden mi dönüştürüleceğini seçebilirsiniz.
• İkinci program:
  • Durum önemli değil , bu nedenle çıktılarınız olabilir pErFectLy OKay.
  • Herhangi bir miktarda izleyen / önde gelen boşluk (satırsonu, sekmeler, boşluklar) da uygundur.
  • İkinci program birinciyle aynı dilde olmalıdır, ancak aynı formatta olmamalıdır (program / işlev)
  • Ekstra ifadeler hakkındaki yorumlardan (çok kısa olmadıkları sürece) öneriler eklemekten memnuniyet duyuyorum
• Bu kod golf olduğundan , amacınız diliniz için en kısa cevabı almaktır!
• İki hafta içinde en kısa Backhand cevabına 200 ödül vereceğim.

R , 187 bayt

 # c  a  t  (  '  P  e  r  f  e  c  t  l  y     o  k  a  y  '  )  #
g=function(x,n=nchar(x),i=c(1:n,(n-1):1,2:n),j=seq(1,3*n-2,3),k=i[j][1:which(i[j]==n)[1]])cat(substring(x,k,k),sep='') 

Çevrimiçi deneyin!

\nProgramın kendisine uygulandığında hiçbir zaman yazdırılmaması için sondaki tek boşluk gerekir.

açıklama

Bölüm 1:

Ungolfed:

 # c  a  t  (  '  P  e  r  f  e  c  t  l  y     o  k  a  y  '  )  #
g <- function(x) {
  n <- nchar(x)                      # number of characters in string
  i <- c(1:n, (n - 1):1, 2:n)        # index: 1 to n, n-1 back to 1, 2 to n
  j <- seq(1, 3 * n - 2, 3)          # every third element of i
  k <- i[j][1:which(i[j] == n)[1]]   # the elements of i at indices j, up to the first appearance of n
  cat(substring(x, k, k), sep = "")  # extract from x the characters at indices k, and paste them together
}

Bölüm 2:

İşlev, programın tamamı üzerinde çalıştığında bunu üretir:

cat('Perfectly okay')#=ni(ncr)=1,-:2)=q,n,,i]:i(j=[]assi(k)e' 

Python 2 , 163 130 127 121 115 99 96 bayt

i=input() ###
print(i+i[-2:0:-1]+i)[:len(i)*(len(i)%3%2or 3):3]  

#'p lr+yi  n'ottk(ca'eyPf'er)

Çevrimiçi deneyin!

Çıktılar:

int #rt+-01i:n)l(%2 : 
print('Perfect' + # 33o3ie*(l)]:2i(i
#(p=iu)#pni[:-+[ei(n)%r)]
'ly okay')

Perl 6 , 101 86 bayt

Vay be, ilk programı önemli ölçüde geliştirerek nwellnhof sayesinde -25 bayt

##
{S:g/(.).?.?/$0/}o{.comb%3-1??.chop~.flip~S/.//!!$_} #
#}{ "" s( kM ro os wt  l )y.

Çevrimiçi deneyin!

Daha fazla insanın bu şekilde yükselişten faydalanmasını umuyorum. Backhanded programı

#{g.?//{o%1.o.iS/!}
{"(Mostly) works"}#_!.~l~h?-bco0?.(:
#S/).$}.m3?cpfp//$ #        .

Hangi sadece dışarı yorum {"(Mostly) works"}.

05AB1E , 43 40 38 37 bayt

@Emigna sayesinde -2 bayt (40 → 38) .

„€€Ã€„Ѐ€µ'€Ý)\[ûDN3*©è  ?®IgD#<ÖNĀ*#

Çevrimiçi deneyin . (Not: dili geçiş 05AB1E (eski) için 05AB1E test durumu için 0123456789. Eski model daha hızlı, ancak sıfır dolgulu sayı girişleri için yanlış sonuçlar gösterir.)

'Backhanded' programı:

„ÃеÝ[N© I#N#

Hangi perfectly okaytam küçük harfle çıktı .

Çevrimiçi deneyin.

Açıklama tabanı programı:

„€€Ã€           # Push the string "the pointed"
„Ѐ€µ           # Push the string "dm one"
'€Ý            '# Push the string "been"
     )          # Wrap the entire stack in a list
      \         # And remove that list from the stack again
[               # Start an infinite loop
 û              #  Palindromize the string at the top of the stack
                #   i.e. "1O+1@" becomes "1O+1@1+O1" the first iteration,
                #        and "1O+1@1+O1O+1@1+O1" the next iteration, etc.
  D             #  Duplicate the palindromized string
 N3*            #  0-indexed index of the loop multiplied by 3
    ©           #  Save it in the register (without popping)
     è?         #  Index into the string and print the character
  Ig            #  If the length of the input is exactly 1:
     #          #   Stop the infinite loop
 ®  D <Ö        #  If the value from the register is divisible by the length - 1
          *     #  And
        NĀ      #  The 0-indexed index of the loop is NOT 0:
           #    #   Stop the infinite loop

'Backhanded' program açıklaması:

„ÃÐµÝ           # Push the string "perfectly okay"
     [          # Start an infinite loop
      N©        #  Push the index, and store it in the register (without popping)
          I     #  Push the input (none given, so nothing happens)
           #    #  If the top of the stack is 1, stop the infinite loop
            N   #  Push the index again
             #  #  If the top of the stack is 1, stop the infinite loop

Adım adım aşağıdakiler olur:

1. „ÃеÝ: STACK, ["perfectly okay"]
2. [: Sonsuz döngüyü başlat
3. (ilk döngü yinelemesi) N©: STACK["perfectly okay", 0]
4. (ilk döngü yineleme) I: STACK ["perfectly okay", 0]girdi olmadığından kalır
5. (ilk döngü yinelemesi) #: STACK olur ["perfectly okay"]ve döngü devam eder
6. (ilk döngü yinelemesi) N: STACK["perfectly okay", 0]
7. (ilk döngü yinelemesi) #: STACK olur ["perfectly okay"]ve döngü devam eder
8. (ikinci döngü yinelemesi) N©: STACK["perfectly okay", 1]
9. (ikinci döngü yineleme) I: STACK ["perfectly okay", 1]girdi olmadığından kalır
10. (ikinci döngü yinelemesi) #: STACK olur ["perfectly okay"]ve 1(doğruluk) nedeniyle döngü kırılır
11. Yığının üstünü örtülü olarak STDOUT'a yazdırır: perfectly okay

TIO'daki hata ayıklayıcı etkinken buradaki adımlara bakın.

Benim bu 05AB1E ucu bakın (bölüm nasıl sözlüğü kullanılır? ) Anlamak için „€€Ã€„Ѐ€µ'€Ývardır the pointed, dm oneve beenve „ÃеÝbir perfectly okay.

Eski 38 baytlık sürüm:

„€€Ã€„Ѐ€µ'€Ý)\ giqë¬?[ûDN>3*©è?®Ig<Ö#

Çevrimiçi deneyin . (Not: dili geçiş 05AB1E (eski) için 05AB1E test durumları için 0123456789ve @eski sürüm daha hızlıdır, ancak başındaki sıfırlar veya tek karakter girişi ile sayı girişleri için yanlış sonuçlar göstermektedir..)

'Backhanded' programı:

„ÃÐµÝ q?D3èIÖ<®©>û¬i\€€„€€€€')gë[N*?g#

( qProgramdan çıkıldığında ve diğer her şeyi işlem yapmadığında.)

Çevrimiçi deneyin.

Python 2 , 130 bayt

p='r'#i  n  t  '  P  e  r  f  e  c  t  l  y     o  k  a  y  '  # 
s=input();S=s+s[-2:0:-1]+s
print S[:len(~-len(s)%3and S or s):3]

Çevrimiçi deneyin!

JavaScript (ES6), 130 bayt

Erken girişim. Çok tatmin edici değil.

f  =/*>  "  P  e  r  f  e  c  t  l  y     o  k  a*/y=>""+/**/(g=p=>(c=y[p])?m++%3?g(p+d):y[p+1]?c+g(p+d):c:g(p-d-d,d=-d))(m=0,d=1)

Çevrimiçi deneyin!

Kod tek başına işlendiğinde, aşağıdaki karakterler yalıtılır:

f  =/*>  "  P  e  r  f  e  c  t  l  y     o  k  a*/y=>""+/**/…
^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^

hangi verir:

f=>"Perfectly okay"//…

Jöle , 34 bayt

JŒḄȧ`ȯ“”NNŒḄ2¡3s@”]ȧZỴḢḢ»`Qị⁸ȧ@11€

(Sırasıyla) yazdırılan veya veren karakterlerin listesini kabul eden tam bir program veya monadik bağlantı.

Çevrimiçi deneyin! Veya test takımına bakın .

Backhand çözümlü kod şöyle olur:

Jȧ“N2s]Ỵ»ị@€

Tam bir program veya niladik bağlantı yazdırma veya verme (sırasıyla) Turing tamamlandı .

Nasıl?

JŒḄȧ`ȯ“”NNŒḄ2¡3s@”]ȧZỴḢḢ»`Qị⁸ȧ@11€ - Main Link: list of characters   e.g. 'abcd'
J                                  - range of length                      [1,2,3,4]
 ŒḄ                                - bounce                         [1,2,3,4,3,2,1]
    `                              - use as both arguments of:
   ȧ                               -   logical AND [x AND x = x]
      “”                           - literal empty list of characters
     ȯ                             - logical OR [when x is truthy: x OR y = x]
        N                          - negate  }
         N                         - negate  } together a no-op
             ¡                     - repeat this...
            2                      - ... two times:
          ŒḄ                       -   bounce                       [1,2,3,4,3,2,1,2,3,4,3,2,1,2,3,4,3,2,1,2,3,4,3,2,1]
              3                    - literal three
               s@                  - split into (threes)            [[1,2,3],[4,3,2],[1,2,3],[4,3,2],[1,2,3],[4,3,2],[1,2,3],[4,3,2],[1]]
                 ”]                - literal ']' character
                   ȧ               - logical AND [']' is truthy so a no-op]
                    Z              - transpose                      [[1,4,1,4,1,4,1,4,1],[2,3,2,3,2,3,2,3],[3,2,3,2,3,2,3,2]]
                     Ỵ             - split at new lines [no newline characters exist in this list of ints so effectively wrap in a list]
                      Ḣ            - head [undo that wrap]
                       Ḣ           - head [get the first of the transposed split indices]
                                   -                                [1,4,1,4,1,4,1,4,1]
                         `         - use as both arguments of:
                        »          -   maximum [max(x, x) = x]
                          Q        - de-duplicate                   [1,4]
                            ⁸      - chain's left argument (the input)
                           ị       - index into it                  "ad"
                               11€ - literal eleven for €ach (of input)
                             ȧ@    - logical AND with swapped args [[11,11,...,11] is truthy]
                                   -                                "ad"
                                   - (as a full program implicit print)

Backhand çözümlü kod ise:

Jȧ“N2s]Ỵ»ị@€ - Main Link: no arguments
J            - range of length (of an implicit 0, treated as [0]) -> [1]
  “N2s]Ỵ»    - compression of "Turing complete"
 ȧ           - logical AND [[1] is truthy] -> "Turing complete"
           € - for each character in the list of characters:
          @  -   with swapped arguments (an implicit 0 is on the right, so f(0, "Turing complete"))
         ị   -     index into
             - (as a full program implicit print)

Runik Efsunlar , 294 bayt

>; "  O  n  l  y     a     F  e  w     B  u  g  s  "  @
                                  /{\!?   =ka:{;!?=ka\
v   R                         R {{R:ak=?!\:$:'@=?!;{:/
v/?!/:$:'@=?!;}:ak= ?!;}:ak=?!\}\        }
y\=ka:L                      }{ /        }
\iuakrU      y<<              !  }}}L {{{L

Çevrimiçi deneyin!

Sıkıştırılmamış (ve neredeyse okunabilir) sürüm:

>; "  O  n  l  y     a     F  e  w     B  u  g  s  "  @
                               ;           /                                 \
/y<<         R                         R {{R:ak=?!\:$:'@=?!;{:ak=?!\{:ak=?!\{/
RiuakrR:ak=?!/:$:'@=?!;}:ak= ?!/}:ak=?!\}\        }                ;
\y<<  U                               }{ /        }
      \                                !          L                     }}}L

Çevrimiçi deneyin!

Bu ... alabildiğim kadar yakın.

Daha fazla sıkıştırmak, çeşitli ilmek değiştirme noktalarını başka şeylerle çarpışmadan ele almanın bir yolunu bulmayı gerektirir. İlk satırın (kendisinin girdi olarak geçirilmesi gereken tek bölüm olan) ayrı kalması gerekir: tüm dize, soruna neden olmadan ikinci satıra sığamaz ( _gerekli boşluklar için):

Needed string:
>; "  O  n  l  y  _  a  _  F  e  w  _  B  u  g  s
Best fit:
>; "  O  n  l  y  _  a  _  F  e  w/{_\!?   =ka:{;!?=ka\
Collision:                             ↑

Yani ?uzak taşınamaz !hangi kendisinden uzağa taşınamaz \ve izin verilen mesajların hiçbiri bu pozisyonda bu üç karakter herhangi tanır.

Alternatif akış yönlendirme kullanmak olacaktır, ancak bu alt satırda bir soruna yol açar:

Last usable character:
            ↓
>"Only a Few Bugs"@
/.../
ur         }{L
              ↑
Earliest available free space:

Ana programdaki döngü anahtarından kaçınmamız gerektiğinden.

Bilinen Sorunlar:

• Son derece büyük girişler. Runik'in IP yığın limitleri nedeniyle, çok büyük giriş dizelerinin itilmesi, tamamlanmadan önce IP'nin süresinin dolmasına neden olur. Bu, ek IP'ler oluşturarak ve birleştirerek en aza indirilebilir (örneğin, abcdefghijklmnopqrstuvwxyzkendi kaynağının tamamını ele almaz, ancak değil). Ve kaç birleşmenin gerçekleştiğine bakılmaksızın bir sınır var. 58 bayta kadar girişi olduğu gibi işleyebilir (ek olarak, IP sayısını artırmak, daha fazla alan kullanmadan nasıl birleştirileceklerini bulmayı gerektirir). Döngü dönüş hattına ( sıkıştırılmamış versiyondan Ubaşlayarak hattın sağına \y<<veya sıkıştırılmış versiyondaki satırın soluna) iki IP girişi daha y<<girebilir ve giriş maksimum uzunluğunu 78'e yükseltir.
• Boşluklu giriş dizelerinin boşluklardan kaçması gerekir (örn. 1\ \ 1\ \ +\ \ O\ \ @). Bu, dilin girdi ayrıştırmasının bir sınırlamasıdır.
• Herhangi bir sayıda 0s ile başlayan tamsayılara benzeyen dizelerden oluşan girişler sağlanamaz (yığın üzerinde bir sayıya dönüştürüldüğünde 0, kaybolur). Yine, dilin girdi ayrıştırma sınırlaması.

Nasıl çalışır

Giriş:

1. 4 komut işaretçisi birleştir
2. Girişi okuyun, karakterlere bölün, yeni satır ekleyin, ters çevirin, ana döngüye girin.

Ana döngü (yığını açan her şey bir dup ile başlar):

1. Yığının üstünü yazdır
2. Newline ile karşılaştırın. Doğru: döngüler arasında geçiş yapar ve yığını iki kez sola döndürür.
3. İle karşılaştırın @. Doğru: sonlandır. (Sonlandırma komutu yürütüldü)
4. Yığını sağa döndür
5. Newline ile karşılaştırın. Doğru: sonlandır. (En sağdaki komut çalıştırıldı)
6. Yığını sağa döndür
7. Newline ile karşılaştırın. Doğru: döngüler arasında geçiş yapın ve yığını üç kez sola döndürün.
8. Yığını sağa döndür
9. Döngünün başına dön

İkincil döngü:

• Ana döngü ile aynı, yalnızca sola döndürerek sağa döndür