Kabarcık Sayfamı Doldur

18

Bugün okulumda AP sınavı kayıt günüydü ve gerekli sayfalarda ve sayfalarda titizlikle köpürürken, bu meydan okuma fikri beni vurdu. Yani, bir dizi harf ve sayı verildiğinde, uygun şekilde doldurulmuş bir kabarcık grafiği çıktılayın.

Kurallar:

  • Giriş dizesi her karakter için, karşılık gelen sütundaki bu karakteri değiştirmek #veya @veya başka herhangi bir makul sembol (dil Yönetebil, Unicode karakter 'full_block': █ görünüyor gerçekten iyi)
  • Boşluk, boş bir sütunla gösterilir (örneklere bakın)
  • Geçerli giriş, yalnızca büyük harflerden, sayısal rakamlardan ve boşluklardan oluşan bir dize olacaktır.
  • Giriş, en az 1 en fazla 32 karakter uzunluğunda olacaktır.
  • Çıktı BÜYÜK OLMALIDIR
  • Giriş uzunluğu maksimum 32 uzunluktan azsa, programınız yine de kalan boş sütunları çıkarmalıdır
  • Programınızın küçük harf girişini büyük harfle aynı şekilde işlemesi gerekmez, ancak bonus puanları varsa.

Forum Formatı:

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
JJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ
KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK
LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN
OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO
PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP
QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS
TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU
VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY
ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ
00000000000000000000000000000000
11111111111111111111111111111111
22222222222222222222222222222222
33333333333333333333333333333333
44444444444444444444444444444444
55555555555555555555555555555555
66666666666666666666666666666666
77777777777777777777777777777777
88888888888888888888888888888888
99999999999999999999999999999999

Örnekler:

CODE GOLF ->

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
█CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
DD█DDDDDDDDDDDDDDDDDDDDDDDDDDDDD
EEE█EEEEEEEEEEEEEEEEEEEEEEEEEEEE
FFFFFFFF█FFFFFFFFFFFFFFFFFFFFFFF
GGGGG█GGGGGGGGGGGGGGGGGGGGGGGGGG
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
JJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ
KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK
LLLLLLL█LLLLLLLLLLLLLLLLLLLLLLLL
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN
O█OOOO█OOOOOOOOOOOOOOOOOOOOOOOOO
PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP
QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS
TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU
VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY
ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ
00000000000000000000000000000000
11111111111111111111111111111111
22222222222222222222222222222222
33333333333333333333333333333333
44444444444444444444444444444444
55555555555555555555555555555555
66666666666666666666666666666666
77777777777777777777777777777777
88888888888888888888888888888888
99999999999999999999999999999999


ABCDEFGHIJKLMNOPQRSTUVWXYZ012345 ->

@AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
B@BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
CC@CCCCCCCCCCCCCCCCCCCCCCCCCCCCC
DDD@DDDDDDDDDDDDDDDDDDDDDDDDDDDD
EEEE@EEEEEEEEEEEEEEEEEEEEEEEEEEE
FFFFF@FFFFFFFFFFFFFFFFFFFFFFFFFF
GGGGGG@GGGGGGGGGGGGGGGGGGGGGGGGG
HHHHHHH@HHHHHHHHHHHHHHHHHHHHHHHH
IIIIIIII@IIIIIIIIIIIIIIIIIIIIIII
JJJJJJJJJ@JJJJJJJJJJJJJJJJJJJJJJ
KKKKKKKKKK@KKKKKKKKKKKKKKKKKKKKK
LLLLLLLLLLL@LLLLLLLLLLLLLLLLLLLL
MMMMMMMMMMMM@MMMMMMMMMMMMMMMMMMM
NNNNNNNNNNNNN@NNNNNNNNNNNNNNNNNN
OOOOOOOOOOOOOO@OOOOOOOOOOOOOOOOO
PPPPPPPPPPPPPPP@PPPPPPPPPPPPPPPP
QQQQQQQQQQQQQQQQ@QQQQQQQQQQQQQQQ
RRRRRRRRRRRRRRRRR@RRRRRRRRRRRRRR
SSSSSSSSSSSSSSSSSS@SSSSSSSSSSSSS
TTTTTTTTTTTTTTTTTTT@TTTTTTTTTTTT
UUUUUUUUUUUUUUUUUUUU@UUUUUUUUUUU
VVVVVVVVVVVVVVVVVVVVV@VVVVVVVVVV
WWWWWWWWWWWWWWWWWWWWWW@WWWWWWWWW
XXXXXXXXXXXXXXXXXXXXXXX@XXXXXXXX
YYYYYYYYYYYYYYYYYYYYYYYY@YYYYYYY
ZZZZZZZZZZZZZZZZZZZZZZZZZ@ZZZZZZ
00000000000000000000000000@00000
111111111111111111111111111@1111
2222222222222222222222222222@222
33333333333333333333333333333@33
444444444444444444444444444444@4
5555555555555555555555555555555@
66666666666666666666666666666666
77777777777777777777777777777777
88888888888888888888888888888888
99999999999999999999999999999999

ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 ->^^^

