Girişinizi düzenleyin


19

Bu, bu toz kaplı girişe biraz benziyor ama umarım benim spin'imi yeterince benzersiz kılıyor. Bunu göndermekten caydırıcı bir şey bulamadım ama orada oldukça deniz var.

Neyse! Meydan okuma:

Kodunuz bir karakter dizisi alır; Bunu, aynı dizenin ASCII sanat tarzı sürümüne dönüştürür, ancak bir yakalama ile.

Girdi dönüşümü

  • Desteklenecek tek karakterler AZ ve 0-9
  • Küçük harfler büyük harfe dönüştürülür
  • Başka her şey sessizce kaldırıldı

Karakter çizimi

  • Büyütülmüş yazı tipinin her "pikseli" girdi dizesinden çizilir
  • N'inci piksel, giriş dizesindeki n'inci karaktere eşittir. N, giriş dizesinin uzunluğundan büyükse, en başa sarın
  • Tek tek harfler soldan sağa, yukarıdan aşağıya doğru çizilir
  • Sonraki harfler "piksel karakter" indekslerini son harfin kaldığı yerden alır (örneğin, 10 giriş uzunluğunda, ilk harf 9 pikselse, ikinci harfin ilk pikseli 10. giriş karakteri, ikincisi ile çizilir piksel 1. giriş karakteriyle çizilecektir)
  • Her harf, boşluklarla tamamen doldurulmuş 5x5 ızgarada çizilir. Sizin için önceden oluşturulmuş yazı tipini bu macunda veya biraz daha aşağıya bulabilirsiniz.
  • Her harf aynı satıra çizilir, bu nedenle çıktınızdaki toplam satır sonu sayısı 4 olur
  • Her harf 2 sütun boşluk ile ayrılır

Yazı tipi

 000 
0  00
0 0 0
00  0
 000 

111  
  1  
  1  
  1  
11111

2222 
    2
 222 
2    
22222

3333 
    3
  333
    3
3333 

  44 
 4 4 
44444
   4 
   4 

55555
5    
5555 
    5
5555 

 6666
6    
6666 
6   6
 666 

77777
    7
   7 
  7  
 7   

 888 
8   8
 888 
8   8
 888 

 999 
9   9
 9999
    9
9999 

 AAA 
A   A
AAAAA
A   A
A   A

BBBB 
B   B
BBBB 
B   B
BBBB 

 CCCC
C    
C    
C    
 CCCC

DDDD 
D   D
D   D
D   D
DDDD 

EEEEE
E    
EEE  
E    
EEEEE

FFFFF
F    
FFF  
F    
F    

 GGGG
G    
G  GG
G   G
 GGGG

H   H
H   H
HHHHH
H   H
H   H

IIIII
  I  
  I  
  I  
IIIII

JJJJJ
  J  
  J  
  J  
JJ   

K   K
K  K 
KKK  
K  K 
K   K

L    
L    
L    
L    
LLLLL

M   M
MM MM
M M M
M   M
M   M

N   N
NN  N
N N N
N  NN
N   N

 OOO 
O   O
O   O
O   O
 OOO 

PPPP 
P   P
PPPP 
P    
P    

 QQ  
Q  Q 
Q QQ 
Q  Q 
 QQ Q

RRRR 
R   R
RRRR 
R  R 
R   R

 SSSS
S    
 SSS 
    S
SSSS 

TTTTT
  T  
  T  
  T  
  T  

U   U
U   U
U   U
U   U
 UUU 

V   V
V   V
 V V 
 V V 
  V  

W   W
W   W
W W W
WW WW
W   W

X   X
 X X 
  X  
 X X 
X   X

Y   Y
 Y Y 
  Y  
  Y  
  Y  

ZZZZZ
   Z 
  Z  
 Z   
ZZZZZ

Evet, 4 ve Q'nun çirkin olduğunu biliyorum

Bir örnek

Giriş

0123456789

Çıktı

 012   567    6789   0123     34   45678   9012  34567   234    567 
3  45    8        0      4   5 6   9      3          8  5   6  8   9
6 7 8    9     123     567  78901  0123   4567      9    789    0123
90  1    0    4          8     2       4  8   9    0    0   1      4
 234   12345  56789  9012      3   5678    012    1      234   5678 

Başka bir örnek

Giriş

a3 B'2

Çıktı

 A3B   B2A3   2A3B   2A3B 
2   A      B  2   A      2
3B2A3    2A3  3B2A    A3B 
B   2      B  3   B  2    
A   3  2A3B   2A3B   A3B2A

Standart boşluklar yasaktır. Golf kodla yeşil kene verilmeyecek.


17
Girişin sadece içereceğini garanti etmeyi öneririm [A-Z\d]- Geçersiz karakterleri filtrelemenin zorluğa bir şey kattığını düşünmüyorum.
Shaggy

3
@Shaggy Belki. Ama aynı şekilde, hiçbir şey zorluğu kaldırmaz sanmıyorum
Scoots



2
ÜÇ lider alan ne olacak? Elbette buna izin vermeyeceksiniz!
Sihirli Ahtapot Urn

Yanıtlar:


16

Piton 2 , 413 411 373 364 352 345 bayt

Kevin Cruijssen sayesinde -1 bayt .
-Jo King sayesinde 9 bayt . Lynn
sayesinde -1 bayt .

Veri dizesi yazdırılamaz, aşağıda çıkış sürümü içeriyor.

k=list(filter(str.isalnum,input()))
q=range(5);o=['']*5;r=k*25;d=0
for c in'uM<LxSe#ye>El4NpD@$	gh>I,m]aB>e,]?kFLyglxV!%w832wGj%uT{Hr*K,*[P\n6.&ED#T}^DLI&p7f\d`*lG!FacG\rz?!A':d*=126;d+=ord(c)-1
for c in k:
 for i in q:
	for y in q+[999]*2:o[i]+=d>>int(c,36)*25+i*5+y&1and r.pop(0)or' '
print'\n'.join(o).upper()

Çevrimiçi deneyin!

Her karakterin 25 pikseli olduğundan 25 bit olarak kolayca kodlanabilir. Taban 126 numarası 'uM\x04<L\x10x\x14Se#ye\x0f>El4NpD@$\tgh>\x1d\x10\x15I,\x0em]a\x0e\x03B>e\x15,\x0c]\x03?kFL\x01\x0byglxV!\x18\x16\x0c\x0b\x10\x0b%w832wGj%uT{Hr*K,*[P\n6.&ED#T\x0c}^\x1c\x0fD\x17LI&p7\x17f\\d`*\x01l\x1bG\x12!Fac\x05\x08\x0eG\rz?!\x1aA'tüm karakterleri kodlar, en 0az anlamlı 25 bit, 1sonraki 25 bit tarafından kodlanır ve en önemli 25 bit tarafından Zkodlanır. Tek bir karakter aşağıdaki sırayla kodlanır:

00 01 02 03 04
05 06 07 08 09
10 11 12 13 14
15 16 17 18 19
20 21 22 23 24

( 00en küçük anlamlı bit, 25en anlamlı olanıdır)

Boşluklar sıfır, boşluk olmayanlar bir ile kodlanır. Örnek :

