Aşağıdaki üç metin satırını tam olarak aşağıda gösterildiği gibi yazdırın veya görüntüleyin. Sondaki bir satırsonu kabul edilir.

 bC#eF&hI)kL,nO/qR2tU5wX8z
A!cD$fG'iJ*lM-oP0rS3uV6xY9
aB"dE%gH(jK+mN.pQ1sT4vW7yZ

Bu metin bloğu aşağıdakiyle aynıdır, ancak n'ci sütunun n kez aşağıya döndürüldüğü yerler:

 !"#$%&'()*+,-./0123456789
ABCDEFGHIJKLMNOPQRSTUVWXYZ
abcdefghijklmnopqrstuvwxyz

Bunun bir kolmogorov-karmaşıklık mücadelesi olduğunu aklınızda bulundurun, bu nedenle çıktı formatı esnek değildir.

Java 8, 169 162 150 146 116 113 106 95 94 93 92 92 91 90 84 bayt

Yay, sonunda başardık! Alt kısımda bulunabilecek 88 bayt değişmez çıktıyı geçtik. Golfe katılan herkese teşekkürler!

v->{for(int i=0,t=0;++i<81;System.out.printf("%c",i%27<1?10:(4-t++%3)*32%97+i%27));}

@StewieGriffin sayesinde -7 bayt . @Neil
sayesinde -42 bayt . @PeterTaylor sayesinde -11 bayt . @ OlivierGrégoire sayesinde -3 bayt . -6 sayesinde bayt OlivierGrégoire @ ve @Neil (Olivier önerdi Neil'in JavaScript cevabın bir port ).

Çevrimiçi deneyin.

Açıklama:

v->{                          // Method with empty unused parameter and no return-type
  for(int i=0,t=0;++i<81;     //  Loop from 1 to 81 (exclusive)
     System.out.printf("%c",  //   Print the following character:
      i%27<1?                 //    If it's the last column
       10                     //     Print a new-line
      :                       //    Else:
       (4-t++%3)*32%97+i%27   //     Print the correct character based on the index

Burada her aritmetik parçanın ne yaptığını ve doğru karakterlerde nasıl bittiğini görün.

Java 8, 88 bayt

v->" bC#eF&hI)kL,nO/qR2tU5wX8z\nA!cD$fG'iJ*lM-oP0rS3uV6xY9\naB\"dE%gH(jK+mN.pQ1sT4vW7yZ"

Sıkıcı, ancak amaçlanan sütunların dönüşünü kullanmak Java’da bundan daha kısa sürmeyecek .. Düzeltilmiş duruyorum! Ne kadar bayt farklı olduğunu görmek için her iki şekilde de bir çözüm yollayacak. Görünüşe göre fark sadece -4 byte! : D

Çevrimiçi deneyin.

Kabuğu , 13 bayt

Tzṙṫ26¡m→"Aa 

Sondaki boşluğa dikkat edin. Çevrimiçi deneyin!

açıklama

Tzṙṫ26¡m→"Aa   No input.
         "Aa   The string "Aa ".
      ¡        Iterate
       m→      map successor: ["Aa ","Bb!","Cc\"","Dd#",..
 z             Zip with
   ṫ26         the reversed range [26,25,24,..,1]
  ṙ            using rotation: [" Aa","b!B",..,"z9Z"]
               This also truncates the list to length 26.
T              Transpose, implicitly print separated by newlines.

SPL (Shakespeare Programlama Dili), 1679 1618 1600 bayt

.
Ajax,.
Ford,.
Puck,.
Act I:.
Scene I:.
[Enter Ajax and Ford]
Ajax:
You are the remainder of the quotient between the sum of the remainder of the quotient between the product of me and a fat joy and the sum of the cube of a big red day and the difference between a red fat pig and a big old fat cow and the quotient between me and the sum of a day and the square of the sum of a joy and a big red day and the sum of a cat and a fat son.
[Exit Ajax]
[Enter Puck]
Ford:
Am I as good as nothing? If so, you are a bad big old red fat day. Am I as good as a joy? If so, you are the sum of a joy and a the cube of an old bad day. Am I as good as a big day? If so, you are the sum of the square of the sum of a big red fat cat and an old cow and the sum of an old war and a lie.
[Exit Ford]
[Enter Ajax]
Ajax:
You are the sum of thyself and the remainder of the quotient between me and the sum of a man and the square of the sum of a son and a big fat cow. Speak thy mind!
[Exit Puck]
[Enter Ford]
Ford:
You are the sum of yourself and a son.
Ajax:
You are the remainder of the quotient between me and the sum of a cat and the square of the sum of a cow and an old red sky.
Ford:
Am I as good as nothing? If so, let us proceed to scene III.
Scene II:.
Ajax:
You are the product of the sum of a fat man and a cow and the sum of a man and the square of the sum of a cat and a big red son. Are you not better than me? If so, let us return to act I. Let us proceed to scene IV.
Scene III:.
Ajax:
You are the sum of a big old fat cat and a red cow. Speak thy mind! Let us return to scene II.
Scene IV:.
[Exeunt]

Tercüman ile ilgili bazı problemlerim vardı ( https://github.com/drsam94/Spl ), bu yüzden olabileceğimi düşündüğüm kadar küçük değil. Ama en azından bu işe yarıyor :)

İşte PHP'de aynı mantığı, neler olduğunu daha kolay görebilmenizi sağlamak için.

<?php

Act1Scene1:
$ford = ((2 * $ajax) % 52 + $ajax / 26) % 3;
if ($ford == 0) {
    $puck = 32;
}
if ($ford == 1) {
    $puck = 65;
}
if ($ford == 2) {
    $puck = 97;
}
$puck = $ajax % 26 + $puck;
echo chr($puck);

$ajax = $ajax + 1;

$ford = $ajax % 26;
if ($ford == 0) {
    goto Act1Scene3;
}

Act1Scene2:
if ($ajax < 78) {
    goto Act1Scene1;
}
goto Act1Scene4;

Act1Scene3:
$ford = 10;
echo chr($ford);
goto Act1Scene2;

Act1Scene4:

JavaScript (ES6), 86 75 bayt

f=(i=k=0)=>i<80?String.fromCharCode(++i%27?(4-k++%3)*32%97+i%27:10)+f(i):''

Düzenleme: @Ryan sayesinde 11 bayt kaydedildi. Şimdi 10 bayt değişmezden daha kısa!

JavaScript (Node.js) , 64 bayt

f=(i=k=0)=>i<80?Buffer([++i%27?(4-k++%3)*32%97+i%27:10])+f(i):''

Çevrimiçi deneyin! @Ryan'a teşekkürler.

05AB1E , 17 15 bayt

Outgolfer Erik sayesinde 2 bayt kurtarıldı

žQAuA)øε¼¾GÁ]ø»

Çevrimiçi deneyin!

açıklama

žQ                 # push the list of printable ascii characters
  Au               # push upper-case alphabet
    A              # push lower-case alphabet
     )ø            # zip
       ε           # apply to each
        ¼          # increment counter
         ¾G        # for N in [1 ... counter] do:
           Á       # rotate string right
            ]      # end loops
             ø     # zip
              »    # print list joined by newlines

CJam (18 bayt)

26{_" Aa"f+m>}%zN*

Çevrimiçi demo

teşrih

Açıkça görünen yaklaşım orijinal satırları üretmek, sıkıştırmak, döndürmek ee::m>ve geri sıkıştırmaktır. Ancak ee::oldukça uzun ve doğrudan sütunları oluşturmak daha kısa.

26{         e# For i = 0 to 25...
  _" Aa"f+  e#   Generate the unrotated column by offsets from the starting chars
  m>        e#   Rotate the appropriate distance
}%
zN*         e# Zip and join the rows with newlines

Python 2,72 bayt

x=98
exec"r='';exec'r+=chr(x/3);x+=291*(x<180)-94;'*26;print r;x-=78;"*3

Çevrimiçi deneyin!

Bu , önceki kod noktasından 60'ın altında olduğunda 31.333..ekleyerek 97ve 26her satırın sonunda çıkartarak önceki karakterden kaldırılarak çalışır .

R , 64 63 bayt

cat(intToUtf8(c(32:57,10,65:90,10,97:122,10)[(0:80*55)%%81+1]))

Çevrimiçi deneyin!

Giuseppe sayesinde -1 bayt

Buna biraz deneme yanılma ile geldim, bu yüzden kısa ve öz bir açıklama ile mücadele ediyorum. Temel olarak, karakter kodları yerine, orijinal metin bloğunu (3 * 26 artı 3 yeni satır) temsil eden 1: 81'lik daha basit bir sekansla başladım ve bu değerlerin döndürülen blokta bittiği endeksleri inceledim. Bu, her seferinde 26'lık bir düşüşü, modulo 81'i (veya eşdeğerde 55 mod 81'i arttırır) izler. O zaman bu diziyi yeniden yaratma (0:80*55)%%81+1]), gerçek unicode değerlerine haritalama c(32:57,10,65:90,10,97:122,10), karakterlere dönüştürme ve basma meselesiydi .