Ve elbette, bu kod golf , bu yüzden en kısa cevap kazanıyor

code-golf  ascii-art 
— X1M4L
kaynak
7
Giriş doğrulaması genellikle önerilmez, bu nedenle yalnızca girişin eşleşmesini sağlayabilir ve girişlerle eşleşmeyen [A-Z0-9]{1,32}herhangi bir davranışa izin verebilirsiniz.
— Giuseppe
1
ASCII kodunda '0'ın' A'dan önce gelmesi ne kadar gülünç derecede
— canlandırıcıdır::
"Geçerli giriş, kabarcık sayfasında ve boşluklarda görünen karakterlerden oluşan bir dize olacaktır" ancak aynı zamanda "Büyük harfler, boşluklar ve sayısal rakamlar veya 32 karakter sınırının üzerinde herhangi bir karakter göz ardı edilmeli " , yani hangisi?
— Kritixi Lithos
1
Ancak ilk ifadeye göre, bunun $girdilerde görünmeyeceğini söylüyorsunuz
— Kritixi Lithos
1
Rakamları ve innalid karakterleri spesifikasyonlardan çıkardığınıza göre, bunları örneklerden de kaldırmak isteyebilirsiniz.
— Titus

Yanıtlar:

4

Kabuk , 23 bayt

mż§?'#|=⁰mR32¤+…"AZ""09

Çevrimiçi deneyin veya █ karakteriyle (ancak geçersiz bir bayt) deneyin!

Ne yazık ki iki maps bir (parantez kullanarak, 24 bayt maliyeti hariç) birleştirmek mümkün değildi ..

açıklama

mż§?'#|=⁰mR32¤+…"AZ""09"  -- expects string as argument, eg. "FOO"
             ¤            -- with the two strings "AZ" "09" ..
               …          -- | fill ranges: "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                          -- |              "0123456789"
              +           -- .. and concatenate: "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
          m               -- map the following (eg. with 'X')
                          -- | replicate 32 times: "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
                          -- : ["A…A","B…B",…,"Z…Z","0…0",…"9…9"]
m                         -- map the following (eg. with "F…")
 ż      ⁰                 -- | zipWith (keeping elements of longer list) argument ("FOO")
  §?   =                  -- | | if elements are equal
    '#                    -- | | | then use '#'
      |                   -- | | | else use the first character
                          -- | : ["#FF…F"]
                          -- : ["A…A",…,"#FF…F",…,"O##O…O",…,"9…9"]
— ბიმო
kaynak
4

Ruby , 62 bayt

->s{[*?A..?Z,*?0..?9].map{|c|(0..31).map{|i|c==s[i]??@:c}*''}}

Çevrimiçi deneyin!

Dize dizisini döndürür. Dize birleştirmeler atarak ve genellikle norm olduğu gibi bir 2B karakter dizisi döndürerek daha fazla golf olabilir, ama burada izin verilir emin değilim.

— Kirill L.
kaynak
3

C (gcc) , 132 bayt