77777      11111
    7      00001
   7   =>  00010  => (0001000100010001000011111)
  7        00100
 7         01000

Ungolfed

k = list(filter(str.isalnum,input()))  # keep only alphanumeric characters of the input
o = ['']*5   # this list contains the output, initially 5 empty lines
r = k * 25   # make a copy of the input 25-times the length, these chars will be used for the pixels
data = 0
#  data encoded in base 126
b92d = 'uM<LxSe#ye>El4NpD@$	gh>I,m]aB>e,]?kFLyglxV!%w832wGj%uT{Hr*K,*[P\n6.&ED#T}^DLI&p7f\d`*lG!FacG\rz?!A'
for c in b92d:          # convert base 92 to base 10
  d*=126;d+=ord(c)-1

for c in k:             # iterate over the filtered input
  a_index = int(c, 36)  # the index of the current char in '0..9A..Z' / '0..9a..z'
  for i in range(5):    # for each row of the output
    for y in range(5)+[999]*2:  # for each pixel in the row, th two 999's are used for spaces
      is_set = data >> (a_index*25 + i*5 + y) & 1  # We shift the to the right to have ...
                                                   # the current pixels value at the LSB:
                                                   # 25 bits for each char that came before
                                                   # 5 bits for each previous row and 1 bit
                                                   # for every pixel in the same row
      o[i] += is_set and r.pop(0) or ' '           # If the current pixel is set, append ...
                                                   # ... a character from the input to the current row
print '\n'.join(o).upper()  # print the output

Çevrimiçi deneyin!


Harfler iki boşlukla ayrılmalıdır, bu yüzden +' 'olmalıdır +' '. Ne olursa olsun güzel cevap, bu yüzden benden +1.
Kevin Cruijssen

.upper()yine de bir yere ihtiyacınız var , aksi takdirde iç harfler küçük harfle biter
Jo King

@ Hakkı haklısın, düzeltin.
ovs

Bu kodlama hilesini seviyorum. Baz 92'yi seçtiniz, çünkü yazdırılabilir ASCII'den oluşan en büyük standart kodlama bu mu? daha yükseğe çıkabilir misin? Ayrıca ben googled ama temel 92 bilgi ince - başaramadı bir bağ var mı?
Jonah

@Jonah Temel 92 kodlaması gibi bir standart yok, bu yüzden kendi kod çözme mantığımı uyguladım. Yeterli sayıda basamağa sahip olduğunuz sürece, herhangi bir tabanı kullanabilirsiniz >1.
ovs

10

APL (Dyalog Unicode) , 228 225 224 214 bayt

Tam program. Stdin dize ister. Stdout'a yazdırır. Kodun yaklaşık yarısı kodlanmış alfabeyi çözüyor.

⍉↓(⍴t)⍴r\i⍴⍨+/r←,t←(⊂ai←(1(819⌶)⍞)∩a←⎕D,⎕A)⌷0(220⌶)¯1(219⌶)¯125+⎕AV_________________________________________________________________________________________________________________________________________________

__Şu 143 bayt LZ4 kodlu dizeyi tırnak içinde temsil eder:"⊥\u0004pæ€}€\\⊃⌿Æ€â<Å€∧€ÀÆ€Ð┬:Ëcü\u0000≥ðè⊤õ⍨¢∧·èý\u0005þÐÕ\u001EÐ :\u001Eè⌊×ßi[B⊂ɫoãà oéìÐ⍙⊃Ý∣à)≥èB⊃\u001B\u001F⊥ä{⌿⍨ G⍺\u001B⌿Æ\u001F∇x└îR`:└è→⊂\u0000ê∧⍒\u0003ɫqè$$ÛD⊥â∊\u001B\u001Eéu|\u001B@4A|⍪┌nàkááЀ€€€€€€"

Çevrimiçi deneyin!

__ Tırnaklarla 143 bayt LZ4 kodlu dize

⎕AV⍳ɩ bu arasında ndices bir Tomic V ector (karakter kümesi)

¯125+ buna -125 ekleyin (imzalı 8 bitlik tamsayılar almak için)

¯1(219⌶) LZ4 sıkıştırması

0(220⌶) 36 katman, 5 satır, 5 sütun Boolean dizisinin serisini kaldırma

()⌷ Aşağıdaki indeksleri kullanarak indeksleyin:

⎕A büyük A harfi

⎕D, başa eklemek D igits

a← mağazada a( bir lafabet için)

()∩ Ve aşağıdakilerin kesişimi (geçersiz girişi kaldırır):

 stdin'den metin girişi istemi (konsol)

  1(819⌶) büyük harfe kat ( 819görünüm gibi Bigküçük aksine, 1 evet Big içindir)

i← mağazada i( i nput için)

a⍳içinde bulunulan bulgulara

 enclose (önde gelen koordinatı temsil eden her biriyle dizin oluşturmak için)

t← içinde depola t( t ext için)

, ravel (düzleştir)

r← mağazada r( r avelled için)

+/ toplamı (yani resmi boyamak için gereken karakter sayısı)

i⍴⍨siklik r bu uzunlukta giriş eshape

r\ genişletmek; 0 saniyede boşluk bırak, 1 saniyede harf tüket