Japt , 17 15 bayt

"@`"
;By@=cÄ é

Çevrimiçi test edin!

açıklama

"@`"         The string "@`\x1F". The following newline sets U to this string.
;            Reset variables A-L to various values. B is set to
 B           the uppercase alphabet, which we only use to get a length of 26.
  y@         Map each column Z (initially just the letter itself) through this function:
     cÄ        Increment each char-code in U.
        é      Rotate by 1 character.
    =          Set U to the result to keep the chain going.
             This generates the 26 columns exactly how we needed them.
             Implicit: output result of last expression

7 diğer olası 15 byter:

;By@" Aa"c+Y éY
;ByÈpv)iSc+Y)éY
;ByÈ+v)iSc+Y)éY
;ByÈpv)iYd32)éY
;ByÈ+v)iYd32)éY
;ByÈpv)i32dY)éY
;ByÈ+v)i32dY)éY

CJam , 23 21 bayt

3{26{_I-" aA"=+}/N}fI

Çevrimiçi deneyin!

açıklama

3{         e# For I from 0 to 2...
  26{      e#   For i 0 to 25...
    _I-    e#     Duplicate i and subtract I. This shifts the starting
           e#     character of each line left in the following string.
    " aA"= e#     Pick the character at the start of the unrotated line
           e#     of the current character. We basically just cycle
           e#     through non-letters, lower-case, upper-case, which is
           e#     the cycle throughout the result. Due to the I-, when
           e#     We get to the second line we start from A, and on the
           e#     third line we start from a.
    +      e#     Add i to the starting character to get the correct
           e#     column.
  }/
  N        e#   Push a linefeed.
}fI