char*s="ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",*_,*a;f(char*x){for(_=s;*_;++_,puts(""))for(a=s;*a;)putchar(x[a++-s]-*_?*_:64);}

Çevrimiçi deneyin!

Jonathan Frech'e 6 bayt kazandığı için teşekkürler.

— LambdaBeta
kaynak
puts("")eşittir putchar(10).
— Jonathan Frech
++a)putchar((x[a-s]-*_)?*_:64);-> )putchar(x[a++-s]-*_?*_:64);.
— Jonathan Frech
Eğer kurallarını Biraz razı istekli iseniz, golf de olabilir 64için 1.
— Jonathan Frech
Bunu yaparsanız, putcharçağrı golf olabilir putchar(*_*(*_!=a[x-s]));.
— Jonathan Frech
Normalde bunun için kuralları bükmekle iyi olurum ... ama 1 dolu bir dikdörtgen veya @ işaretinden çok farklı bir canavar. Diğer değişiklikler faydalı olsa da - güncellenecektir.
— LambdaBeta
3

Kırmızı , 177 bayt

func[s][m: copy[]foreach c a:"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"[insert/dup r: copy"^/"c 32 append m r]j: 0
foreach c s[j: j + 1 if c <>#" "[m/(index? find a c)/(j): #"@"]]m]

Çevrimiçi deneyin!

Daha okunabilir:

f: func[s][
    m: copy[]
    a:"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
    foreach c a[
        insert/dup r: copy "^/" c 32
        append m r
    ]
    j: 0
    foreach c s[
        j: j + 1
        if c <>#" "[m/(index? find a c)/(j): #"@"]
    ]
    m
]
— Galen Ivanov
kaynak
3

Kömür , 21 bayt

Ｅ⁺α⭆…αχκ⭆…◨θφ³²⎇⁼ιλ#ι

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

  α  α                  Uppercase alphabet predefined variable
      χ                 Predefined variable 10
    …                   Chop to length
   ⭆                    Map over characters and join
       κ                Current index
 ⁺                      Concatenate
Ｅ                       Map over characters into array
           θ            Input string
            φ           Predefined variable 1000
          ◨             Right pad to length
             ³²         Literal 32
         …              Chop to length
        ⭆               Map over characters and join
                 ι  ι   Current outer character
                  λ     Current inner character
                ⁼       Equals
                   #    Literal `#`
               ⎇        Ternary
                        Implicitly print each result on its own line

Giriş doğrulamalı önceki sürüm, 34 32 bayt. Düzenleme: Yalnızca @ ASCII sayesinde 2 bayt kaydedildi.

≔⁺α⭆…αχκαＥα⭆…◨Φθ∨⁼ι №αιφ³²⎇⁼ιλ#ι

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

— Neil
kaynak
: / sonunda bir yakın paren eksik gibi görünüyor
— sadece ASCII sadece
Bu işe yarıyor gibi görünüyor. (Wolfram StringReplaceYan not), gerçekten kullanışlı doğru olur yerleşik yerine
— ASCII sadece
Boş ver, ne yaptığımı bilmiyorum. 27 bayt - ihtiyacınız yokCast
— sadece ASCII-
Ayrıca, re: daha önce sorduğunuz keyfi karaktere sahip ped: bunun bir yerleşik olarak eklenecek kadar yararlı olacağını düşünüyor musunuz? ya da belki iki karakterli bir yerleşik olarak?
— Yalnızca ASCII
23
— sadece ASCII
3

Jöle ,  18  17 bayt

ØA;ØDWẋ32ɓ,€⁶y"ZY

Boşluk karakteri kullanır. Bir bayt maliyeti ile #yerine kullanmak için.⁶”#

Çevrimiçi deneyin!

Nasıl?

ØA;ØDWẋ32ɓ,€⁶y"ZY - Main Link: list of characters, S   e.g.  ['S','P','A','M']
ØA                - upper-case alphabet characters           ['A','B',...,'Z']
   ØD             - digit characters                         ['0','1',...,'9']
  ;               - concatenate                              ['A','B',...,'Z','0','1',...,'9']
     W            - wrap in a list                           [['A','B',...,'Z','0','1',...,'9']]
      ẋ32         - repeat 32 times                          [['A','B',...,'Z','0','1',...,'9'],...,['A','B',...,'Z','0','1',...,'9']]
         ɓ        - start a new dyadic chain with that on the right
            ⁶     - space character                          ' '
          ,€      - pair €ach of S with a space              [['S',' '],['P',' '],['A',' '],['M',' ']]
              "   - zip with:
             y    -   translate (replace 'S' with ' ' in 1st, 'P' with ' ' in 2nd, ...) -- Note: zip is a zip-longest, so trailing lists remain
                Z  - transpose
                 Y - join with line-feeds
                   - implicit print
— Jonathan Allan
kaynak
Bir bayt kaydedebilirim.
— Outgolfer Erik
Welp, ayrıca ³Ḣ,⁶yØA;ØD¤µ32СZY18 de var ki bu da geliştirilebilir olabilir! Gerçi çıkıyor ...
— Jonathan Allan
Açıkçası, bahsettiğim bayt bu değil. :) Daha çok deneyin ...
— Erik Outgolfer
Şaşırtıcı Ben mobil 17 bayt
— Jonathan Allan
Mine aslında bu , ama tebrikler!
— Outgolfer Erik
2

C ++ 14,319 bayt 237

Bu benim ilk kez, mümkün olan en kötü CodeGolf Dili: P

char c;string k="ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",s;int main(){map<char,vc>g;g[' ']=vc(32,' ');for(char c:k)g[c]=vc(32,c);getline(cin,s);for(int i=0;i<s.length();i++)g[s[i]][i]='@';for(char d:k){for(char x:g[d])cout<<x;cout<<'\n';}}

Çevrimiçi deneyin!

— NL628
kaynak
Soru: Başlığı eklemem gerekir mi?
— NL628
Kodu çalıştırmak gerekiyorsa, cevabınızda olması gerekir. Bununla birlikte, hemen hemen tüm boşlukları kaldırabilir ve bu cevabın hala çalışmasını sağlayabilirsiniz.
Bunu main () yerine parametrelerle birlikte bir işlev olarak yeniden yazabilir miyim?
— NL628
@ NL628 evet yapabilirsiniz. Daha fazla yardım için C ++ ile golf oynamaya ilişkin ipuçlarına bakın . EDIT: bağlantı C ++
— Giuseppe
1
COBOL kimse var mı? Ben asla bir kod satırı yazdım, ama kod golf için COBOL kullanmak ilginç bir meydan okuma olabilir.
— Hans-Martin Mosner
2

Node.js, 85 bayt

Port to Node.js @DanielIndie tarafından önerildi

f=(s,x=544,c=Buffer([48+x/32%43]))=>x<1696?(s[x&31]==c?'@':c)+[`
`[++x&31]]+f(s,x):''

Çevrimiçi deneyin!

JavaScript (ES6), 103 98 bayt

f=(s,x=544,n=x>>5,c=String.fromCharCode(48+n%43))=>n<53?(s[x&31]==c?'@':c)+[`
`[++x&31]]+f(s,x):''

Çevrimiçi deneyin!

— Arnauld
kaynak
90 bayt buna ne dersiniz?
— DanielIndie
@DanielIndie Teşekkürler! Katma. (Buna gerçekten ihtiyacımız yok, değil +""mi?)
— Arnauld
Biz dönüştürmek gerekir ya da değil bu yüzden bunu düşünmüyorum bilmiyorum: P ama evet, aslında gerek yok :)
— DanielIndie
@DanielIndie Ah, şimdi sadece x/322 bayt tasarruf etmek için kullanabiliriz , çünkü Buffertamsayılara zorlar.
— Arnauld
f=(s,x=561,c=Buffer([48+x/33%43]))=>x<1749?(s[x++%33]==c?'@':x%33?c:`\n`)+f(s,x):''
— l4m2
2

