Write language name in 3D ASCII: Difference between revisions

 

;Related tasks:

* [[Draw_a_cuboid|draw a cuboid]]

<br><br>

 

=={{header|360 Assembly}}==

3D EBCDIC. This program does nothing clever in any way: it just prints out strings.

STM 14,12,12(13)

BALR 12,0

BR 14

LTORG

{{out}}

<pre>

 

</pre>

 

=={{header|Ada}}==

Quotes are not escaped by \ in ada (nor does \ have any meaning in strings),

so this turns out highlighting funny.

with Ada.Strings.Fixed; use Ada.Strings.Fixed;

procedure AsciiArt is

if i mod 3 = 0 then New_Line; Put(i/3*' '); end if;

end loop;

{{out}}

<pre>

\/\\\ \/\\\ \/\\\\\\\\\\\\ \/\\\\\\\\\\\\

\/// \/// \//////////// \////////////</pre>

 

=={{header|AutoHotkey}}==

draw =

(

 

GuiClose:

{{out}}

<pre> ______ __ __ __ __

 

=={{header|AWK}}==

# syntax: GAWK -f WRITE_LANGUAGE_NAME_IN_3D_ASCII.AWK

BEGIN {

exit(0)

}

{{out}}

<pre>

 

==={{header|Applesoft BASIC}}===

20 DIM B(5,5) : REM OUR BIGMAP CHARACTERS

30 FOR L = 1 TO 5 : REM 5 CHARACTERS

9030 DATA 31,4,4,4,31: REM I

9040 DATA 14,17,16,17,14: REM C

 

==={{header|BBC BASIC}}===

{{works with|BBC BASIC for Windows}}

Uses the built-in '''BBC Micro'''-compatible character generator, so any text can be specified.

END

PRINT

NEXT row%

{{out}}

<pre>

==={{header|FreeBASIC}}===

freebasic is quite a long name, so I have done a combi.

dim as integer xres=loword(width)

 

print "BASIC"

Sleep

{{out}}

<pre> \ \ \ \ \ \ \ \ \ \ \ \

 

==={{header|Liberty BASIC}}===

r=21:s=9:c=s

For i=1 To 11

Next

Data 479667712,311470336,485697536,311699712,476292608,0,1976518785,1160267905,1171157123,1160267909,1171223529

 

{{out}}

 

==={{header|Locomotive Basic}}===

20 locate 1,25

30 print "Basic";

230 locate xp,yp+1

240 print "\\/";

 

{{Out}}

 

==={{header|TI-83 BASIC}}===

Disp “ +o+ooo +o+ooo

Disp “ .o .o

Disp “ +o +ooooo

Disp “

 

Replace . + o with 0x81,0x80,and 0x7F http://tibasicdev.wikidot.com/one-byte-tokens

but the output would still look the same.

Fixed the error and removed the need for 2^z.

20 FOR l=1 TO 5: REM 5 characters

30 FOR m=1 TO 5: REM 5 rows

9020 DATA 15,16,14,1,30: REM S

9030 DATA 31,4,4,4,31: REM I

 

To me it does not work. So I bring my particular solution:

 

10 LET d=0: INK 1: GO SUB 40

20 LET d=1: INK 6: GO SUB 40

150 DATA "XXX XXXX XXX X X "

160 DATA "X X X X X X X "

 

[[File:Basic.jpg]]

 

=={{header|Batch File}}==

for %%b in (

""

"|_______/ |__/ |__/ |__/ \______/ |__/ |__/"

""

) do echo(%%~b

 

=={{header|Befunge}}==

 

===Befunge-93===

v"'%$%'%$%3$%$%7% 0%&7&%&7&(%$%'%$"<

>"%$%7%$%&%$%&'&%7%$%7%$%, '&+(%$%"v

? ";(;(+(+$%+(%&(;(3%$%&$ 7`+( ":v >

^v!:-1<\,:g7+*63%4 \/_#4:_v#:-*84_$@

{{out}}

<pre>

(It adds line offset to those strings,and the strings are encoded with numbers just because.)

{{works with|CCBI|2.1}}

v THE DATA IMAGE.(totally useless after loading into stack)

>89 v Made by gamemanj

" "

^ $,< < < (code path reuse here,all 3 end in ,$ so I merged them)

{{out}}

<pre>

 

</pre>

 

=={{header|Brainf***}}==

Coming up with decent 3D font was honestly the hardest part.

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

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

..>>.<<.>>.>......<..>..<.<<..> >.<<.>>.>...<<.>.>..<..>..<..>.

.<..<<.>>.>..<..>..<.<<<.>..... .>>.<.>>......<<..>>..<<.<...>>

{{out}}

<pre>

 

=={{header|C}}==

const char*s = " _____\n /____/\\\n/ ___\\/\n\\ \\/__/\n \\____/";

{{out}}

<pre>

 

=={{header|C sharp|C#}}==

using System.Text;

 

}

}

 

Output:

 

=={{header|C++}}==

#include <windows.h>

#include <iostream>

}

//--------------------------------------------------------------------------------------------------

{{out}}

<pre>

</pre>

Another solution:

// @author Martin Ettl (http://www.martinettl.de)

// @date 2013-07-26

return 0;

}

