BrainFuck ile 1000 kez 'A' yazdırın

'A' 1000 kez yazdırmak için en iyi BrainFuck kodu nedir (kod boyutu açısından)?

Benim yaklaşımım:

'A'yı p [0] olarak ayarlayın
255 'A' görüntülemek için 255'i p [1] olarak ayarlayın, 3 kez
235 'A' görüntülemek için 235'i p [1] olarak ayarlayın

Bu etkili değil ama yedekte sayıcıları aynı anda bir çarpma gibi kullanmanın bir yolunu bulamıyorum

Çarpma işleminden daha iyi bir yaklaşım var mı?

Daha genel bir soru: Mümkün olan en küçük koda sahip çok sayıda sayı ile çarpma kuralı var mı?

code-golf tips brainfuck

— Nelson G.
kaynak

Bu , başlamak için iyi bir yerdir. Kod golf hoş geldiniz! :)

— FryAmTheEggman

Sadece iç içe bir döngü kullanmak istediğinizi düşünüyorum, ama BF'yi çok iyi tanımıyorum. Brainfuck ipuçlarını gördün mü ? Ayrıca muhtemelen Brainfuck sabitlerindeki esolangs sayfası burada yararlı bir kaynak olacaktır.

— Jonathan Allan

En iyi BrainFuck kodunu açıklığa kavuşturmanız gerektiğini düşünüyorum . En az +karakter veya sadece en yüksek kısalık kullanarak en okunabilir, en zarif olanı mı arıyorsunuz?

— Jonathan Frech

@Jonathan Allan: Evet, bu sorunun amacı: İç içe döngü nasıl kullanılır? ASM'ye yakın büyüleyici bir dil ama bazı yönleri anlamıyorum

— Nelson G.

Bu varyantı BF'de kullanabilir miyim -> github.com/gergoerdi/brainfuck64

— Shaun Bebbers

Yanıtlar:

Şu anda kullanmakta olduğunuz yöntem 39 bayttır:

>>+++[<-[-<.>]>-]++++[<----->-]<-[-<.>](alma dahil değil A) ( Çevrimiçi Deneyin! )

(döngü 3 kez, her seferinde sayacı 255 olarak ayarlayın ve bunu birçok kez yazdırın, sonra 20'yi çıkarın, 1'i çıkarın ve birçok kez yazdırın)

Ancak, 250 kez döngü yapmak ve her seferinde 4 kez yazdırmak çok daha kısadır (bunu orijinal loop-4 loop-250 print-1 çözümüm üzerinden optimize etmek için jimmy23013 sayesinde):

>------[<....>-] (16 bayt)

Hücreleriniz sınırsızsa (8 bit olduklarını varsayarım, aksi takdirde golf için 255 kullanmayı denemezsiniz):

>>++++++++++[<++++++++++[<..........>-]>-] (42 bayt).

— HyperNeutrino
kaynak

Bu 8-bit hücreler varsayıyor gibi görünüyor ...

— John Dvorak

@JohnDvorak: Soru OP'nin düşünebileceği en etkili çözümün bir parçası olarak 255 olarak ayarlandığından bahsetti. Bu, 8-bit hücre sargısının kullanıldığı (ab) 'nin oldukça açık bir göstergesi gibi görünüyor.

— randomdude999

@ Randomdude999 ne dedi, ama hücrelerin sınırsız olması durumunda 10x10x10 kullanarak bir yöntem ekledim.

— 19:37

250 kat ....daha kısa olurdu.

— jimmy23013

@ jimmy23013 ... nasıl bu hala LOL yapmak için benim 10x10x10 çözüm optimize optimize etmedi emin değilim. Teşekkürler!

— HyperNeutrino

47 Bayt (Yetersiz Akış Yok)

Bu çözümü sadece 47 baytta yaptım. Ben normalde iki değer arasında sayaçları hokkabazlık yerden tasarruf etmeye çalışacağımdan farklı bir şekilde yapmaya çalıştım. A'nın p [4] içine önceden yüklendiğini varsayar.

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

Açıklaması

Place 5 into p[0]
+++++
Loop 5 times to put p[1]=20, p[2]=25
[>++++>+++++<<-]>
Loop 20 times
[>
Move pointer to p[2] and loop 25 times.
Also move p[2] to p[3]

[
Increment p[3] from 0, effectively moving the value from p[2] to p[3]
>+
Print p[4]
>.
Decrement p[2]
<<-]
Shift over to p[3]
>
[
Decrement p[3]
->
Print p[4]
.<
Increment p[2]
<+>]
Move back to p[1] and decrement
<<-
Repeat until p[1] is 0
]

— Josh Bacon
kaynak

'A' için 65 sayısını almanın en kısa yolu budur >+[+[<]>>+<+]>ve sonra >------[<....>-]bunun sonuna HyperNeutrino'nun eklenmesi yeterlidir . tam kod olur >+[+[<]>>+<+]>>------[<....>-](30 bayt)

— yay Burcu
kaynak

Bu yolun en kısa olduğunu nereden biliyorsun? Kesinlikle daha kısa ama kimsenin daha kısa bir tane bulamayacağından emin misiniz?

— Ad Hoc Garf Hunter

28:>+[+[<]>>+<+]------[>....<-]

— jimmy23013

@ SriotchilismO'Zaic evet gerçekten en kısa lol olduğunu kastetmedim

— Yay