MATL , 16 bayt

1Y2tk9V:v26:l&YS

Çevrimiçi deneyin!

açıklama

1Y2     % Push 'AB...Z' (predefined literal)
t       % Duplicate
k       % Maker lowercase
9V      % Push 9, convert to string representation: gives char '9'
:       % Range. For chars, gives string from space to that
v       % Concatenate vertically. Gives a 3×26 char matrix
26      % Push 26
:       % Range. For numbers, gives numeric vector from 1 to that
l&YS    % Circularly shift each column of the first input (char matrix)
        % by the amount specified by the second input (numeric vector).
        % Implicitly display

Jöle , 13 bayt

26“ aA‘ẋs+ḶỌY

Çevrimiçi deneyin!

Nasıl çalışır

26“ aA‘ẋs+ḶỌY  Main link. No arguments.

26             Set the argument and the return value to 26.
  “ aA‘ẋ       Repeat [32, 97, 65] (code points of ' ', 'a', and 'A') 26 times.
        s      Split the result into chunks of length 26.
          Ḷ    Unlength; yield [0, ..., 25].
         +     Add [0, ..., 25] to each of the chunks.
           Ọ   Unordinal; cast all integers to characters.
            Y  Jojn, separating by linefeeds.

Perl 5 , 46 bayt