(…) ⍴` aşağıdaki şekle yeniden şekillendirin:

⍴t metnin şekli

 N-5-5-5 dizisini N-5-5 sanat çizgisi matrisine bölme

5x-N sanat satırları matrisine dönüştürün (bu karakterlerin karşılık gelen satırlarını hizalar)

Varsayılan olarak, APL iç içe dizinin basit öğelerini 2 boşlukla ayırır.


Pek değil! Her harf arasında 2 boşluk olmalıdır
Scoots

1
@Scoots OK, sabit.
ADAM


9

Python 2 , 428 bayt

s=filter(str.isalnum,input().upper());x=s
R=['']*5
for c in s:
 i=0;exec"n=int('RAAAOQQ2RBAQBQRRBDRRDCDDAQ8QBRDDDDDRXDDF0XX6CCDDCDCCCD00ECNLDDEDC0DDD66YYABH0A3RQQRQCDOOFR00OCHHDQIQA0D6H0000DXL0CXYXDDDCDCCDD00ECDFDCEEX0D6N6044AQARRQYQADQBQRCBDRKDRDDAC9DQ0A0DD0R'[i*36+ord(c)%55%45],36);R[i]+=bin(n+36*(n<30)<<2)[3:].replace(*'0 ').replace(*'1.');i+=1;"*5
 while'.'in`R`:R=eval(`R`.replace('.',x[0],1));x=x[1:]+s
print'\n'.join(R)

Çevrimiçi deneyin!


Harfler aşağıdaki gibi kodlanır:

Her bir benzersiz parça (23 tane var) ikiliye dönüştürülür ve önüne 1 eklenir. Daha sonra baz 36'ya dönüştürülür.

  part      bin      1+bin     int     base36
'  ...' -> 00111 -> 100111 ->   39  ->   13

Ortaya çıkan baz-36 sayıları:

[10,12,13,14,16,18,19,1A,1B,1C,1D,1E,1F,1H,1I,1K,1L,1N,1O,1Q,1R,X,Y]

İlk harf 1kaldırıldı, bu yüzden tek bir karakterimiz var:

[0,2,3,4,6,8,9,A,B,C,D,E,F,H,I,K,L,N,O,Q,R,X,Y]

A-Z0-9Daha sonra her harf ( ) bu yeni karakterden beşine kodlanır.

0 = ' ... ','.  ..','. . .','..  .',' ... ' -> A,F,H,L,A
1 = '...  ','  .  ','  .  ','  .  ','.....' -> O,0,0,0,R
etc.

Beş listeye:

'AOQQ2RBRAAAQBQRRBDRRDCDDAQ8QBRDDDDDR'
'F0XX6CCXDDDDCDCCCD00ECNLDDEDC0DDD66Y'
'H0A3RQQYABRQCDOOFR00OCHHDQIQA0D6H000'
'L0CXYXD0DXDDCDCCDD00ECDFDCEEX0D6N604'
'ARRQYQA4AQDQBQRCBDRKDRDDAC9DQ0A0DD0R'

Girdiyi bu listelerdeki bir dizine eşlemek için sıra sayısı değiştirilir:

'0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
ord(c) = [48-57, 65-90]
ord(c)%55%45 = [3-9, 0-2, 10-35]

Sıra sıraları 0-35 değil, biraz karışık olduğundan, 5 liste yeniden düzenlenir ve birleştirilir:

'RAAAOQQ2RBAQBQRRBDRRDCDDAQ8QBRDDDDDR'
'XDDF0XX6CCDDCDCCCD00ECNLDDEDC0DDD66Y'
'YABH0A3RQQRQCDOOFR00OCHHDQIQA0D6H000'
'0DXL0CXYXDDDCDCCDD00ECDFDCEEX0D6N604'
'4AQARRQYQADQBQRCBDRKDRDDAC9DQ0A0DD0R'
->
'RAAAOQQ2RBAQBQRRBDRRDCDDAQ8QBRDDDDDRXDDF0XX6CCDDCDCCCD00ECNLDDEDC0DDD66YYABH0A3RQQRQCDOOFR00OCHHDQIQA0D6H0000DXL0CXYXDDDCDCCDD00ECDFDCEEX0D6N6044AQARRQYQADQBQRCBDRKDRDDAC9DQ0A0DD0R'

Girişteki her karakter için 5 harf bulunur ve bir girişe dönüştürülür (base36):

n=int('RAAA...D0R'[i*36+ord(c)%55%45],36)
                   i*36                    #get row i
                        ord(c)%55%45       #n -> 0..35
  int(                               ,36)  #convert to int

Numara altında ise 30, 36ilave edilir (eksik 1biz daha önce kaldırıldı)

n+36*(n<30)

Sonra sayı ikili dönüştürülen geri döndü ve 0s ve 1s dönüştürülür ve .. Dönüşüm sırasında sonuna iki boşluk eklenir.

bin(n+36*(n<30)<<2)[3:].replace(*'0 ').replace(*'1.')

    n+36*(n<30)                                       #add leading base36 '1'
               <<2                                    #add 2 0's to end
bin(              )                                   #convert to binary string
                   [3:]                               #remove '0b1' from front
                       .replace(*'0 ').replace(*'1.') #replace 0 and 1

Örneğin.

C    base36    int     <<2       bin-str        str
3 ->   13   ->  39  ->  156 -> 0b10011100 -> '  ...  '

Sonuçtaki her .biri için, girişteki bir sonraki karakterle değiştirilir (tarafından yinelenir x)

while'.'in`R`:R=eval(`R`.replace('.',x[0],1));x=x[1:]+s

Güzel! Bunun nasıl çalıştığına dair bir açıklama için sizi rahatsız edebilir miyim? Şu anda bu gözlerim için bir sihirbaz.
Scoots

@Scoots Üzerinde! :)
TFeld

3
Eklediğin için teşekkürler :) Bu sitedeki cevaplarda gördüğüm
zekâ

Parçalar 5 bit olduğundan, neden taban 32'yi kullanmıyorsunuz?
Neil

6

Java 8, 917 907 bayt

int i,l;String[]S;s->{String q=" ",t="",r[]={t,t,t,t,t};S=s.toUpperCase().replaceAll("[^A-Z0-9]",t).split(t);i=-1;l=S.length;for(String c:S){r[0]+=s("12357BDEFHIJKLMNPRTUVWXYZ",c)+s("012356789ABCDEFGIJOPQRSTZ",c)+s("0123456789ABCDEFGIJOPQRSTZ",c)+s("023456789ABCDEFGIJOPRSTZ",c)+s("567CEFGHIJKMNSTUVWXYZ",c)+q;r[1]+=s("05689ABCDEFGHKLMNOPQRSUVW",c)+s("4MNXY",c)+s("1IJT",c)+s("04KMQXYZ",c)+s("023789ABDHMNOPRUVW",c)+q;r[2]+=s("0456ABCDEFGHKLMNOPQRUW",c)+s("245689ABEFHKPRSV",c)+s("012345689ABEFHIJKMNPQRSTWXYZ",c)+s("23456789ABGHPQRSV",c)+s("0349ADGHMNOUW",c)+q;r[3]+=s("0268ABCDEFGHKLMNOPQRUW",c)+s("0VWXZ",c)+s("17IJTY",c)+s("4KNQRVWX",c)+s("035689ABDGHMNOSUW",c)+q;r[4]+=s("12359ABDEFHIJKLMNPRSWXZ",c)+s("012356789BCDEGIJLOQSUZ",c)+s("01235689BCDEGILOQSTUVYZ",c)+s("012345689BCDEGILOSUZ",c)+s("12ACEGHIKLMNQRWXZ",c)+q;}return"".join("\n",r);}String s(String...s){return s[0].contains(s[1])?S[++i%l]:" ";}

En azından mevcut bayt sayımını umarım yarıya indirmek için buradan golf oynayacaktır.

Çevrimiçi deneyin.

Açıklama:

int i,                         // Index-integer on class-level
    l;                         // Length-integer on class-level
String[]S;                     // String-array of characters on class-level

s->{                           // Method with String as both parameter and return-type
  String q="  ",               //  Temp String containing two spaces to reduce bytes
         t="",                 //  Temp Empty String to reduce bytes
         r[]={t,t,t,t,t};      //  Start with five empty rows
  S=s.toUpperCase()            //  Transform the input-String to uppercase
     .replaceAll("[^A-Z0-9]",t)//  Remove all non alphanumeric characters
     .split(t);                //  And transform it into a String-array of characters
  i=-1;                        //  Set the index-integer on -1 to start with
  l=S.length;                  //  Set the length of the modified input
  for(String c:S){             //  Loop over the characters of the modified input:
    r[0]+=                     //   Append to the first row:
          s("12357BDEFHIJKLMNPRTUVWXYZ",c)      // The first pixel
          +s("012356789ABCDEFGIJOPQRSTZ",c)     // The second pixel
          +s("0123456789ABCDEFGIJOPQRSTZ",c)    // The third pixel
          +s("023456789ABCDEFGIJOPRSTZ",c)      // The fourth pixel
          +s("567CEFGHIJKMNSTUVWXYZ",c)         // The fifth pixel
          +q;                                   // Two trailing spaces
    r[1]+=                     //   Append to the second row:
          s("05689ABCDEFGHKLMNOPQRSUVW",c)      // The first pixel
          +s("4MNXY",c)                         // The second pixel
          +s("1IJT",c)                          // The third pixel
          +s("04KMQXYZ",c)                      // The fourth pixel
          +s("023789ABDHMNOPRUVW",c)            // The fifth pixel
          +q;                                   // Two trailing spaces
    r[2]+=                     //   Append to the third row:
          s("0456ABCDEFGHKLMNOPQRUW",c)         // The first pixel
          +s("245689ABEFHKPRSV",c)              // The second pixel
          +s("012345689ABEFHIJKMNPQRSTWXYZ",c)  // The third pixel
          +s("23456789ABGHPQRSV",c)             // The fourth pixel
          +s("0349ADGHMNOUW",c)                 // The fifth pixel
          +q;                                   // Two trailing spaces
    r[3]+=                     //   Append to the fourth row:
          s("0268ABCDEFGHKLMNOPQRUW",c)         // The first pixel
          +s("0VWXZ",c)                         // The second pixel
          +s("17IJTY",c)                        // The third pixel
          +s("4KNQRVWX",c)                      // The fourth pixel
          +s("035689ABDGHMNOSUW",c)             // The fifth pixel
          +q;                                   // Two trailing spaces
    r[4]+=                     //   Append to the fifth row:
          s("12359ABDEFHIJKLMNPRSWXZ",c)        // The first pixel
          +s("012356789BCDEGIJLOQSUZ",c)        // The second pixel
          +s("01235689BCDEGILOQSTUVYZ",c)       // The third pixel
          +s("012345689BCDEGILOSUZ",c)          // The fourth pixel
          +s("12ACEGHIKLMNQRWXZ",c)             // The fifth pixel
          +q;}                                  // Two trailing spaces
  return"".join("\n",r);}      //  Return the rows joined with new-lines

//  Separated method with String-varargs parameter and String return-type
String s(String...s){          
  return s[0].contains(s[1])?  //  If the String contains the character-String:
                               //   Increase `i` by 1 first with `++i`
    S[++i%l]                   //   Then return the i'th character of the modified input
                               //   with wraparound by using modulo-`l`
   :                           //  Else:
    " ";}                      //   Return a space

Kendi kendine yeten bir örneğiniz yok gibi görünüyor. Sınıf alanları, yöntemler ve lambdalar. Beklendiği gibi zaman ayırdığınız için + 1'ledim, ancak buradaki yol biraz geçersiz görünüyor.
Olivier Grégoire

@ OlivierGrégoire Hmm, onları sınıf düzeyinde ayarlamadığınız sürece sınıf düzeyindeki alanlara izin verildiğini düşündüm (işlevin kendine yeten herhangi bir şeyi sıfırlamadan birden çok kez çalıştırılması gerekir). Bu yüzden i=-1lambda'nın içini aldım . Ama belki yanılıyorum ve metaya göre izin verilmiyor? EDIT: C cevaplarında benzer bir şey oldukça sık yapılır.
Kevin Cruijssen

Bilmiyorum. Bu yüzden "görünüyor" kelimesini kullandım. Ancak bu, ilkel değerleri varsayılan değerlerine yansıtmanın türetilmiş bir yoludur ve birçok golf cevabı için önemli etkiye sahiptir. Örneğin: int i;f->{for(;i++<10;)print(i);}1 bayt daha kısadır f->{for(int i=0;i++<10;)print(i);}.
Olivier Grégoire

@ OlivierGrégoire Bu yüzden i=-1lambda fonksiyonunun içinde olduğunu söyledim . Örneğiniz aynı lambda'yı iki kez çalıştırırsanız işe yaramaz, benimki buradaki temel farktır. int i;f->{for(i=0;i++<10;)print(i);}örneğin (daha kısa olmasa da) izin verilebilir.
Kevin Cruijssen

5

Japt v2.0a0 -R, 213 211 210 209 206 193 191 190 bayt

Her satırda önde gelen bir boşluk içerir.

uf w \
£ `...` ò4 gXn36) nLõd) ¤r0S r1 @ gT ° ò5n) ù6Ãy m¸

Deneyin veya tüm karakterleri test edin (ekstra baytların TIO'nun Japt v2'yi henüz desteklememesi nedeniyle)


açıklama

Arama Tablosu

Dizedeki 4 karakterden oluşan her grup ( ...yerden tasarruf etmek için burada temsil edilir ve bir grup yazdırılamazlar içerdiğinden ), yeni satırlar kaldırılmış ve base-100'e dönüştürülmüş her karakterin (karakterler 0için boşluklar 1için) ikili temsilidir .

Misal

ZZZZZ -> 11111
   Z  -> 00010
  Z   -> 00100 -> 1111100010001000100011111 -> 32575775 -> !::L
 Z    -> 01000
ZZZZZ -> 11111

Kod

                                                :Implicit input of string U
u                                               :Uppercase
  f                                             :Get the array of characters matching
   \w                                           : /[a-z0-9]/gi
\n                                              :Reassign to U
£                                               :Map each character as X
 `...`                                          :  The string described above
      ò4                                        :  Split into strings of length 4
          Xn36                                  :  Convert X from base-36 to decimal
         g    )                                 :  Get the element in the array at that index
                Lõ                              :  Range [1,100]
                  d                             :  Get characters at those codepoints
               n   )                            :  Convert from that base to decimal
                    ¤                           :  Convert to binary
                     r0S                        :  Replace all 0s with spaces
                         r1                     :  Replace all 1s
                           @                    :  By passing each match through a function
                             T°                 :    Postfix increment T (initially 0)
                            g                   :    Get the character in U at that index (Yay, index wrapping!)
                               Ã                :  End replacement
                                ò5n)            :  Split into strings of length 5, weighted towards the end
                                    ù6          :  Left pad each with spaces to length 6
                                      Ã         :End mapping
                                       y        :Transpose
                                         m      :Map
                                          ¸     :  Join with spaces
                                                :Implicitly join with newlines and output

4

Yakut , 366 bayt

->s{s.tr!('^0-9A-Za-z','');b=([s]*s.size).map(&:chars);%w(esuu6vfveeeufuvvfhvvhghheucufvhhhhhv j411agg1hhhhghgggh44igrphhihg4hhhaa2 l4e7vuu2efvughssjv44sgllhumue4hal444 p4g121h4h1hhghgghh44ighjhgii14hara48 evvu2ue8euhufuvgfhvohvhhegdhu4e4hh4v).map{|x|w=t='';s.chars{|c|c=~/\w/&&w+="%5b  "%x[c.to_i 36].to_i(36)};w.size.times{|i|t+=w[i]>?0?b[i/7].rotate![-1]:' '};t}}

Çevrimiçi deneyin!

Bu çok golf olabilir, ama şimdi zamanım ve fikirlerim tükendi. Sadece çalışmasını sağlamak için düşündüğümden daha zordu.

Nasıl çalışır:

Anlamak o kadar zor değil, sadece alfabenin bir örnekle nasıl kodlandığını açıklayacağım. Her karakterin her satırı ikiliye, sonra da taban 36'ya dönüştürülür.

 AAA   -> 01110 -> E
A   A  -> 10001 -> H
AAAAA  -> 11111 -> V
A   A  -> 10001 -> H
A   A  -> 10001 -> H

İlk adım, alfasayısal olmayan tüm karakterleri giriş dizesinden çıkarmaktır.

Sonra satır için satır yazdırmak istiyorum, çünkü son render için bir arama tablosu oluşturmak.

Bundan sonra, alfabe satırında yineleme yaparak harflerin ikili desenini oluşturuyorum.

Sonunda 0'ı boşluklarla ve 1'i arama tablosundaki karakterlerle değiştiriyorum.

Daha fazla golf oynamaktan çekinmeyin, bunun 20-30 bayt daha kısa olabileceğini biliyorum (tr yerine gsub kullanarak vb.), Ancak alfabe tablosunu daha küçük hale getiremediğim sürece şimdi ilgilenmiyorum.


4

Kömür , 172164 bayt

≔⁺⭆χιαα≔Φ↥S№αιθFθ«E⁵⭆§⪪”)∧%"<⁰ETV´el⟧2[◧À&η²p.±‹§K×GR←∨�X¶⌈hF)ξυ9DUuqε↘Z)s⎚H⊙←<¿.&]~b≧✂⪪XïJ61%ZWm/ειK⮌λ﹪▷(σΠNc←º✳Fb⌕⊘¹ÞEpM&➙δl◨α↑j≕ςL¡ρG⁰/y”⁵⁺κ×⁵⌕αι⎇Iμ§θ⊖L⊞Oυω M⁷±⁵

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

≔⁺⭆χιαα

Basamakları önceden tanımlanmış büyük harf alfabesine önekleyin.

≔Φ↥S№αιθ

Girişi büyük yapın ve desteklenmeyen tüm karakterleri filtreleyin.

Fθ«

Kalan karakterlerin üzerine gelin.

E⁵

Her satırı kendi satırına dolaylı olarak yazdırarak her satırın üzerinden geçin.

⭆§⪪”...”⁵⁺κ×⁵⌕αι

Sıkıştırılmış dize @ ovs'un büyük tamsayı sabitidir, ikilik biçime dönüştürülür ve ters çevrilir. Daha sonra 5 karakterlik 180 alt dizeye dilimlenir ve geçerli karakter ve satır için ilgili alt dize daha sonra döngüye alınır.

⎇Iμ§θ⊖L⊞Oυω 

Bit ayarlanmışsa, filtrelenmiş girişin sonraki karakterini döngüsel olarak yazdırın, aksi takdirde bir boşluk yazdırın.

M⁷±⁵

İmleci bir sonraki karakteri yazdırmaya hazır hale getirin.


3

Perl 5 ile -nlaF/[^A-Za-z0-9]+|/247 byte,

@l{0..9,A..Z}=unpack("b*",q&....!.?.......G...../.......\....c|...C......'..N.>..c.1~B......I1..~.5.8k....^|!...}.......BH.1..."1..."*FE.....&)=~/.{25}/g;eval'$;[$j%5].=($l{+uc}=~/.{5}/g)[$j++%5]=~s/./$&?uc$F[$i++%@F]:$"/ger.$"x2;'x5for@F;say for@

Çevrimiçi deneyin!


açıklama

İlk %lolarak packed verileri kullanılarak bir arama tablosu oluşturulur . Bu veriler, diğer bazı cevaplara benzer şekilde, 25 bitlik ikili bir dize (113 bayt - kömürden sadece 1 bayt daha fazla saklanır!) Olarak paketlenmiş her bir karakterin 900 bitlik ikili dizesidir, yani A:

 AAA 
A   A
AAAAA
A   A
A   A

ki, 0boşluk ve 1için Akullanmak:

01110
10001
11111
10001
10001

ve satır kesmeleri olmadan:

0111010001111111000110001

Arama her geçerli kömürün üzerine, biz iterate başlatıldı sonra @F(ki Perl kullanarak doldurulur -alistenin 5 elemanlarının her birine ekleyerek utosplit seçeneği) @;tüm değiştirirken, aramasındaki dizideki her satır için 1birlikte s uc$F[$i++%@F]olan $iinci karakteri (modülo @Fuzunluğudur @F) dönüştürülebilir upper case ve tüm 0ile s $"alanı olan varsayılan. Girilen her bir dizin, içindeki @;her karakter için doldurulduktan sonra @F, sayher satırı bir satırsonu çizgisiyle yazdırır.

Not : sonraki dize unpack, \xXXgösterim kullanılarak kaçan yazdırılamazlar içeriyor . 247 puanının doğrulanması .


3

SOGL V0.12 , 165 164 163 bayt

⁰CīøDs8↓3‛⁸⁷ω8<t↑\≈⅓dPb¦l═│ƹč<⁷i3ζ°@Ο≠ΖηKπ⁴Φd←⅔Ωī$∞ΧΗf▼xƧqWƨ∑ģpc!ƨ@┐Γ<§5ΛMn«Ιq;⁾№╔1xdψBN≤⁴ζ8□\b╗³╤>↔²Μ±}H}≤╬bφIæ7“2─{rƧ- W}⁰∑M¼nEU{SUZ+;W:?ew;cF+C}X}⁰┌cŗā;{√┼@L*┼

Buradan Deneyin!

Açıklama:

...“                 big long number of the character data
    2─               convert to a base 2 string
      {r    }        for each number in it
        Ƨ- W           get it's index in "- ": space for 0, dash for 1
             ⁰∑      join up the results
               M¼n   split into groups of 25 - the letters
                  E  save that in variable E

U{                 }⁰ map over the input uppercased
  SUZ+                  push 1234567890 + the alphabet
      ;W                get the current characters index in that string
        :?       }      duplicate, if not 0 (aka if found)
          e               push the variable E
           w              get in it the duplicated number'th item
                            this leavesleaving the array below the item
            ;             get the array ontop
             cF+C         append the character to the array C
                  X     and remove the top item - either the duplicate or the array

┌             push "-"
 c            load the variable C
  ŗ           cycically replace "-" in maps result with the characters of C
   ā          push an empty array - the output
    ;{        for each item in the result of the replacement
      √         squareify it
       ┼        and append that to the output array
        @L*┼    top-to-bottom, left-to-right add 10 spaces to the array

2

JavaScript (node.js) , 365 347 bayt

@Scoots sayesinde 1 bayt kaydedildi

5 dizeden oluşan bir dizi döndürür. Her satırda önde gelen bir boşluk içerir.

37 Her şeyi büyük harfe dönüştürürken ve eşleştirirken 36 bayt kaybedildi [A-Z0-9]: - /

a=>(a=a.toUpperCase(s=[...'     ']).match(/[A-Z\d]/g)).map(x=c=>(g=n=>n<35&&g(n+1,s[n<25?n/5|0:n%5]+=Buffer("mJ*Z?<^#?.&+o@V+`L7ho=Jkm?`:Tm)Km?ZZo@p*#MmjoCZ[=('ZoC#;?-g[RZW[>.cJ#Mmm?<^;Vp5[#p*]?,iM#KAm$$:Mm?0*R[#;-46B#qC;o==*X$(km?0-XDc=$.Mm#%]=X$*-?1M[".slice(parseInt(c,36)*(i=v=4))).map(c=>v+=c%80*80**--i)|v>>n&n<25?a[++x]||a[x=0]:' '))(0))&&s

Çevrimiçi deneyin!

Karakter kodlaması

Karakterler baş aşağı kodlanır ve ASCII aralığı kullanılarak 4 ofseti ile özel bir tabana 80 dönüştürülür [35..114] .

Değerler 35 için 79 değerleri ise, doğrudan tekabül eden bir ASCII karakter eşlenir, 0 ile 34 karakter eşlenir 80 için 114 . Bu sadece ASCII kod modulo 80 alarak kod çözme sağlar .

Örneğin, 'F' şu şekilde kodlanır "RZW[":

....#     00001
....#     00001
..### --> 00111 --> 0000100001001110000111111 --[decimal]--> 1088575 --[-4]--> 1088571
....#     00001
#####     11111

floor(1088571 / 80**3)        = 2    --> (( 2 + 45) mod 80) + 35 = 82  --> 'R'
floor(1088571 / 80**2) mod 80 = 10   --> ((10 + 45) mod 80) + 35 = 90  --> 'Z'
floor(1088571 / 80)    mod 80 = 7    --> (( 7 + 45) mod 80) + 35 = 87  --> 'W'
1088571                mod 80 = 11   --> ((11 + 45) mod 80) + 35 = 91  --> '['

İ = v = 4 ile başlayarak, 25 bitlik bir tam sayıya dönüştürülerek:

Buffer("RZW[").map(c => v += c % 80 * 80 ** --i)

Tam kodda, aslında kodlanmış akışın sınırsız bir dilimini () işleriz , bu da 4 kattan daha fazla yineleme yapacağımız anlamına gelir . Bu bir sorun değildir, çünkü i <0 ile yapılan tüm yinelemeler , sonucun yalnızca ondalık kısmını etkileyecektir;

Çevrimiçi deneyin!


Değiştirmek Can toUpperCaseile iRegEx'in içinde bayrak?
Shaggy

@Shaggy Çıktıda küçük harfli karakterlerin değişmesine izin vermediğini düşünüyorum.
Arnauld

Ah, haklı görünüyorsun, bunu özledim. En iyi kendi çözümümü güncelle!
Shaggy

1
Bayt [A-Z\d]yerine eşleştirerek kaydedebilir misiniz [A-Z0-9]?
Scoots

1

C (gcc) , 792690 bayt

#define S strlen
#define V v[1][i]
#define A putchar(32);
#define F(x)(((G(x,0)*92+G(x,1))*92+G(x,2))*92+G(x,3))*92+G(x,4))
#define G(x,y)(f[(x-(x<58?48:55))*5+y]-35)
i,j,l;main(c,v)char**v;{l=S(v[c=1]);char*x[l],t[l+1],*p=t,*f="$dKqK&>%Q3&R`ms&RYXg#gAB/&b_R/$n>Pw&]?vO$cbu+$ccG#$csC+&X7sS$n0w[&X+={&b^%s&b^$W$n3qS%(4\\_&^Bjg&^Bj/%(Pec$xx%S%+L`/%*jjw$cel7&X7oS$NWLO&X7u3$n.U+&^BhG%(')k%'|*/%(+:'%%UO;%%U=K&]`{+";*x=t;for(;i<l;i++){V>96?V-=32:V;(V>47)&(V<58)|(V>64)&(V<91)?*(p++)=V:V;}*p=0;for(;c<S(t);)x[c++]=((__builtin_popcount(F(t[c-1])+x[c-1]-t)%S(t))+t;for(c=6;--c;){for(i=0;i<S(t);i++){for(j=5,l=1<<c*5+3;j--;)if((l>>=1)&F(t[i]){putchar(*x[i]++);!*x[i]?x[i]=t:x;}else A A A}puts(p);}}