{{out}}

<pre>

=={{header|Clojure}}==

{{libheader|clj-figlet}}

(println

(render-to-string

(load-flf "ftp://ftp.figlet.org/pub/figlet/fonts/contributed/larry3d.flf")

 

{{out}}

This displays 'COBOL' in 3D with a shadow effect. The font is 'Slant Relief' from [http://http://patorjk.com/software/taag/ here].

{{works with|OpenCOBOL}}

PROGRAM-ID. cobol-3d.

 

 

GOBACK

 

{{out}} (note: the shadow effect is quite faint on this site):

=={{header|Common Lisp}}==

{{libheader|cl-ppcre}}

(ql:quickload :cl-ppcre)

(defvar txt

)

(princ (cl-ppcre:regex-replace-all " " (cl-ppcre:regex-replace-all "x" txt "_/") " " ))

{{out}}

<pre>

 

=={{header|ContextFree}}==

startshape START

 

ARCL [ size 0.97 y 0.55 r 1.5 ]

}

{{out}}

[https://www.contextfreeart.org/gallery/view.php?id=4205 Output Image]

=={{header|D}}==

This generates a single image ASCII stereogram.

// by Jan Hubicka and Thomas Marsh

// (GNU General Public License)

writeln();

}

{{out}}

<pre>nguageDLangunguageDLangunguageDLangunguageDLangung

 

=={{header|Dart}}==

void main(){

print("""

""".replaceAll('X','_/'));

}

{{out}}

<pre>

 

</pre>

 

=={{header|Elixir}}==

def decode(str) do

Regex.scan(~r/(\d+)(\D+)/, str)

2 3 B5_1/4 6 B3 1B/_/2 /1_2 6 B1\n3 3 B10_6 B3 3 /2B_1_6 B1

4 2 B11_2B 1B_B2 B1_B 3 /1B/_/B_B2 B B_B1\n6 1B/11_1/3 B/_/2 3 B/_/"

 

{{out}}

 

=={{header|Erlang}}==

-module(three_d).

-export([main/0]).

main() ->

io:format(" _____ _ \n| ___| | | \n| |__ _ __| | __ _ _ __ __ _ \n| __| '__| |/ _` | '_ \\ / _` |\n| |__| | | | (_| | | | | (_| |\n|____/_| |_|\\__,_|_| |_|\\__, |\n __/ |\n |___/\n").

{{out}}

<pre>

'''3D ASCII:'''

{{trans|Elixir}}

-export([decode/1]).

 

Joined = string:join(lists:flatmap(Fun, Splited), ""),

Lines = binary:replace(binary:list_to_bin(Joined), <<"B">>, <<"\\">>, [global]),

{{out}}

<pre>

 

=={{header|ERRE}}==

 

DIM TBL$[17,1]

 

END PROGRAM

{{out}}

<pre>

 

=={{header|F_Sharp|F#}}==

let maxY = picture.Length

let maxX = picture |> List.maxBy String.length |> String.length

if x = 0 then printfn ""

printf "%c" c) a2

{{out}}

<pre>

=={{header|Forth}}==

=== Text strings ===

\ Simple Method

 

( test at the console )

page "forth"

 

{{out}}

 

=== Bit Matrix Method ===

\ Modified BFox for simple 3D presentation 2015-07-14

 

\ test the solution in the Forth console

 

 

{{out}}

 

</pre>

 

=={{header|Go}}==

 

For the interest component of the task, I thought about rendering the result from an input string and realized that it wasn't completely trivial as the glyphs of the Lean font overlap with the standard letter spacing. Rendering different fonts would add interest because now there would be a point in developing a common font representation and rendering function. Block and Lean would have sufficed, but I looked further and found the Keyboard and Small Keyboard fonts. These I found somewhat amusing, for the final component of the task.

 

import (

fmt.Println(render("Go", lean))

fmt.Println(render("Go", smallKeyboard))

{{out}}

<pre>

=={{header|Groovy}}==

A simple way to display ASCII art

_|_|_|

_| _| _|_| _|_| _|_| _| _| _| _|

_|_|_| _| _|_| _|_| _| _|_|_|

_|

A more complicated example:

def request = "http://www.network-science.de/ascii/ascii.php?TEXT=${delegate}&x=23&y=10&FONT=block&RICH=no&FORM=left&STRE=no&WIDT=80"

def html = new URL(request).text

}

 

{{out}}

<pre> _|_|_|

=={{header|Haskell}}==

A simple printing of the ASCII art

{-

__ __ __ ___ ___

 

main = putStrLn ascii3d

 

{{out}}

=={{header|Icon}} and {{header|Unicon}}==

The following fits under the fuzzy definition of 3D ASCII and pays homage to one of the Icon Newsletter logos.

write(ExpandText(

if !arglist == "icon" then

s ? until pos(0) do

writes(repl(" ",tab(many(&digits)))|tab(upto(&digits)|0))

 

{{out}} with "icon" as the argument:

=={{header|J}}==

 

view 5#.^:_1]21-~a.i.'j*ez`C3\toy.G)' NB. Due to Oleg Kobchenko

________________________

\| | | |

\_____|_____|_____|

 

For the VRML script, see [http://nsg.upor.net/jpage/jpage.htm Andrew Nikitin's J page] (search for VRML) and for the origin of the 3D J banner, see [http://www.jsoftware.com/pipermail/programming/2007-May/006539.html Oleg Kobchenko's post to the J Forums].

Here's a slimmer version:

 

\| |

\_____|

 

Explanation: the argument says where to place the solid "blocks". Each block is described by three integers, describing position along the x, y and z axis. In other words, 1 0 0 is one position to the right of 0 0 0, while 0 1 0 is one place down and 0 0 1 is one place towards the observer. (Thus the space at the top of the "slimmer" version could have been eliminated by subtracting 2 from the middle column of integers being passed to 'view'.)

 

It's not really that obfuscated. The characters in <var>z</var> are used to draw the letters. The array <var>f</var> contains one element per letter of the alphabet. Each array element is another array of 7 longs because each output letter is made of 7 lines of text. Each long value represents a sequence of 2-bit integers that are extracted by bit-twiddling and used to find the right character in <var>z</var>.

char[]z={' ',' ','_','/',};

long[][]f={

System.out.print(' ');

System.out.println(o[i]);}}}

 

{{out}} With no parameters:

_/

_/_/

</pre>

 

=={{header|Julia}}==

{{trans|Awk}}

xxxxx

x x

xx xx x x x x xx

""", "x" => "_/"))

_/_/_/_/_/

_/ _/

=={{header|Kotlin}}==

{{trans|Java}}

 

class Ascii3D(s: String) {

Ascii3D("of the")

Ascii3D("Java entry")

 

{{out}}

 

=={{header|Lasso}}==

---------------------------------------------------------------

| ,--, |

")

 

<pre>---------------------------------------------------------------

| ,--, |

 

=={{header|Lua}}==

io.write("| $$\n")

io.write("| $$ /$$ /$$ /$$$$$$\n")

io.write("| $$ | $$ | $$ /$$__ $$\n")

io.write("| $$$$$$$$| $$$$$$/| $$$$$$$\n")

{{out}}

<pre> /$$

| $$$$$$$$| $$$$$$/| $$$$$$$

|________/ ______/ _______/</pre>

 

No hardcoding at all!

ImageData[Binarize[Rasterize["Mathematica", ImageSize -> 150]]], 0];

Print[StringRiffle[

ConstantArray[

" ", {Max[locs[[All, 1]]] + 1, Max[locs[[All, 2]]] + 1}],

{{output}}

<pre>

=={{header|MiniScript}}==

Nothing fancy here, but in keeping with MiniScript's "clear and simple" ethos:

" ______ _____ _________",

"|\ \/ \ ___ ________ ___|\ _____\ ________ ________ ___ ________ _________ ",

for line in data

print line

{{out}}

<pre> ______ _____ _________

 

=={{header|Modula-2}}==

FROM Terminal IMPORT WriteString,WriteLn,ReadChar;

 

ReadChar

END Art.

 

=={{header|Nanoquery}}==

println "|\\ ___ \\|\\ __ \\|\\ ___ \\|\\ __ \\|\\ __ \\|\\ \\|\\ \\|\\ ___ \\ |\\ __ \\ |\\ \\ / /| "

println "\\ \\ \\\\ \\ \\ \\ \\|\\ \\ \\ \\\\ \\ \\ \\ \\|\\ \\ \\ \\|\\ \\ \\ \\\\\\ \\ \\ __/|\\ \\ \\|\\ \\ \\ \\ \\/ / / "

println " \\ \\__\\\\ \\__\\ \\__\\ \\__\\ \\__\\\\ \\__\\ \\_______\\ \\_____ \\ \\_______\\ \\_______\\ \\__\\\\ _\\ __/ / / "

println " \\|__| \\|__|\\|__|\\|__|\\|__| \\|__|\\|_______|\\|___| \\__\\|_______|\\|_______|\\|__|\\|__|\\___/ / "

{{out}}

<pre> ________ ________ ________ ________ ________ ___ ___ _______ ________ ___ ___

=={{header|NetRexx}}==

Based on an idea found in the [[#Scala|Scala]] version.

options replace format comments java crossref symbols nobinary

 

method isFalse public constant binary returns boolean

return \isTrue()

{{out}}

<pre>

=={{header|Nim}}==

{{trans|Python}}

 

const nim = """

for i, line in lines:

{{out}}

 

=={{header|OCaml}}==

print_string "

_|_|_| _|_|_| _|_| _|_| _|_| _|

_|_|_| _|_|_| _| _| _| _| _|_|_|_|_|

"

{{out}}

<pre>

 

=={{header|Pascal}}==

program WritePascal;

 

end;

end.

Need 64-Bit Integer for this solution.

My goal was to do a straight-forward solution, (Just two nested loops, no conditional code).

 

=={{header|Perl}}==

use strict;

use warnings;

) {

print $tuple->[0] x $tuple->[1];

{{out}}

<pre> _ \ |

 

=={{header|Phix}}==

{{out}}

<pre>

===obfuscated===

For those of you who like this sort of thing, same output

===another version===

Inspired by Ruby

 

=={{header|PicoLisp}}==

{{Trans|Tcl}}

"***** * "

"* * * * * "

(maplist '((X) (transform X "/" "\\")) (cdr Lst)) )

 

 

{{out}}

///\/ ///\/ ////////////\ ////////////\/ ////////////\ ///\/ ////////////\/ ///\/

\\\/ \\\/ \\\\\\\\\\\\/ \\\\\\\\\\\\/ \\\\\\\\\\\\/ \\\/ \\\\\\\\\\\\/ \\\/

</pre>

 

=={{header|PureBasic}}==

PrintN(" ////\ ////\ ////| ")

PrintN(" //// \ __ //// \ __ |XX|_/ ")

Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()

CloseConsole()

Sample output:

<pre> ////\ ////\ ////|

 

=={{header|Python}}==

 

for i, l in enumerate(lines):

 

{{out}}

 

 

 

 

 

 

if __name__ == '__main__':

val= 27

else:

val = 26

 

{{out}}

 

import html

 

ascii_text = ascii_text[:ascii_text.index(post_ascii)]

 

{{out}}

<pre> ____ __ __

/\___/

\/__/</pre>

 

=={{header|Racket}}==

Use the GUI to create a text banner:

 

#lang racket/gui

 

(for ([line (dropf-right (dropf lines empty?) empty?)])

(displayln (string-trim line #:left? #f))))

 

{{out}}

(formerly Perl 6)

Produces a good old-fashioned stereogram, meant to be looked at by focusing beyond the screen, not by crossing your eyes. If you can't get it to converge, try shrinking the font size till the images are closer together than your eyes. Also helps to be old enough to have progressive lenses, so you can look through the reading part of your glasses. Or borrow glasses from someone who's farsighted. <tt>:-)</tt>

my $text = q:to/END/;

.say;

}

{{out}}

<small><pre>

 

=={{header|Raven}}==

" ##### #### # # #### # #"

" # # # # # # # ## #"

$line r/#/@@@/g r/ /X/g r/X/ /g r/@ /@!/g r/@$/@!/g as $l1

$l1 "@" split $r1 join "!" split $r2 join print "\n" print

{{out}}

<pre> ///////////////> ////////////> ///> ///> ////////////> ///> ///>

 

This REXX has been used as part of a test suite for some REXX interpreters to stress test their syntax parser.

signal . /* Uses left-hand shadows, slightly raised view.

0=5~2?A?2?A?

,13,u));_=_('=',left('',16,u));_=_('#','|\\|');_=translate(_,"|"u,'@"')

do k=0 for 16;x=d2x(k,1);_=_(x,left('',k+1));end;say ' '_;end;exit;_:return,

Some older REXXes don't have a &nbsp; '''changestr''' &nbsp; BIF, so one is included here &nbsp; ──► &nbsp; [[CHANGESTR.REX]].

 

{{Works with|ooRexx}}

{{Works with|Regina}}

 

drop !top !bot

isFalse:

procedure

{{out}}

<pre> ///////////////\

<br>the output doesn't have trailing blanks,

<br>the input text can be any consistent non-blank character except the forward slash &nbsp; (<big>'''/'''</big>) &nbsp; or backward slash &nbsp;(<big>'''\'''</big>).

#=7; @.1 = '@@@@ '

@.2 = '@ @ '

do k=1 for 2; say strip(left('',#-j)$.k,"T") /*the LEFT BIF does indentation.*/

end /*k*/ /* [↑] display a line and its shadow.*/

{{out|output|text=&nbsp; when using the internal default input:}}

<pre>

 

=={{header|Ruby}}==

#### #

# # #

#

#

 

{{out}}

 

'''Another version:''' like a 3D solid.

def decode(str)

str.split(/(\d+)(\D+)/).each_slice(3).map{|_,n,s| s * n.to_i}.join.tr('sub','/_\\')

end

 

{{out}}

 

=={{header|Rust}}==

[' ', '#', '/', '_', 'L', '|', '\n'][id as usize]

}

 

println!("{}", decode(&code));

 

{{out}}

{{libheader|Scala}}

===Java style===

 

val name = """

}

 

===Idiomatic===

Cleaner code.

 

object Ascii3D extends App {

 

println(ASCII3D)

{{out}}

<pre>

 

=={{header|Seed7}}==

 

const array string: name is [] (

end for;

writeln(previousLine);

 

{{out}}

=={{header|Sidef}}==

{{trans|Ruby}}

 

***

};

 

<pre>

 

=={{header|SQL}}==

union all select 'S \|', 'Q Q\ ', 'L | ' from dual

union all select '\SSS ', 'Q Q |', 'L | ' from dual

union all select ' SSS |', '\QQQ\\|', 'LLLL\' from dual

union all select ' \__\/', ' \_Q_/ ', '\___\' from dual

This works in Oracle. For other databases, try it without "from dual".

{{out}}

 

=={{header|Tcl}}==

 

proc mergeLine {upper lower} {

{ * *** *}

}

{{out}}

<pre>

=={{header|UNIX Shell}}==

{{works with|Bash|4}}

mapfile -t name <<EOF

Aimhacks

 

main "$@"

{{Out}}

<pre> __/__/__/ __/

=={{header|Visual Basic .NET}}==

{{trans|C#}}

 

Sub Main()

End Sub

 

{{out}}

<pre> ___ ___ ___ ________ ___ ___ ________ ___ ________ ________ ________ ___ ________ ________ _______ _________

=={{header|Wren}}==

This uses the 3D ASCII letter font [https://github.com/arpan98/3dwrite/blob/master/3d_font.txt here].

 

 

 

 

for (i in 0..8) {

System.print("%(w[i]) %(r[i]) %(e[i]) %(n[i])")

 

{{out}}

<pre>

</pre>

 

=={{header|XPL0}}==

Here's XPL0's "cheap hack." (Hats off to D!)

 

proc DrawBlock(X, Y);

];

];

 

{{out}}

 

=={{header|Yabasic}}==

// Method 1

// r$ = system$("explorer \"http://www.network-science.de/ascii/ascii.php?TEXT=${delegate}&x=23&y=10&FONT=block&RICH=no&FORM=left&STRE=no&WIDT=80&TEXT=Yabasic\"")

write(2, 2, "\\")

write(1, 1, "#")

 

=={{header|zkl}}==

{{trans|Common Lisp}}

"

xxxxxx x x x

"

#<<<<

{{out}}

<pre>