print map{chr$n+++ord,$/x!($n%=26)}($",A,a)x26

@TonHospel 'in gizli sihirbazı sayesinde 13 bayt kurtarıldı !

Çevrimiçi deneyin!

R , 88 86 bayt

cat(intToUtf8(rbind(diffinv(matrix(c(66,-32,-31),25,5,T)[,1:3],,,t(c(32,65,97))),10)))

Çevrimiçi deneyin!

R, string manipülasyonunda korkunçtur ve bazı düzgün matris yerleşiklerine sahip olmasına rağmen, rotasyonlar çok kolay yapamadığı başka bir şeydir. Mutlu bir şekilde bana R'de golf attırabilecek birine lütuf vereceğim.

Daha kısa bir cevap bulmama rağmen, 88 bayttan daha kısa olan ilk R cevabına hala 50 rep ödül vereceğim.

Galiba mümkünse kendime ödül verirdim, ama bu "sıkıcı" cevabından daha kısa bir iki bayt! Sadece R'nin geri dönüşüm için kullandığı tutkuyu kullanarak rotasyonları önlüyorum.

EDIT: kullanici2390246'nın cevabı beni çok kızdı ve bu çözüm çok daha üstün olduğundan 100 puanlık bir ödül vereceğim.

Buraya gelmek için, istenen çıktıyı ASCII kod noktalarına göre utf8ToInt(yeni satırları kaldırarak) yapıyorum , bir matris oluşturdum ve diffsütunlara göre farklılıkları elde ederek üzerlerine koştum . Orada periyodikliğe dikkat ederek diffinv, orijinali yeniden yaratmayı umarak matrisi golf golf tarzında inşa etmeye başladım .

Periyodiklik sayesinde, diffR matrisini çoklu olmayan bir uzunlukla geri dönüştürmeye zorlayarak ed matrisini yeniden oluşturabilir ve gerçekte istediğimiz sütunları çıkarabiliriz:

matrix(c(66,-32,-31),25,5,T)[,1:3]

Sonra diffinvkod sürecini yeniden oluşturmak 10, tabana bir satır (yeni satırlar) eklemek, ASCII'ye dönüştürmek intToUtf8ve catsonucu ile birlikte bu süreci tersine çeviririz .

Stax , 14 12 bayt

ü≤▐éh╢%╠£┐3]

Koş ve hata ayıkla

Ambalajsız, ağzı açılmış ve yorumlanmış gibi görünüyor.

3R26        push [1,2,3] and 26
K           cross-map using the rest of the program, printing lines implicitly
            this instruction maps over a cartesian join
  -         subtract
  " Aa"@    index into " Aa" using the subtraction result
  i+        add the iteration index

Bunu çalıştır

Bu program yalnızca ilk stax sürümünden bu yana mevcut olan özellikleri kullanır, ancak Kbaşlangıçta bu cevabı yazdığımda çapraz harita için unuttum .

Bu cevap hakkında dikkat edilmesi gereken neredeyse ilginç bir şey, bunun Rgereksiz bir talimat Kolduğudur, çünkü tamsayıları aralıklara dönüştürür. Bununla birlikte , aralarında fazladan bir byte olmadan 3ve itmek için bir yolu yoktur 26.

PowerShell , 53 bayt

0..2|%{-join(32..57|%{[char]($_+(0,65,33)[$j++%3])})}

Çevrimiçi deneyin!

Bunun Dom'un Perl cevabına benzer olduğunu görüyorum ama bağımsız olarak geldim.

Bu , örneğin, Symbol - Lowercase - Capitalyeni satırları sararken bile ( 8 - z - Aörneğin), desenin gittiği gerçeğinden yararlanır ve bu nedenle , bunları tek bir dizgeye eklemeden önce $j++%3geçerli sayıya yalnızca uygun ofseti (aracılığıyla seçilir ) ekler . Bu, üç çizgiyi ortaya çıkarmak için üç kez yapılır ( yinelemeleri koruyarak ). Bu üç satır boru hattında kalıyor ve üstü kapalı bize yeni hatları ücretsiz veriyor.$_-join$jWrite-Output

Julia 0.6 , 79 bayt