Çevrimiçi deneyin!

Bunu bir miktar değişken yeniden kullanımla 800'ün altında sıkmayı başardı. Yazı tipini ints dizisi olarak saklamayı seçti , ancak uzun bir dize olarak saklamak çekici bir fikir gibi görünse de, yazı tipinin 8 bitlik parçalarının çoğu, kaçış kodlarının aldığı hoş bir ASCII karakteri değildi intdiziden daha fazla karakter .

Düzenleme: Sonuçta bir dize kodlama geçerek 700 altında var - biraz burada diğer yanıtların çoğu esinlenerek Ben yazdırılabilir ASCII karakterleri (çoğu) kullanarak bir baz-92 temsil Arnavut kaldırımı. Temsili, kaçmak için fazladan bir alana ihtiyaç duyan ancak yazı tipinde yalnızca bir kez gerçekleşen ters eğik çizgiler içerir.

Bunun dışında çok gösterişli bir şey yok - giriş (ilk komut satırı argümanından oluşur), yazı tipinde olmayan tüm karakterler ve küçük harflerle değiştirilen bir yığın dizisine kopyalanır. büyük harfli sürümlerde, her tam harfin başladığı "piksel" karakteri hesaplanır ( __builtin_popcountağrılı olarak uzun bir adı vardır, ancak yine de düşünebildiğim bitlere saymanın herhangi bir yönteminden daha iyiydi) ve daha sonra baskı satır satır ilerler. Derleyici, elbette uyarılardaki program uzunluğunun birkaç katını çıkarır.

