Write language name in 3D ASCII: Difference between revisions

{{omit from|GUISS}}

{{omit from|TUSCRIPT}}

(We can leave the definition of "3D ASCII" fuzzy,

so long as the result is interesting or amusing,

not a cheap hack to satisfy the task.)

 

=={{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>

_/ _/ _/ _/ _/ _/

</pre>

 

=={{header|BASIC}}==

 

==={{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

to cause a colour switch using a traditional space (ascii 32),

but the output would still look the same.

1000 REM convert to binary bigmap

2000 REM display the big letters

2030 FOR m=1 TO 5: REM bigmap for each character

2050 GO SUB 1000

9000 DATA 30,17,30,17,30: REM B

9010 DATA 14,17,31,17,17: REM A

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

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

 

=={{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***}}==

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

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

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

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

{{out}}

<pre>

 

=={{header|C}}==

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

{{out}}

<pre>

</pre>

 

 

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

\/___/

</pre>

 

=={{header|COBOL}}==

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>

 

</pre>

 

=={{header|D}}==

This generates a single image ASCII stereogram.

// by Jan Hubicka and Thomas Marsh

// (GNU General Public License)

writeln();

}

{{out}}

<pre>nguageDLangunguageDLangunguageDLangunguageDLangung

geDLanguageDgeDLanuageDgeDLanuageeDgeDLanuageeDgeD

guageDLanguaguageDLanguaguageDLanguaguageDLanguagu</pre>

 

=={{header|Erlang}}==

-module(three_d).

-export([main/0]).

 

main() ->

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

</pre>

 

=== Text strings ===

\ Simple Method

 

( test at the console )

page "forth"

 

{{out}}

 

=== Bit Matrix Method ===

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

 

variable bannerstr 5 allot \ memory for the character string

 

 

 

\ 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'.)

=={{header|Java}}==

This was written ages ago as an exercise in obfuscation, and improved here with upper case letters. The font is "lean" from [http://en.wikipedia.org/wiki/Figlet figlet].

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

long[][]f={

System.out.print(' ');

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

 

{{out}} With no parameters:

</pre>

 

 

=={{header|Lasso}}==

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

| ,--, |

")

 

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

| ,--, |

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

</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 = """

 

{{out}}

 

=={{header|Perl}}==

use strict;

use warnings;

) {

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

{{out}}

<pre> _ \ |

Font taken from http://www.network-science.de/ascii/.

 

{{out}}

 

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

 

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

... ... ........ ...... ... ... ...... .....

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

=={{header|REXX}}==

===block characters===

<br><br>It's astonishing how much time I <del>wasted</del> spent on this program.

<br>Most of the time was spent on writing comments, but the code was so easy to read, so the comments were elided. &nbsp; <font size=8> ☺ </font>

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,

<pre>

________________ _____________ ____ ____ ____ ____

{{Works with|ooRexx}}

{{Works with|Regina}}

 

drop !top !bot

isFalse:

procedure

{{out}}

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

===simpler, shorter===

This is a version of the above REXX program (with a minor bug fixed),

<br>the output doesn't have extraneous leading blanks,

<pre>

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

///\ ///\

\\\/ \\\/

</pre>

 

=={{header|Ruby}}==

#### #

# # #

#

#

 

{{out}}

\\\/

</pre>

 

=={{header|Scala}}==

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

</pre>

 

=={{header|Tcl}}==

 

proc mergeLine {upper lower} {

{ * *** *}

}

{{out}}

<pre>

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

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

</pre>

 

=={{header|XPL0}}==

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

 

proc DrawBlock(X, Y);

];

];

 

{{out}}

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

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

</pre>