println.([prod([' ':'9' 'A':'Z' 'a':'z'][n,mod1(i-n,3)] for n=1:26) for i=2:4])

[' ':'9' 'A':'Z' 'a':'z']değiştirilmemiş 2d karakter [n,mod1(i-n,3)]dizisi, uygun döndürme ile bu diziye endeksler. prod(bir çarpım string birleştirme için kullanıldığından) bir String karakterine vektör alır. 3 dize içeren bir Vector ile sonuçlanan iki yuvalanmış Vector anlama vardır, ardından println.Vector içindeki her bir dizgiyi ve ardından yeni bir satır yazdırır.

TIO, prodbir String almak için iki karakterle çarparak (ile ) uygun yöntemden yoksundur . Bu yöntemin yakın zamanda eklendiğini biliyorum, ancak TIO sürümü bu kodun çalıştığı bilgisayarımdaki sürümle aynı görünüyor, bu yüzden TIO'da neden çalışmadığını tam olarak açıklayamıyorum.

Kopyala yapıştır örneği ( ;gerekli değildir, sadece REPL'deki fazladan çıkışı bastırır):

julia> println.([prod([' ':'9' 'A':'Z' 'a':'z'][n,mod1(i-n,3)] for n=1:26) for i=2:4]);
 bC#eF&hI)kL,nO/qR2tU5wX8z
A!cD$fG'iJ*lM-oP0rS3uV6xY9
aB"dE%gH(jK+mN.pQ1sT4vW7yZ

Kömür , 26 21 15 bayt

Ｅ³⭆⧧⟦γαβ⟧⁻κμμ

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Açıklama:

 ³              Literal 3
Ｅ               Map over implicit range
   β            Lowercase letters
  ⭆             Map over characters and concatenate
            κ   Outer index
             μ  Inner index
           ⁻    Subtract
       γ        Printable characters
        α       Uppercase letters
         β      Lowercase letters
     §⟦   ⟧     Circularly index into list (selects one of the three strings)
              μ Inner index
    §           (Circularly) index into string
                Implicitly print each inner map result on a separate line

J , 29, 2725 bayt

FrownyFrog sayesinde -2 bayt Km sayesinde -2 bayt

 |:u:(<26)2&(|.>:)32 65 97

Çevrimiçi deneyin!

İlk yaklaşım: J , 29 bayt

u:(-|."_1&.|:32 65 97+/])i.26

Açıklama: i.26- 0-26 aralığı

   i.26
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

32 65 97+/] - karakterler için 3 sıralı bir tablo oluşturun

   32 65 97+/i.26
32 33 34  35  36  37  38  39  40  41  42  43  44  45  46  47  48  49  50  51  52  53  54  55  56  57
65 66 67  68  69  70  71  72  73  74  75  76  77  78  79  80  81  82  83  84  85  86  87  88  89  90
97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122

&.|:transpoz sonra bir sonraki fiili ( |.) yapın ve tekrar transpozisyon yapın

-|."_1 her satırı n kere döndür

     (-i.26)|."_1|:32 65 97+/i.26
 32  65  97
 98  33  66
 67  99  34
 35  68 100
101  36  69
 70 102  37
 38  71 103
104  39  72
 73 105  40
 41  74 106
107  42  75
 76 108  43
 44  77 109
110  45  78
 79 111  46
 47  80 112
113  48  81
 82 114  49
 50  83 115
116  51  84
 85 117  52
 53  86 118
119  54  87
 88 120  55
 56  89 121
122  57  90

u: unicode'a dönüştür

    u:(-i.26)|."_1&.|:32 65 97+/i.26
 bC#eF&hI)kL,nO/qR2tU5wX8z
A!cD$fG'iJ*lM-oP0rS3uV6xY9
aB"dE%gH(jK+mN.pQ1sT4vW7yZ

Çevrimiçi deneyin!

C, 70 69 67 60 64 bayt

i;f(t){for(i=t=0;++i<81;putchar(i%27?(4-t++%3)*32%97+i%27:10));}

Fonksiyonu tekrar kullanılabilir hale getirmek için +4 bayt .

Yeniden kullanılamayan geçersiz 60 baytlık cevap:

i,t;f(){for(;++i<81;putchar(i%27?(4-t++%3)*32%97+i%27:10));}

Port Benim Java 8 cevap @Neil 'ın JavaScript cevap .

Çevrimiçi deneyin.

APL + WIN, 26 bayt

Endeks kökenli 0

⎕av[(-⍳26)⊖32 65 97∘.+⍳26]

APL atomik vektöründeki karakterlerin tamsayı dizin değerlerinin bir matrisini oluşturun.

Her sütunu sayı değerine göre aşağı doğru döndürün.

Atom vektöründen karakterleri görüntülemek için elde edilen endeksleri kullanın.

Vim, 81 79 bayt

a !"#$%&'()*+,-./0123456789␛:h<_␍jjYZZpPgU$klqq"aDjlma"bD"ap`ajD"bpkkp`akl@qq@q

Açıklama (basitleştirilmiş)

a !"#$%&'()*+,-./0123456789␛    Insert the first line
:h<_␍jjYZZpPgU$                  Insert the alphabet twice by copying it from the help page
klqq                             Define the loop `q`:
"aDjl                             Cut the rest of the line to `a`
ma"bD"ap                          Replace the rest of the second line (cut `b`, paste `a`)
`ajD"bp                           Replace the rest of the third line (cut `c`, paste `b`)
kkp                               Paste `c`
`akl@qq@q                        Run the loop, each time one more step to the right

C, 72 bayt

f(k,x,n){for(n=81;n;putchar(x?k*32+59-x-!k:10))x=--n%27,k=(3+x-n/27)%3;}

Python 2 , 65 bayt

for x in 2,99,196:s='';exec"s+=chr(32+x%291/3);x-=94;"*26;print s

Çevrimiçi deneyin!

brainfuck , 121 115 bayt

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

6 byte'ı kurtardığı için @JoKing'e teşekkürler!

Çevrimiçi deneyin!

Japt , 17 bayt

26Æ" Aa"c+X éX÷y

Dene

açıklama

26Æ           Ã       :Create the range [0,26) and pass each X through a function
   " Aa"              :  String literal
        c+X           :  Add X to the codepoint of each character
            éX        :  Rotate right X times
               ·      :Join with newlines
                y     :Transpose

Python 2,79 bayt

p=0
exec"o=0;r='';exec'r+=chr(o+[32,65,97][(p-o)%3]);o+=1;'*26;p+=1;print r;"*3

Çevrimiçi deneyin!

APL (Dyalog Unicode) , 23 bayt ( Adám's SBCS )

(⎕UCS-⊖∘↑32 65 97+⊂)⍳26

Çevrimiçi deneyin!

-1 Adám sayesinde .

Etkileşimli bir ortamda çalışır.

Varsayım ⎕IO←0.

K4 , 38 bayt

Çözüm:

-1"c"$+(-t).q.rotate'32 65 97+/:t:!26;

Örnek:

q)k)-1"c"$+(-t).q.rotate'32 65 97+/:t:!26;
 bC#eF&hI)kL,nO/qR2tU5wX8z
A!cD$fG'iJ*lM-oP0rS3uV6xY9
aB"dE%gH(jK+mN.pQ1sT4vW7yZ

Açıklama:

Rotasyonu gerçekleştirmek için 9 karakter ...

-1"c"$+(-t).q.rotate'32 65 97+/:t:!26;
-1                                   ; / print to stdout, swallow return
                                  !26  / til 26, 0..25
                                t:     / save as variable t
                             +/:       / add each right item to...
                     32 65 97          / the list 32, 65, 97 (ASCII offsets)
           .q.rotate'                  / rotate each-both
       (-t)                            / negate, 0..-25
      +                                / flip rows and columns
  "c"$                                 / cast to characters

Perl, 49 46 bayt

perl -E 'say map chr($_*55%81)=~y// -:A-Z             
a-z       
/cr,0..79'

veya

perl -E 'say grep{$_=chr$_*55%81;y// -:A-Z             
a-z       
/c}0..79'