İzleme keyfiniz için aşağıda biraz degolfed:

//The defines are listed here for reference. Some are replaced in the below code but I still use F() because it's long.
#define S strlen
#define V v[1][i]
#define A putchar(32);
#define F(x)(((G(x,0)*92+G(x,1))*92+G(x,2))*92+G(x,3))*92+G(x,4))  //How to lookup a font character given an input char x
#define G(x,y)(f[(x-(x<58?48:55))*5+y]-35)                         //Used for looking up the individual parts of a character font
i, j, l;                                           // Declaring some int variables for later use.
main(c,v) char**v; {                               // Declaring afterwards lets us have the int arg default without declaring it
  l = strlen(v[c=1]);                              // Using l as a local variable to shorten S(v[1]) and also giving c an initial value here where there was a spare 1, saving a character over writing the full c=1 init in a later for loop.
  char t[l+1], *p=t, *x[l];                        // Declaring char arrays and char*s and char* arrays. t is oversized if there are any invalid characters in the input, but that's not important for golfing.
  char *f="$dKqK&>%Q3&R`ms&RYXg#gAB/&b_R/$n>Pw&]?vO$cbu+$ccG#$csC+&X7sS$n0w[&X+={&b^%s&b^$W$n3qS%(4\\_&^Bjg&^Bj/%(Pec$xx%S%+L`/%*jjw$cel7&X7oS$NWLO&X7u3$n.U+&^BhG%(')k%'|*/%(+:'%%UO;%%U=K&]`{+";      // The font, encoded base-92 with 5 characters to a letter in the order 0123456789ABCDEF... etc.
  *x=t;                                            // The first character's "pixels" will start at the beginning of the valid input.
  for(; i<strlen(l); i++){                         // Speaking of which, now validate the input.
    v[1][i] > 96 ? v[1][i] -= 32 : v[1][i];        // Change lowercase characters to uppercase. If they aren't actually lowercase characters but have ascii value >96, they won't end up valid after this either and will be edited out on the next line. The false case does nothing, but since with the macro it is one character using the ternary operator saves a character over an if statement even though that case ends up redundant.
    (v[1][i]>47)&(v[1][i]<58)|(v[1][i]>64)&(v[1][i]<91)?*(p++)=v[1][i]:v[1][i];        // If the character is now either a numeral or an uppercase letter, set the next spot in the t array by way of the pointer p and then increment said pointer. 
  }
  *p=0;                                            // Add the null terminator to the t array, our validated input string.
  for(;c<strlen(t);) {                             // Now find out at what index each letter should start getting "pixels" from.
    x[c++] = ((__builtin_popcount(F(t[c-1])+x[c-1]-t)%strlen(t))+t;          // Use the builtin to get the number of on bits/pixels in the previous letter, then add that to the previous letter's starting pixel and take the modulus strlen() of the valid string.
  }
  for(c=6; --c;){                                  // Now start the actual printing. For each line...
    for(i=0; i<strlen(t); i++){                    // For each letter...
      for(j=5, l=1<<c*5+3; j--;) {                 // For each pixel of the 5 on this line...
        if((l>>=1) & F(t[i]) {                     // If it is on...
          putchar(*x[i]++);                        // Print it and increment the pixel-fetching pointer for this letter.
          !*x[i]?x[i]=t:x;                         // If said pointer hit the end of the valid input go back to the beginning.
        } else {
          putchar(32);                             // If it is an off pixel, print a space.
        }
      }
      putchar(32);                                 // After a letter, print two spaces.
      putchar(32);
    }
    puts(p);                                       // This is the cheapest way in character count I could come up with to output a newline. p currently points to the end of t, so it is an empty string and puts just adds a newline.
  }
}


1

Excel VBA, 816 bayt

Aralıktan [A1]ve çıkıştan konsola giriş alan anonim bir VBE anında pencere işlevi .

Bildiğim kadarıyla, bu base64sıkıştırma kullanan ilk VBA cevabı .

For i=1To[Len(A1)]:c=Mid(UCase([A1]),i,1):y=y &IIf(c Like"[0-9A-Z]",c,""):Next:l=Len(y):Set d=New MSXML2.DOMDocument:Set d=d.createElement("b64"):d.DataType="bin.base64":d.Text="HxHxCSEqRkVUjLvGSJSK0cUYIyGEfB8cfFH66Ju0kkHoo3cxRhdnzTHGuuOHEMIouYyYEPI/IeTH+GN8ccIHIYf/Qw6/jzH6ByF8PvroY/zR+fCic9FFh4gI30UPnw8efiG+Mj6c4D90wX9CCHe5Tgc=":b=d.nodeTypedValue:For i=0To 112:k=Right("00000" &Evaluate("=Dec2Bin("&b(i)&")"),8)&k:Next:For i=1To 5:For j=1To l:c=UCase(Mid(y,j,1)):Z=c Like"[0-9]":s=s &IIf(c Like"[A-Z]",Mid(k,IIf(Z,1,25*(Asc(c)-55)+5*i),5)&" ",IIf(Z,Mid(k,25*(Asc(c)-48)+5*i,5)&" ","")):Next:s=Replace(Replace(s,0," "),1,"#") &vbLf:Next:Do:i=InStr(1+(g*l+h)*6+g,s,"#"):p=(p-e)Mod l:e=i<(g*l+h+1)*6+g:s=IIf(e,Left(s,i-1)&Replace(s,"#",Mid(y,p+1,1),i,1),s):g=g-(0=e):h=h-(g>4):g=g Mod 5:Loop While InStr(1,s,"#"):?s

Not: Bu cevap Microsoft XML, v3.0VBA referansına bağlıdır

Örnek G / Ç

[A1]="'0123456789"
For i=1To[Len(A1)]:c=Mid(UCase([A1]),i,1):y=y &IIf(c Like"[0-9A-Z]",c,""):Next:l=Len(y):Set d=New MSXML2.DOMDocument:Set d=d.createElement("b64"):d.DataType="bin.base64":d.Text="HxHxCSEqRkVUjLvGSJSK0cUYIyGEfB8cfFH66Ju0kkHoo3cxRhdnzTHGuuOHEMIouYyYEPI/IeTH+GN8ccIHIYf/Qw6/jzH6ByF8PvroY/zR+fCic9FFh4gI30UPnw8efiG+Mj6c4D90wX9CCHe5Tgc=":b=d.nodeTypedValue:For i=0To 112:k=Right("00000" &Evaluate("=Dec2Bin("&b(i)&")"),8)&k:Next:For i=1To 5:For j=1To l:c=UCase(Mid(y,j,1)):Z=c Like"[0-9]":s=s &IIf(c Like"[A-Z]",Mid(k,IIf(Z,1,25*(Asc(c)-55)+5*i),5)&" ",IIf(Z,Mid(k,25*(Asc(c)-48)+5*i,5)&" ","")):Next:s=Replace(Replace(s,0," "),1,"#") &vbLf:Next:Do:i=InStr(1+(g*l+h)*6+g,s,"#"):p=(p-e)Mod l:e=i<(g*l+h+1)*6+g:s=IIf(e,Left(s,i-1)&Replace(s,"#",Mid(y,p+1,1),i,1),s):g=g-(0=e):h=h-(g>4):g=g Mod 5:Loop While i<InStrRev(s,"#"):?s
 012  567   6789  0123    34  45678  9012 34567  234   567  
3  45   8       0     4  5 6  9     3         8 5   6 8   9 
6 7 8   9    123    567 78901 0123  4567     9   789   0123 
90  1   0   4         8    2      4 8   9   0   0   1     4 
 234  12345 56789 9012     3  5678   012   1     234  5678

Açıklanamayan ve Açıklanan

Bu çözümün büyük kısmı büyük yazı tipini temel 64 dizesi olarak saklar. Bu, önce yazı tipini ikili biçime dönüştürerek yapılır; burada 1bir piksel üzerinde ve 0bir pikselde temsil edilir. Örneğin 0, bu şu şekilde temsil edilir:

      ###     01110
     #  ##    10011
0 -> # # # -> 10101 --> 0111010011101011100101110
     ##  #    11001
      ###     01110

Bu yaklaşımla alfanümerikler daha sonra şu şekilde temsil edilebilir:

0: 0111010011101011100101110    1: 1110000100001000010011111
2: 1111000001011101000011111    3: 1111000001001110000111110
4: 0011001010111110001000010    5: 1111110000111100000111110
6: 0111110000111101000101110    7: 1111100001000100010001000
8: 0111010001011101000101110    9: 0111010001011110000111110
A: 0111010001111111000110001    B: 1111010001111101000111110
C: 0111110000100001000001111    D: 1111010001100011000111110
E: 1111110000111001000011111    F: 1111110000111001000010000
G: 0111110000100111000101111    H: 1000110001111111000110001
I: 1111100100001000010011111    J: 1111100100001000010011000
K: 1000110010111001001010001    L: 1000010000100001000011111
M: 1000111011101011000110001    N: 1000111001101011001110001
O: 0111010001100011000101110    P: 1111010001111101000010000
Q: 0110010010101101001001101    R: 1111010001111101001010001
S: 0111110000011100000111110    T: 1111100100001000010000100
U: 1000110001100011000101110    V: 1000110001010100101000100
W: 1000110001101011101110001    X: 1000101010001000101010001
Y: 1000101010001000010000100    Z: 1111100010001000100011111

Bu segmentler birleştirildi ve MSXML base 64'e dönüştürüldü.

HxHxCSEqRkVUjLvGSJSK0cUYIyGEfB8cfFH66Ju0kkHoo3cxRhdnzTHGuuOHEMIouYyYEPI/IeTH+GN8ccIHIYf/Qw6/jzH6ByF8PvroY/zR+fCic9FFh4gI30UPnw8efiG+Mj6c4D90wX9CCHe5Tgc=

Aşağıdaki altyordam bunu alır, geri ikiliye dönüştürür ve bunu, her karakterin ilk 5 pikseli, daha sonra ikinci satır vb. .

Alt program daha sonra çıkış dizesi üzerinde yinelenir ve 'açık' pikselleri giriş dizesindeki karakterlerle değiştirir.

''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
''
''  Embiggen Function
''
''  @Title  :   Embiggen
''  @Author :   Taylor Scott
''  @Date   :   15 June 2018
''  @Desc   :   Function that takes input, value, and outputs a string in which
''              value has been filtered to alphnumerics only, each char is then
''              scaled up to a 5x5 ASCII art, and each 'pixel' is replaced with
''              a char from value. Replacement occurs letter by letter, line by
''              line
''
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
Function EMBIGGEN(ByVal value As String) As String

    Dim DOM         As New MSXML2.DOMDocument, _
        bytes()     As Byte

    Dim isNum       As Boolean, _
        found       As Boolean, _
        index       As Integer, _
        length      As Integer, _
        line        As Integer, _
        letter      As Integer, _
        pos         As Integer, _
        alphanum    As String, _
        char        As String, _
        filValue    As String, _
        outValue    As String

    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    ''
    ''  Filter input
    ''
    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    For letter = 1 To Len(value) Step 1             ''  Iterate Accross `Value`
        Let char = Mid$(UCase(value), letter, 1)    ''  Take the nth char
        ''  If the char is alphnumeric, append it to a filtered input string
        Let filValue = filValue & IIf(char Like "[0-9A-Z]", char, "")
    Next letter
    Let length = Len(filValue)                      ''  store length of filValue

    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    ''
    ''  Convert Constant from Base 64 to Byte Array
    ''
    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    With DOM.createElement("b64")           ''  Construct b64 DOM object
        Let .DataType = "bin.base64"        ''  define type of object`
        ''  Input constructed constant string shown above
        Let .Text = "HxHxCSEqRkVUjLvGSJSK0cUYIyGEfB8cfFH66Ju0kkHoo3cxRhdnz" & _
                     "THGuuOHEMIouYyYEPI/IeTH+GN8ccIHIYf/Qw6/jzH6ByF8PvroY/" & _
                     "zR+fCic9FFh4gI30UPnw8efiG+Mj6c4D90wX9CCHe5Tgc="
        Let bytes = .nodeTypedValue         ''  Pass resulting bytes to array
    End With

    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    ''
    ''  Convert Byte Array to Byte String
    ''
    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    For index = 0 To 112 Step 1
        '' convert each byte to binary, fill left with `0`s and prepend
        Let alphanum = _
            Right("00000" & Evaluate("=Dec2Bin(" & bytes(index) & ")"), 8) & _
            alphanum
    Next index

    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    ''
    ''  Construct Embiggened Binary String of Input Value
    ''
    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    For line = 1 To 5 Step 1                ''  iterate across lines
        For letter = 1 To length Step 1     ''  iterate across letters
            ''  take the corresponding letter from
            Let char = UCase(Mid(filValue, letter, 1))
            If char Like "[0-9]" Then       '' if it is a number,
                ''  Add the 5 bit corresponding to number at line
                Let outValue = outValue & _
                    Mid$(alphanum, 25 * Val(char) + 5 * line, 5) & " "
            ElseIf char Like "[A-Z]" Then   '' if it is a letter,
                ''  Add the 5 bits corresponding to letter at line
                Let outValue = outValue & _
                    Mid$(alphanum, 25 * (Asc(char) - 55) + 5 * line, 5) & " "
            End If
            Next letter
        Let outValue = outValue & IIf(line < 5, vbLf, "")
    Next line
    Let outValue = Replace(Replace(outValue, 0, " "), 1, "#")

    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    ''
    ''  Replace #s with Input Value
    ''
    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    Let pos = 0                             ''  Reset position in filValue
    Let line = 0                            ''  Reset line index
    Let letter = 0                          ''  Reset letter index
    Do
        ''  Find the index of the first `#` starting at line and letter
        Let index = _
            InStr(1 + (line * length + letter) * 6 + line, outValue, "#")
        ''  Iterate position in filValue if a `#` is found in that letter & line
        Let pos = (pos - found) Mod length
        ''  check to see if found index is in the correct letter
        Let found = index < (line * length + letter + 1) * 6 + line
        ''  iff so, replace that # with letter in filValue corresponding to pos
        Let outValue = IIf(found, _
            Left(outValue, index - 1) & _
                Replace(outValue, "#", Mid(filValue, pos + 1, 1), index, 1), _
            outValue)
        ''  if not found, them iterate line
        Let line = line - (found = False)
        ''  iterate letter every five iterations of line
        Let letter = letter - (line > 4)
        ''  Ensure that line between 0 and 4 (inc)
        Let line = line Mod 5
    ''  Loop while there are '#'s in outValue
    Loop While InStr(1, outValue, "#")

    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    ''
    ''  Output
    ''
    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    Let EMBIGGEN = outValue

    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    ''
    ''  Clean Up
    ''
    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    Set DOM = Nothoing
End Function

1

K (ngn / k) ' , 230 231 bayt

(Dil implindeki bir değişiklikten sonra +1 bayt)

f:{{x,'"  ",/:y}/(#s;5;5)#@[(#c)#"";i;:;(#i:&c:,/(36 25#4_,/+2\a)s)#`c$b s:((b:(48+!10),65+!26)?x-32*(96<x)&x<123)^0N]}

Çevrimiçi deneyin!

burada a, yazı tipini kodlayan alıntılanmış bir dize değişmezidir. K, dizeleri bayt dizileri olarak görür, bu nedenle böyle bir değişmez değeri içeren bir program geçerlidir, ancak HTML formu UTF-8 olarak yorumlamaya ve bozmaya çalıştığından TIO'da çalıştırılamaz.

Bayt sayısı şu şekilde hesaplanır:

  • 119 TIO tarafından bildirildi

  • -2 işlevi adlandırmak için f:

  • Yer tutucu için -1 a

  • Bir çift tırnak için 2 ""

  • 113, akaçmayı gerektiren karakter içermeyen dizgi değişmezinin uzunluğu için

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.