Embiggen ข้อมูลของคุณ


19

นี่เป็นสิ่งที่คล้ายกับรายการที่มีฝุ่นปกคลุมแต่ฉันหวังว่าการหมุนของฉันจะทำให้มีลักษณะเฉพาะ ไม่พบสิ่งใดที่ห้ามปรามฉันในการโพสต์สิ่งนี้ แต่มีทะเลอยู่ตรงนั้น

อย่างไรก็ตาม! ความท้าทาย:

รหัสของคุณได้รับสตริงอักขระ มันแปลงสิ่งนี้ให้เป็นรูปแบบ ASCII-art ของสตริงเดียวกัน แต่มีการจับ

การแปลงอินพุต

  • อักขระที่จะสนับสนุนเท่านั้นคือ AZ และ 0-9
  • อักษรตัวพิมพ์เล็กจะถูกแปลงเป็นตัวพิมพ์ใหญ่
  • สิ่งอื่นใดถูกลบอย่างเงียบ ๆ

การวาดตัวละคร

  • "พิกเซล" ของแบบอักษรขยายแต่ละอันจะถูกดึงออกมาจากสตริงอินพุต
  • พิกเซลของ n'th เท่ากับอักขระ n'th ในสตริงอินพุต ถ้า n มากกว่าความยาวของสตริงอินพุตให้ล้อมรอบกลับไปที่จุดเริ่มต้น
  • ตัวอักษรแต่ละตัวจะถูกวาดจากซ้ายไปขวา, จากบนลงล่าง
  • ตัวอักษรที่ตามมารับดัชนี "ตัวละครพิกเซล" ของพวกเขาจากที่ตัวอักษรตัวสุดท้ายทิ้งไว้ (เช่นกับความยาวของการป้อน 10 ถ้าตัวอักษรตัวแรกมี 9 พิกเซลพิกเซลตัวแรกของตัวอักษรที่สองจะถูกวาดด้วยตัวอักษรที่ 10 ตัวที่สอง พิกเซลจะถูกวาดด้วยอักขระอินพุต 1)
  • ตัวอักษรแต่ละตัวถูกวาดในตาราง 5x5 เต็มไปด้วยช่องว่าง คุณสามารถค้นหาแบบอักษรที่คุณต้องการใช้แสดงผลล่วงหน้าสำหรับคุณในpastebin นี้หรือเพิ่มเติมลงในโพสต์นี้
  • ตัวอักษรทุกตัวจะถูกวาดในบรรทัดเดียวกันดังนั้นจำนวนตัวแบ่งบรรทัดทั้งหมดในเอาต์พุตของคุณจะเป็น 4
  • จดหมายทุกฉบับคั่นด้วยช่องว่าง 2 คอลัมน์

แบบอักษร

 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

ใช่ฉันรู้ว่า 4 และ Q นั้นน่าเกลียด

ตัวอย่าง

อินพุต

0123456789

เอาท์พุต

 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 

ตัวอย่างอื่น

อินพุต

a3 B'2

เอาท์พุต

 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

ช่องโหว่มาตรฐานเป็นสิ่งต้องห้าม รหัสกอล์ฟดังนั้นจะไม่มีการทำเครื่องหมายสีเขียว


17
ฉันขอแนะนำให้รับรองว่าข้อมูลที่ป้อนจะมีเพียง[A-Z\d] - ฉันไม่คิดว่าการกรองอักขระที่ไม่ถูกต้องจะเป็นการเพิ่มสิ่งใด ๆ ให้กับความท้าทาย
Shaggy

3
@Shaggy บางที แต่ด้วยโทเค็นแบบเดียวกันฉันไม่คิดว่ามันจะลบสิ่งใดออกจากการท้าทาย
Scoots



2
สามช่องว่างชั้นนำคืออะไร? แน่นอนคุณจะไม่อนุญาตให้!
Magic Octopus Urn

คำตอบ:


16

Python 2 , 413 411 373 364 352 345 ไบต์

-1 ขอบคุณไบต์เควิน Cruijssen
-9 ไบต์ต้องขอบคุณโจกษัตริย์
-1 ขอบคุณไบต์ลินน์