Haskell , 86 bayt

Daha hoş bir yaklaşım (ve daha az bayt) için, Laikoni'nin çözümüne bakın !

f x=(x#).(<$[1..32])<$>['A'..'Z']++['0'..'9']
(a:b)#(u:v)=last(u:['#'|a==u]):b#v
_#w=w

Çevrimiçi deneyin!

Alternatif olarak aynı bayt sayısı için şunları kullanabiliriz:

(a:b)#(u:v)|a==u='#':b#v|0<3=u:b#v

Çevrimiçi deneyin!

Açıklama / Ungolfed

Operatör (#)buna çok benzer, zipWithancak fonksiyon sabit kodlanmıştır, st. Kullandığı #iki karakter eşittir ve aksi takdirde ungolfed ikincisi, devam ederse:

(a:b) # (u:v)
   | a == u    = '#' : b # v
   | otherwise =  u  : b # v

İlk liste biterse, sadece ikincisinin kalan öğelerini ekler:

_ # w = w

Bu yardımcıyla, yalnızca dizeyi oluşturmamız, "A..Z0..9"her öğeyi 32 kez çoğaltmamız ve girdiyi her dizeyle birlikte sıkıştırmamız gerekir:

f x = map ((x#) . replicate 32) (['A'..'Z'] ++ ['0'..'9'])
— ბიმო
kaynak
1
— Laikoni
@Laikoni: Sadece 1 bayt daha az olduğu için, bu gerçekten akıllı bir kullanım max. Benim çözümümden çok farklı olduğu için bunu kendi çözümünüz olarak yayınlamanız gerektiğini düşünüyorum.
— 18:20
74 baytlık bir sürüm yayınladım .
— Laikoni
2

Haskell , 74 bayt

f x=[do a<-take 32$x++cycle" ";max[c]['~'|a==c]|c<-['A'..'Z']++['0'..'9']]

Çevrimiçi deneyin! Bir giriş dizesi x, uzunluğu 32 olan boşluklarla doldurulur take 32$x++cycle" ". Her karakter için cgelen Aiçin Zve 0için 9, biz karakterlere bakmak ayastıklı giriş dizesinden ve bunları yerine ~ne zaman ave ceşit işlemiş caksi. Bu elde edilir max[c]['~'|a==c]örn olan ve ne zaman ve . Bu, char yerine tekli bir dize verdiğinden, singleton dizelerini tek bir dizede birleştiren -notation kullanılır.max "A" "~" = "~"a = c = 'A'max "A" "" = "A"c = 'A'a = 'B'do

Dayanarak BMO en Haskell çözümü .

— Laikoni
kaynak
2

Python 2, 138 bayt

Hem büyük hem de küçük harf karakterleri destekler ve boşluklar için doldurulmamış bir sütun bırakır.

def f(s):
 s=s.upper()
 for j in"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789":print"".join(j if(len(s)<=i)or(s[i]!=j)else'@'for i in range(32))

Bonus buna değmezse, 125 bayt için gideceğim ve sadece büyük harf girişlerini destekleyeceğim:

def f(s):
 for j in"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789":print"".join(j if(len(s)<=i)or(s[i]!=j)else'@'for i in range(32))
— sonrad10
kaynak
2

Stax , 15 bayt

╛dδÑ-═E↑\≈Fà±AG

Çalıştır ve hata ayıkla

Bu kullanan '#'bir dolu kabarcık belirtmek için.

Ambalajından çıkarılmış, golf edilmemiş ve yorum yapılmış gibi görünüyor.

32(     right-pad or truncate to 32
{       begin block for mapping
  VAVd+ "A..Z0..9"
  s'#+  move input character to top of stack and append "#". e.g. "C#"
  |t    translate; replace the first character with the second in string
m       perform map using block
Mm      transpose array of arrays and output each line

Bunu çalıştır

— özyinelemeli
kaynak
1

Pyth, 23 20 bayt

j.Tm:s+r1GUTdN.[Qd32

Burada deneyin

açıklama

j.Tm:s+r1GUTdN.[Qd32
              .[Qd32      Pad the input to 32 characters.
   m                      For each character...
     s+r1GUT              ... get the string "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"...
    :       dN            ... with the character replaced by a '"'.
j.T                       Transpose the lines and print them all.
1

APL + WIN, 56 bayt

Girdi dizgisini ister ve tanımlayıcı olarak # karakteri kullanır:

m←⍉32 36⍴⎕av[(65+⍳26),48+⍳10]⋄((,m[;1]∘.=32↑⎕)/,m)←'#'⋄m

Açıklama:

m←⍉32 36⍴⎕av[(65+⍳26),48+⍳10] create the table

32↑⎕ pad the input string to 32 characters with spaces

(,m[;1]∘.=32↑⎕) use outer product with = to identify characters in table

((,m[;1]∘.=32↑⎕)/,m)←'#' replace characters with #

m display table

⋄ statement separator
— Graham
kaynak
1

C (gcc) , 124 bayt

f(s,b,x,y)char*s,b[33];{sprintf(b,"%-32.32s",s);for(x=0;++x<36;puts(""))for(y=x+21+43*(x<27),s=b;*s;putchar(*s++==y?35:y));}

Çevrimiçi deneyin!

Sabit kodlanmış bir dizi yerine, bunun yerine bir arama işleviyle değiştirdim. Neyse ki ASCII karakter setinin bitişik alfabetik ve sayısal aralıkları var (Sana bakıyorum, EBCDIC!) Ayrıca, çıktıyı tam olarak 32 karaktere kadar tuttum sprintf(): işlevi 97 bayt olur:

f(s,i,x,y)char*s,*i;{for(x=0;++x<36;puts(""))for(y=x+21+43*(x<27),i=s;*i;putchar(*i++==y?35:y));}

Çevrimiçi deneyin!

— ErikF
kaynak
— ceilingcat
1

CJam , 31 bayt

q32Se]{'[,65>A,s+S+_@#St);}%zN*

Çevrimiçi deneyin! Boşlukları "delik" karakteri olarak kullanır.

Sondaki boşluğa izin verilirse, bu 29 bayt için çalışır :

q32Se]{'[,65>A,s+S+_@#St}%zN*

Çevrimiçi deneyin!

█Bunun yerine Unicode tam bloğunu ( ) kullanan 34 baytlık bir varyasyon :

q32Se]{'[,65>A,s+S+_@#'█t);}%zN*

Çevrimiçi deneyin!

açıklama

q                                Input.
    e]                           Pad to a length of
 32                                32
                                 with
   S                               spaces.
      {                   }%     For each character:
                                   Get the uppercase alphabet by
            >                        dropping the first
          65                           65
                                     elements of
         ,                             the range of characters below
       '[                                '['.
                +                  Append
               s                     the string version
              ,                        of the range of numbers below
             A                           10.
                  +                Append
                 S                   a space.
                     #             Find the index of
                    @                the character.
                       t           Set this index to
                      S              a space
                   _               in the original array.
                        );         Drop the space at the end.
                                   Yield this modified array.
                                 End for. The result is an array of arrays of characters.
                            z    Transpose this array, turning rows into columns.
                             N*  Join the result on newlines.
— Esolanging Meyve
kaynak
1

05AB1E , 19 bayt

RтúR32£vžKuÙyð:})ø»

Çevrimiçi deneyin!

açıklama

R                     # reverse
 тú                   # prepend 100 zeroes
   R                  # reverse
    32£        }      # take the first 32 characters
       v              # for each character
        žK            # push a string of [a-zA-Z0-9]
          uÙ          # upper case and remove duplicates
            yð:       # replace current character with space
                )ø    # transpose
                  »   # join by newline
— Emigna
kaynak
a[b]burada istediğiniz gibi çalışmıyor, değil mi? P?
— Sihirli Ahtapot Urn
@MagicOctopusUrn: Maalesef değil. Bu benim de ilk düşüncemdi, ama bu durumda modüler indeksleme bizim dostumuz değil: P
— Emigna
1

MATL , 21 bayt

1Y24Y2vjO33(32:)y=~*c

Boşluğu işaretçi karakteri olarak kullanır.

Çevrimiçi deneyin!

açıklama

1Y2     % Push 'AB...YZ'
4Y2     % Push '01...89'
v       % Concatenate into a 36×1 column vector of chars
j       % Push unevaluated input: string of length n, or equivalently 1×n
        % row vector of chars
O33(    % Write 0 at position 33. This automatically writes a 0 at postions
        % n+1, n+2, ..., 32 too
32:)    % Keep only the first 32 entries: gives a 1×32 row vector
y       % Duplicate from below: pushes a copy of the 36 ×1 column vector
=~      % Test for non-equal entries, with broadcast. Gives a 33×32 matrix
        % containing 0 for matching entries, and 1 otherwise
*       % Multiply this matrix by the 1×32 row vector, with broadcast. This
        % changes each 1 into the corresponding character in the input
c       % Convert to char. Implicitly display. Char 0 is displayed as space
— Luis Mendo
kaynak
1

Ortak Lisp , 150 bayt

(setq s(format nil"~32a"(read-line)))(map nil(lambda(i)(map nil(lambda(j)(princ(if(eq i j)#\# i)))s)(princ"
"))"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")

Çevrimiçi deneyin!

açıklama

;; pad input to 32 spaces on the right
(setq s(format nil"~32a"(read-line)))
;; for each character in bubble sheet, for each character in input:
;; if characters are equal print "#"
;; else print bubble sheet character
(map nil(lambda(i)(map nil(lambda(j)(princ(if(eq i j)#\# i)))s)(princ"
"))"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")
— ASCII sadece
kaynak
1

Java 10, 120 118 117 bayt

s->{var r="";for(char c=65,i;c<91&c!=58;r+="\n",c+=c<90?1:-42)for(i=0;i<32;i++)r+=i<s.length&&s[i]==c?35:c;return r;}

Çevrimiçi deneyin (TIO için '█' kullandım ( 9608yerine35 daha iyi görünürlük için için).

Açıklama:

s->{                   // Method with character-array parameter and String return-type
  var r="";            //  Result-String, starting empty
  for(char c=65,i;     //  Start character `c` at 'A'
      c<91&c!=58       //  Loop as long as `c` is 'Z' or smaller, and is not '9'
      ;                //    After every iteration:
       r+="\n",        //     Append a new-line to the result-String
       c+=c<90?        //     If `c` is not 'Z' yet
           1           //      Go to the next character ASCII-value-wise
          :            //     Else:
           -42)        //      Change the 'Z' to '0'
    for(i=0;i<32;i++)  //    Inner loop `i` in the range [0,32)
      r+=i<s.length    //     If we're not at the end of the input array yet,
         &&s[i]==c?    //     and the characters in the column and array are the same
          35           //      Append the filler-character '#'
         :             //     Else:
          c;           //      Append the current character instead
  return r;}           //  Return the result-String
— Kevin Cruijssen
kaynak
1

Retina , 64 bayt

$
36* 
L`.{36}
.
36*@$&¶
Y`@`Ld
(.)(.*)\1
@$2
N$`\S
$.%`
L`.{32}

Çevrimiçi deneyin!

$
36* 
L`.{36}

Sağdaki giriş dizesini 36 karaktere boşluk bırakarak doldurur

.
36*@$&¶
Y`@`Ld

Ardından, her karakteri kendi satırına koyun ve ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789önüne ekleyin .

(.)(.*)\1
@$2

Aynı satırda aynı karakterin bir çiftini eşleştirin; bu satır, yalnızca bu satırın karakteri bunlardan biriyle eşleşiyorsa, bir tane varsa ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789. Birincisini değiştirin @ve ikincisini çıkarın.

N$`\S
$.%`

Eşleşmeyen tek satırlar boşluklu olanlardır, bu nedenle boşluk olmayan karakterler 36 × 36 kare bloktur. Transpoze edin.

L`.{32}

Her satırda yalnızca ilk 32 karakteri sakla

— TwiNight
kaynak
1

Tcl , 153 bayt

-8 bayt için @sergiol teşekkürler

lmap i [split ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 ""] {puts [join [lmap j [split [format %-32s [join $argv ""]] ""] {expr {$i==$j?"#":$i}}] ""]}

Çevrimiçi deneyin!

açıklama

# for i in list of choices
lmap i [split ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 ""] {
    # print string of
    puts [join
        # list of
        [lmap j
             # for each character in first argument padded to 32 characters
             [split [format %-32s [join $argv ""]] ""]
             # return "#" if current choice and current character are equal, else current choice
             {expr {$i==$j?"#":$i}}
        ]
        ""
    ]
}
— ASCII sadece
kaynak
152
— sergiol
@sergiol: | Evet öyle. 146 ?
— sadece ASCII
1
145
— sadece ASCII
1

SNOBOL4 (CSNOBOL4) , 155 , 150 bayt

	I =INPUT
	U =&UCASE '0123456789'
N	U LEN(1) . K REM . U	:F(END)
	O =DUPL(K,32)
	X =
S	I LEN(X) @X K	:F(O)
	O POS(X) K =' '	:S(S)
O	OUTPUT =O	:(N)
END

Çevrimiçi deneyin!

Açıklama:

	I =INPUT			;* read input
	U =&UCASE '0123456789'		;* U = uppercase concat digits
N	U LEN(1) . K REM . U	:F(END)	;* while U not empty, pop first letter as K
	O =DUPL(K,32)			;* dup K 32 times
	X =				;* set position to 0
S	I LEN(X) @X K	:F(O)		;* find the next occurrence of K and save (index - 1) as X
	O POS(X) K =' '	:S(S)		;* replace the X'th occurrence of K with space. If that's before character 32, goto S, else proceed to next line
O	OUTPUT =O	:(N)		;* output the string and goto N
END
— Giuseppe
kaynak
1

Prolog (SWI) , 235 229 228 222 214 198 173 167 165 bayt

-6 sayesinde bayt @Cows vak , -6 sayesinde bayt 0 @ ' 

X*[H|T]:-(H=X->write(#);writef("%n",[X])),X*T;nl.
_+[].
X+[H|T]:-H*X,X+T.
?-read(X),swritef(Y,"%32l",[X]),string_codes(Y,Z),Z+`ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789`.

Çevrimiçi deneyin!

açıklama

% if head = bubble char, write "#", else write bubble char, then while tail is non-empty, recurse.
% if tail is empty then print newline
X*[H|T]:-(H=X->write(#);writef("%n",[X])),X*T;nl.
% if list is empty, then do nothing. this prevents t from being called with invalid X
_+[].
% call t, then recurse for each char in list
X+[H|T]:-H*X,X+T.
% read, pad input to 32 chars, and convert input to list
?-read(X),swritef(Y,"%32l",[X]),string_codes(Y,Z),Z+`ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789`.
— ASCII sadece
kaynak
0

Oktav , 61 bayt

@(s)[((a=[30:55 13:22]'*~~(o=1:32)).*(a+35~=[s o](o)))+35 '']

Çevrimiçi deneyin!

Fonksiyon aşağıdaki gibi çalışır:

@(s)[                                                     ''] %Anonymous function, taking string, outputting character array   
         [30:55 13:22]'                                       %Creates the board alphabet ('A':'Z' '0':'9']) but minus 35 (value of '#')
                       *~~(o=1:32)                            %Matrix multiplication by an array of 32 1's to form the 2D board. Saves 1:32 for later.
      (a=                         )                           %Saves the board mimus 32 to a for use later.
                                            [s o](o)          %Ensures the input is 32 characters long. Missing chars replaced by 1:32 (not in board)
                                     (a+35~=        )         %Compares against board (a+35 as a=board-35). Makes 2D array where matches = 0, others = 1. 
     (                             .*                )+35     %Element=wise multiplication, forcing matches to 0. Then add 35 resulting in board with #'s
— Tom Carpenter
kaynak
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.