สายข้อมูลประกอบด้วย unprintables หนีรุ่นด้านล่าง

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()

ลองออนไลน์!

เนื่องจากอักขระแต่ละตัวมี 25 พิกเซลจึงสามารถเข้ารหัสได้อย่างง่ายดายใน 25 บิต หมายเลขฐาน 126 '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'เข้ารหัสตัวอักษรทั้งหมดซึ่ง0จะถูกเข้ารหัสโดย 25 บิตที่สำคัญน้อยที่สุด1โดย 25 บิตถัดไปและZจะถูกเข้ารหัสโดย 25 บิตที่สำคัญที่สุด อักขระเดี่ยวถูกเข้ารหัสตามลำดับต่อไปนี้:

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

( 00เป็นบิตที่สำคัญน้อย25ที่สุดซึ่งสำคัญที่สุด)

ช่องว่างถูกเข้ารหัสด้วยศูนย์ไม่ใช่ช่องว่างโดยหนึ่ง ตัวอย่าง :

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

ลองออนไลน์!


ตัวอักษรควรคั่นด้วยช่องว่างสองช่องดังนั้น+' 'ควรเป็น+' 'ตัวอักษร คำตอบที่ดีไม่ว่าจะเป็น +1 จากฉัน
Kevin Cruijssen

คุณต้องการ.upper()ที่ไหนสักแห่งมิฉะนั้นตัวอักษรภายในก็จะเป็นตัวพิมพ์เล็ก
Jo King

@ โจกิ้งคุณพูดถูกแก้ไขแล้ว
OVS

รักเคล็ดลับการเข้ารหัสนี้ คุณเลือกฐาน 92 เพราะนั่นเป็นการเข้ารหัสมาตรฐานที่ใหญ่ที่สุดซึ่งประกอบด้วย ascii ที่พิมพ์ได้หรือไม่ คุณจะสูงขึ้นได้ไหม ฉันยัง googled แต่ไม่สามารถปรับข้อมูลบนฐาน 92 - คุณมีลิงค์?
Jonah

@Jonah ไม่มีมาตรฐานเช่นการเข้ารหัสพื้นฐานเป็น 92 นั่นคือเหตุผลที่ฉันใช้ตรรกะการถอดรหัสของตัวเอง >1ตราบใดที่คุณมีตัวเลขที่แตกต่างกันมากพอที่คุณสามารถใช้ฐานใด ๆ
ovs

10

APL (Dyalog Unicode) , 228 225 224 214 ไบต์

โปรแกรมเต็มรูปแบบ พร้อมต์ stdin สำหรับสตริง พิมพ์ไปยัง stdout ประมาณครึ่งหนึ่งของรหัสเป็นเพียงการถอดรหัสตัวอักษรที่เข้ารหัส

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

__แสดงถึงสตริงที่เข้ารหัส LZ4 143 ไบต์ต่อไปนี้ในเครื่องหมายคำพูด:"⊥\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ááЀ€€€€€€"

ลองออนไลน์!

__ สตริงที่เข้ารหัส LZ4 143 ไบต์ในเครื่องหมายคำพูด

⎕AV⍳ɩ ndices ที่อยู่ในTomic วีเอ็กเตอร์ (ชุดตัวอักษร)

¯125+ เพิ่ม -125 ลงในนั้น (เพื่อรับจำนวนเต็ม 8 บิตที่ลงชื่อ)

¯1(219⌶) LZ4 คลายการบีบอัด

0(220⌶) deserialise เป็น 36 บูล, 5 แถว, 5 คอลัมน์บูลีน

(... ทำ)⌷ ดัชนีโดยใช้ดัชนีต่อไปนี้:

⎕A ตัวพิมพ์ใหญ่A lphabet

⎕D, ย่อหน้าD igits

a← เก็บไว้ในa(สำหรับlphabet)

()∩ จุดตัดของสิ่งต่อไปนี้และ (ลบอินพุตไม่ถูกต้อง):

 พรอมต์สำหรับการป้อนข้อความจาก stdin (คอนโซล)

  1(819⌶) พับเป็นตัวพิมพ์ใหญ่ ( 819ดูเหมือนว่าBig1 มีไว้สำหรับใช่ใหญ่ตรงข้ามกับขนาดเล็ก)

i← เก็บในi(สำหรับฉัน nput)

a⍳ɩ ndices ที่อยู่ในa

 แนบ (เพื่อทำดัชนีโดยแต่ละอันแสดงถึงพิกัดชั้นนำ)

t← เก็บในt(สำหรับt ext)

, ravel (แผ่)

r← เก็บไว้ในr(สำหรับR avelled)

+/ สรุปว่า (เช่นจำนวนตัวอักษรที่จำเป็นในการทาสีงานศิลปะ)

i⍴⍨วนr eshape การป้อนข้อมูลให้มีความยาวที่

r\ ขยายที่; แทรกช่องว่างที่ 0 ใช้ตัวอักษรที่ 1s

(…) ⍴`ก่อร่างใหม่รูปร่าง:

⍴t รูปร่างของข้อความ

 แยกอาเรย์ N-by-5-by5 เป็นเมทริกซ์ N-by-5

แปลงเป็นเมทริกซ์ขนาด 5 คูณ N ของเส้นศิลปะ (ซึ่งจัดตำแหน่งบรรทัดที่สอดคล้องกันของอักขระ)

โดยค่าเริ่มต้น APL จะแยกองค์ประกอบง่าย ๆ ของอาร์เรย์ที่ซ้อนกันด้วย 2 ช่องว่าง


ไม่มาก! จะต้องมีช่องว่าง 2 ตัวระหว่างตัวอักษรแต่ละตัว
Scoots

1
@Scoots ตกลงแก้ไขแล้ว
อดัม

@ Adámมีบางอย่างผิดปกติกับC และ D
ngn

9

Python 2 , 428 ไบต์

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)

ลองออนไลน์!


ตัวอักษรมีการเข้ารหัสดังนี้:

แต่ละส่วนที่ไม่ซ้ำกัน (มี 23) จะถูกแปลงเป็นไบนารีและ 1 จะถูกเพิ่มไว้ด้านหน้า จากนั้นจะถูกแปลงเป็นฐาน 36

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

ผลลัพธ์หมายเลขฐาน 36 คือ:

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

การเริ่มต้น1จะถูกลบดังนั้นเราจึงมีอักขระตัวเดียว:

[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-9) จะถูกเข้ารหัสแล้วถึงห้าตัวอักษรใหม่เหล่านี้

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

เป็นห้ารายการ:

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

ในการแมปอินพุตกับดัชนีในรายการเหล่านี้ลำดับจะถูกปรับเปลี่ยน:

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

เนื่องจากเลขลำดับไม่ได้เป็น 0-35 แต่ผสมกันเล็กน้อยรายการทั้ง 5 รายการจึงถูกจัดเรียงใหม่และเรียงต่อกัน:

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

สำหรับอักขระแต่ละตัวในอินพุตจะพบ 5 ตัวอักษรและแปลงเป็น ints (ฐาน 36):

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

ถ้าตัวเลขอยู่ด้านล่าง30, 36ถูกเพิ่ม (หายไป1เราเอาออกก่อน)

n+36*(n<30)

แล้วจำนวนจะถูกแปลงกลับไปไบนารีและ0s และ1s จะถูกแปลงและ .จะมีการเพิ่มช่องว่างสองช่องในตอนท้ายระหว่างการแปลง

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

เช่น.

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

สำหรับ.ผลลัพธ์แต่ละรายการจะถูกแทนที่ด้วยอักขระถัดไปจากอินพุต (iterated by x)

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

ดี! ฉันขอรบกวนคุณสำหรับคำอธิบายว่ามันทำงานอย่างไร? ในขณะนี้นี่คือเวทมนตร์แห่งสายตาของฉัน
ยิง

@Scoots กับมัน! :)
TFeld

3
ขอบคุณสำหรับการเพิ่มที่ :) ความฉลาดที่ฉันเห็นในคำตอบในเว็บไซต์นี้ไม่เคยล้มเหลวในการทำให้ฉันประทับใจ
Scoots

เนื่องจากชิ้นส่วนเป็น 5 บิตทำไมไม่ใช้ base 32 แทน
Neil

6

Java 8, 917 907 ไบต์

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]:" ";}

จะตีมันลงจากที่นี่อย่างน้อยครึ่งหนึ่งหวังว่านับไบต์ปัจจุบัน ..

ลองออนไลน์

คำอธิบาย:

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

คุณดูเหมือนจะไม่มีตัวอย่างของตัวเอง คลาสฟิลด์เมธอดและ lambdas ฉัน +1 เพื่อสละเวลาไปตามที่คาดไว้ แต่ลักษณะที่นี่ดูเหมือนจะไม่ถูกต้อง
Olivier Grégoire

@ OlivierGrégoireอืมฉันคิดว่าอนุญาตให้ใช้ฟิลด์ระดับคลาสได้ตราบใดที่คุณไม่ได้ตั้งค่าไว้ในระดับคลาส นี่คือเหตุผลที่ฉันมีi=-1แลมบ์ดาอยู่ภายใน แต่บางทีฉันผิดและมันไม่ได้รับอนุญาตตาม meta? แก้ไข: สิ่งที่คล้ายกันทำได้ค่อนข้างบ่อยในคำตอบ C
Kevin Cruijssen

ฉันไม่รู้ นั่นเป็นเหตุผลที่ฉันใช้คำว่า "ดูเหมือน" แต่นั่นก็เป็นวิธีที่ได้รับมาในการติดตั้งค่าดั้งเดิมให้กับค่าเริ่มต้นโดยมีผลกระทบที่สำคัญสำหรับคำตอบของการเล่นกอล์ฟจำนวนมาก ยกตัวอย่างเช่น: int i;f->{for(;i++<10;)print(i);}1 f->{for(int i=0;i++<10;)print(i);}ไบต์สั้นกว่า
Olivier Grégoire

@ OlivierGrégoireนั่นเป็นเหตุผลที่ฉันพูดถึงi=-1ฟังก์ชั่นแลมบ์ดา ตัวอย่างของคุณไม่ทำงานหากคุณเรียกใช้แลมบ์ดาเดียวกันสองครั้งฉันใช้แลมบ์ดาซึ่งเป็นความแตกต่างหลักที่นี่ int i;f->{for(i=0;i++<10;)print(i);}จะได้รับอนุญาตตัวอย่าง (แม้ว่าจะไม่สั้นลงจริงๆ)
Kevin Cruijssen

5

Japt v2.0a0 -R, 213 211 210 209 206 193 191 190 ไบต์

รวมถึงพื้นที่ชั้นนำในแต่ละบรรทัด

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

ลองใช้หรือทดสอบอักขระทั้งหมด (ไบต์พิเศษเกิดจาก TIO ยังไม่รองรับ Japt v2)


คำอธิบาย

ตารางค้นหา

ทุกกลุ่มของ 4 ตัวอักษรในสตริง (แสดงโดย...ที่นี่เพื่อประหยัดพื้นที่และเพราะมันมีพวงของ unprintables) เป็นตัวแทนไบนารีของตัวละครแต่ละตัว ( 0สำหรับช่องว่าง1สำหรับตัวอักษร) ด้วยการขึ้นบรรทัดใหม่และถูกแปลงเป็นฐาน -100

ตัวอย่าง

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

รหัส

                                                :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

Ruby , 366 ไบต์

->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}}

ลองออนไลน์!

นี่สามารถเล่นกอล์ฟได้มาก แต่ตอนนี้ฉันหมดเวลาและความคิดแล้ว มันยากกว่าที่ฉันคิดไว้ก่อนเพื่อให้มันทำงานได้

มันทำงานอย่างไร:

มันไม่ยากที่จะเข้าใจฉันจะอธิบายวิธีการเขียนตัวอักษรด้วยตัวอย่าง ทุกบรรทัดของตัวละครทุกตัวจะถูกแปลงเป็นไบนารี่แล้วไปยังเบส -36

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

ขั้นตอนแรกคือการลอกอักขระที่ไม่ใช่ตัวอักษรและตัวเลขทั้งหมดออกจากสตริงอินพุต

จากนั้นฉันสร้างตารางการค้นหาสำหรับการเรนเดอร์ขั้นสุดท้ายเพราะฉันต้องการพิมพ์บรรทัดสำหรับบรรทัด

หลังจากนั้นทำซ้ำในบรรทัดตัวอักษรฉันสร้างรูปแบบไบนารีของตัวอักษร

ในที่สุดฉันก็แทนที่ 0 ด้วยช่องว่างและ 1 ด้วยอักขระจากตารางการค้นหา

อย่าลังเลที่จะเล่นกอล์ฟต่อไปฉันรู้ว่านี่อาจสั้นกว่า 20-30 ไบต์ (โดยใช้ gsub แทนที่จะเป็น tr และอื่น ๆ ) แต่ฉันไม่สนใจเลยเว้นแต่ว่าฉันจะทำให้ตารางตัวอักษรเล็กลงอย่างมาก


4

ถ่าน , 172 164 ไบต์

≔⁺⭆χιαα≔Φ↥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⁷±⁵

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด คำอธิบาย:

≔⁺⭆χιαα

คำนำหน้าตัวเลขไปยังตัวอักษรตัวพิมพ์ใหญ่ที่กำหนดไว้ล่วงหน้า

≔Φ↥S№αιθ

พิมพ์ใหญ่อินพุตและกรองอักขระที่ไม่สนับสนุนทั้งหมด

Fθ«

วนซ้ำอักขระที่เหลือ

E⁵

วนรอบแต่ละแถวโดยนัยการพิมพ์แต่ละผลลัพธ์ในบรรทัดของตัวเอง

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

สตริงที่บีบอัดคือค่าคงที่จำนวนเต็มขนาดใหญ่ของ @ ovs แปลงเป็นไบนารีและกลับรายการ จากนั้นจะถูกแบ่งออกเป็น 180 สตริงย่อยของ 5 อักขระและสตริงย่อยที่เกี่ยวข้องสำหรับอักขระและแถวปัจจุบันจะถูกวนซ้ำ

⎇Iμ§θ⊖L⊞Oυω 

หากบิตถูกตั้งค่าให้พิมพ์อักขระตัวถัดไปของอินพุตที่กรองแล้วหรือพิมพ์เว้นวรรค

M⁷±⁵

วางเคอร์เซอร์ให้พร้อมที่จะพิมพ์อักขระถัดไป


3

Perl 5กับ-nlaF/[^A-Za-z0-9]+|/, 247 ไบต์

@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@

ลองออนไลน์!


คำอธิบาย

อันดับแรกตารางการค้นหาจะถูกสร้างขึ้น%lโดยใช้packข้อมูล ed ข้อมูลนี้เป็นสตริงไบนารี 900 บิตของถ่านแต่ละตัวที่บรรจุเป็นสตริงไบนารี 25 บิต (เก็บไว้ที่ 113 ไบต์ - เพียง 1 ไบต์มากกว่าถ่าน!) คล้ายกับคำตอบอื่น ๆAดังนี้:

 AAA 
A   A
AAAAA
A   A
A   A

ซึ่งใช้0สำหรับพื้นที่และ1สำหรับAคือ:

01110
10001
11111
10001
10001

และไม่มีตัวแบ่งบรรทัดคือ:

0111010001111111000110001

เมื่อการค้นหาเป็น initialised เราย้ำกว่าแต่ละถ่านที่ถูกต้องใน@F(ซึ่งเป็นประชากรโดยใช้ Perl ของ-aตัวเลือก utosplit) ผนวกกับแต่ละ 5 องค์ประกอบของรายการ@;แต่ละแถวในอาร์เรย์จากการค้นหาแทนที่ทั้งหมด1s พร้อมด้วยuc$F[$i++%@F]ซึ่งเป็น$iวันที่ อักขระ (โมดูโล@Fซึ่งเป็นความยาว@F) แปลงเป็นupper case และ0s ทั้งหมดที่มี$"ค่าปริยายเป็นช่องว่าง เมื่อดัชนีแต่ละรายการ@;ถูกเติมสำหรับอักขระแต่ละตัว@Fแล้วให้sayพิมพ์แต่ละบรรทัดด้วยบรรทัดใหม่ต่อท้าย

หมายเหตุ : สตริงหลังจากunpackมี unprintables ซึ่งหนีโดยใช้\xXXสัญกร ตรวจสอบคะแนน 247


3

SOGL V0.12 , 165 164 163 ไบต์

⁰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*┼

ลองที่นี่!

คำอธิบาย:

...“                 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 ไบต์

บันทึกแล้ว 1 ไบต์ขอบคุณ @Scoots

ส่งคืนอาร์เรย์ 5 สตริง รวมถึงพื้นที่ชั้นนำในแต่ละแถว

37 36 ไบต์หายไปในการแปลงทุกอย่างให้เป็นตัวพิมพ์ใหญ่และการจับคู่[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

ลองออนไลน์!

การเข้ารหัสอักขระ

ตัวละครจะถูกเข้ารหัสคว่ำลงและเปลี่ยนไปยังฐาน-80 ที่กำหนดเองด้วยชดเชย4โดยใช้ช่วงความ ASCII [35..114]

ค่า35ถึง79ถูกแมปโดยตรงกับอักขระ ASCII ที่สอดคล้องกันในขณะที่ค่า0ไป34แมปกับตัวละคร80ไป114 นี้จะช่วยให้การถอดรหัสโดยเพียงแค่การรหัสแอสกีโมดูโล 80

ตัวอย่างเช่น'F'ถูกเข้ารหัสเป็น"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  --> '['

เริ่มต้นด้วยi = v = 4มันถูกถอดรหัสกลับไปเป็นจำนวนเต็ม 25 บิตโดยทำ:

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

ในรหัสเต็มจริง ๆ แล้วเราประมวลผลชิ้นไม่ได้ จำกัด()ของสตรีมที่เข้ารหัสซึ่งหมายความว่าเรามีแนวโน้มที่จะทำซ้ำอย่างมีนัยสำคัญมากกว่า4ครั้ง นี่ไม่ใช่ปัญหาเนื่องจากการวนซ้ำทั้งหมดที่มี<<0จะส่งผลต่อส่วนทศนิยมของผลลัพธ์เท่านั้นซึ่งจะถูกละเว้นโดยการดำเนินการระดับบิตที่ตามมาทันที

ลองออนไลน์!


คุณสามารถแทนที่toUpperCaseด้วยiค่าสถานะใน RegEx ได้หรือไม่
Shaggy

@Shaggy นั่นจะทำให้ตัวอักษรตัวเล็กไม่เปลี่ยนแปลงในผลลัพธ์ซึ่งฉันคิดว่าไม่ได้รับอนุญาต
Arnauld

อาดูเหมือนว่าคุณพูดถูก ปรับปรุงวิธีแก้ปัญหาของตัวเองให้ดีที่สุด!
Shaggy

1
คุณสามารถบันทึกไบต์ด้วยการจับคู่[A-Z\d]แทนได้[A-Z0-9]หรือไม่
ยิง

1

C (gcc) , 792 690 bytes

#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);}}

ลองออนไลน์!

จัดการเพื่อบีบนี้ภายใต้ 800 กับบางตัวแปรที่นำมาใช้ใหม่ เลือกที่จะเก็บฟอนต์เป็นอาร์เรย์int s แม้ว่าจะจัดเก็บเป็นสตริงยาวหนึ่งดูเหมือนว่าเป็นความคิดที่น่าดึงดูดใจดังนั้นจำนวน 8 บิตของแบบอักษรจึงไม่ใช่ตัวอักษร ASCII ที่สะดวกสบายที่รหัสหนีถูกใช้ อักขระมากกว่าที่intอาร์เรย์ใช้

แก้ไข: มีน้อยกว่า 700 โดยสลับไปใช้การเข้ารหัสสตริงหลังจากทั้งหมด - ค่อนข้างแรงบันดาลใจจากการตอบสนองอื่น ๆ ที่นี่ฉัน cobbled ร่วมกันเป็นตัวแทนฐาน 92 โดยใช้ (ส่วนใหญ่) อักขระ ASCII ที่พิมพ์ได้ การเป็นตัวแทนนั้นรวมถึงแบ็กสแลชที่ต้องการการหลบหลีกพิเศษ แต่จะเกิดขึ้นเพียงครั้งเดียวในฟอนต์

นอกเหนือจากนั้นมีไม่มากเกินไปที่จะเกิดขึ้นฉูดฉาด - อินพุต (ประกอบด้วยอาร์กิวเมนต์บรรทัดคำสั่งแรก) จะถูกคัดลอกไปยังอาร์เรย์สแต็กลบด้วยอักขระใด ๆ ที่ไม่ได้อยู่ในฟอนต์และแทนที่ด้วยอักษรตัวพิมพ์เล็ก เวอร์ชันตัวพิมพ์ใหญ่ตัวอักษร "พิกเซล" ตัวอักษรแต่ละตัวที่ขึ้นต้นด้วยจะถูกคำนวณ (โดยใช้ __builtin_popcountมีชื่อยาวเจ็บปวด แต่ก็ยังดีกว่าวิธีการนับบนบิตที่ฉันคิดได้) แล้วพิมพ์ไปทีละบรรทัด คอมไพเลอร์ของหลักสูตรส่งออกหลายครั้งความยาวของโปรแกรมในคำเตือน

ค่อนข้างต่ำกว่าด้านล่างเพื่อความสุขในการรับชมของคุณ:

//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 ไบต์

ฟังก์ชันหน้าต่าง VBE แบบไม่ระบุชื่อแบบทันทีที่รับอินพุตจากช่วง[A1]และเอาต์พุตไปยังคอนโซล

เท่าที่ฉันทราบนี่เป็นคำตอบ VBA แรกที่ใช้การbase64บีบอัด

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

หมายเหตุ: คำตอบนี้ขึ้นอยู่กับการMicrosoft XML, v3.0อ้างอิง VBA

ตัวอย่าง I / O

[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

Ungolfed และอธิบาย

ส่วนที่สำคัญของการแก้ปัญหานี้เก็บตัวอักษรขนาดใหญ่เป็นสตริง 64 ฐาน สิ่งนี้ทำได้โดยการแปลงฟอนต์เป็นไบนารี่เป็นอันดับแรกโดยที่จะ1แสดงเป็นพิกเซลและ0แสดงเป็นพิกเซลแบบปิด ตัวอย่างเช่นสำหรับ0สิ่งนี้ถูกแทนด้วย

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

ด้วยวิธีการนี้ตัวอักษรและตัวเลขจึงสามารถแสดงเป็น

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

ส่วนเหล่านี้ถูกต่อกันและแปลงเป็นฐาน MSXML 64 การเรนเดอร์

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

รูทีนย่อยด้านล่างใช้สิ่งนี้กลับไปแปลงเป็นไบนารี่และใช้การอ้างอิงนี้เพื่อสร้างสตริงเอาท์พุททีละบรรทัดโดยจับแรกสุด 5 พิกเซลของอักขระแต่ละตัวจากนั้นแถวที่สองเป็นต้นจนกว่าจะมีการสร้างสตริง .

รูทีนย่อยจะทำซ้ำผ่านสตริงเอาต์พุตและแทนที่พิกเซล 'on' ด้วยอักขระจากสตริงอินพุต

''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
''
''  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 ไบต์

(+1 ไบต์หลังจากการเปลี่ยนภาษา)

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]}

ลองออนไลน์!

โดยที่aเป็นสตริงตัวอักษรที่ยกมาที่เข้ารหัสตัวอักษร K เห็นสตริงเป็นลำดับของไบต์ดังนั้นโปรแกรมที่มีตัวอักษรดังกล่าวจะถูกต้อง แต่ไม่สามารถรันบน TIO ได้เนื่องจากรูปแบบ HTML ของมันพยายามตีความว่าเป็น UTF-8 และทำให้มันยุ่งเหยิง

จำนวนไบต์คำนวณเป็น:

  • 119 รายงานโดย TIO

  • -2 สำหรับการตั้งชื่อฟังก์ชั่น f:

  • -1 สำหรับตัวแทน a

  • 2 สำหรับคู่ของคำพูด ""

  • 113 สำหรับความยาวของสตริงตัวอักษรaที่ไม่มีตัวอักษรใด ๆ ที่ต้องมีการหลบหนี

โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.