Mad Libs: Difference between revisions

{{trans|Python}}

 

found a <noun>. <name> decided to take it home.’

 

print("\nThe story becomes:\n\n"story)

 

 

{{out}}

The fun of Mad Libs is not knowing the story ahead of time, so the program reads the story template from a text file. The name of the text file is given as a command line argument.

 

 

procedure Madlib is

Ada.Text_IO.Put_Line(Text.Element(I));

end loop;

 

It uses an auxiliary package String_Helper for simple string functions;

 

 

package String_Helper is

function Get_Vector(Filename: String) return Vector;

 

 

Here is the implementation of String_Helper:

 

 

package body String_Helper is

end Get_Vector;

 

 

A sample run (with the story template in t.txt):

 

=={{header|Aime}}==

data b;

list l;

}

 

 

=={{header|ALGOL 68}}==

{{works with|ALGOL 68G|Any - tested with release 2.8.win32}}

 

# gets the story template from the file f. The template terminates with #

story( stand in )

 

{{out}}

<pre>

 

----

 

set theNoun to the text returned of (display dialog "What is your noun?" default answer "")

display dialog thePerson & " went for a walk in the park. " & theGender & " found a " & theNoun & ". " & thePerson & " decided to take it home."

 

 

=={{header|AutoHotkey}}==

Like some other examples, this prompts the user for a text file template.<br/>AutoHotkey is interestingly well suited for this task...

If ErrorLevel

ExitApp ; the user canceled the file selection

StringReplace, contents, contents, %match%, %repl%, All

}

{{out|Sample Output}}

<pre>Han Solo went for a walk in the park. She

 

=={{header|AWK}}==

# syntax: GAWK -f MAD_LIBS.AWK

BEGIN {

exit(0)

}

{{out}}

<pre>

 

=={{header|BASIC256}}==

cadena = "<name> went for a walk in the park. <he or she> found a <noun>. <name> decided to take it home."

k = instr(cadena, "<")

print : print "La historia final: " : print cadena

end

 

 

=={{header|C}}==

Dealing with c strings can be quite annoying. This solution implements a dynamic string type with simple functionality which makes the actual madlibs logic a bit clearer. A quicker solution would probably circumvent the copying and moving over characters in the string by utilizing a different data structure that could make use of pointers to input data. This would reduce copying, and require less memory, and allocations for.

#include <stdio.h>

#include <stdlib.h>

return 0;

}

{{out}}

<pre>

 

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

#include <string>

using namespace std;

 

return 0;

 

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

using System.Linq;

using System.Text;

}

}

 

=={{header|Clojure}}==

(:require [clojure.string :as str]))

 

; While Bob Dylan walk, strange man

; appears and gave Bob Dylan a Nobel prize.

 

=={{header|Commodore BASIC}}==

 

20 print chr$(147);chr$(14);"Mad Lib Processor":print

25 gosub 1000

230 return

250 print chr$(147):print "Processing...":print

260 t$=bf$(i)

265 for c=1 to len(t$):ch$=mid$(t$,c,1)

280 m=m-1:return

300 rem insert cr for word wrap

320 if peek(pt)=32 then gosub 350:if(ll+sz>39) then poke pt,13:ll=-1:sz=0

325 if peek(pt)=13 then ll=-1

400 rem output memory buffer

401 ln=0:print chr$(147);

420 if c=13 then ln=ln+1

425 print chr$(c);

2105 print:print er;"- ";en$;" at .:";et$;" .:";es$

2110 print:print "Press a key.":gosub 500

 

'''Input File'''

ready.

&#9608;</pre>

 

=={{header|D}}==

{{trans|Ruby}}

 

void main() {

 

writeln("\nThe story becomes:\n", story);

{{out}}

<pre>Enter a story template, terminated by an empty line:

 

=={{header|Erlang}}==

-compile(export_all).

 

lists:foldl(fun ([M],D) ->

dict:store(M,"",D)

 

This version can be called via either madlib:main() or madlib:main(File) to read from standard_in or from a file.

 

{{out}}

Please name a <noun>: banana

Please name a <name>: Jack

Jack went for a walk in the park. She

found a banana. Jack decided to take it home.ok

 

=={{header|Factor}}==

IN: rosetta-code.mad-libs

 

get-mad-lib dup find-replacements replacements nl print ;

 

{{out}}

<pre>

written on it. Joseph the lucky decided to take it home.

 

MODULE MADLIB !Messing with COMMON is less convenient.

INTEGER MSG,KBD,INF !I/O unit numbers.

CALL WRITESTORY(66)

END

 

=={{header|FreeBASIC}}==

Dim As String con, cadena

cadena = "<name> went for a walk in the park. <he or she> found a <noun>. <name> decided to take it home."

Print Chr(10) & "La historia final: "

Print cadena & Chr(10)

 

=={{header|Go}}==

Variance: The fun of Mad Libs is not knowing the story ahead of time, so instead of asking the player to enter the story template, my program asks the player to enter the file name of a story template (with contents presumably unknown to the player.)

 

import (

return m[p]

}))

Sample run:

<pre>

=={{header|Haskell}}==

This will read a template story via stdin with no arguments, or read from a file if given as an argument.

 

import System.Environment (getArgs)

nlines_ <- parseText nlines M.empty

putStrLn ""

 

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

This just runs with the sample. It would be much more fun with a database of randomly selected story templates.

ml := "<name> went for a walk in the park. There <he or she> _

found a <noun>. <name> decided to take it home." # sample

story := replace(story,v,read())

write("\nYour MadLib follows:\n",story)

 

{{libheader|Icon Programming Library}}

Implementation:

 

 

madlib=:3 :0

end.

t

 

Example use:

 

Please enter the story template

See http://rosettacode.org/wiki/Mad_Libs for details

Jill went for a walk in the park. she

found a rock. Jill decided to take it home.

 

=={{header|Java}}==

I tried to fix this... but this is my first one.

 

 

public class MadLibs {

}

}

 

=={{header|Julia}}==

{{trans|Python}}

 

function madlibs(template)

println("The story template is:\n", template)

"""

 

 

{{out}}

 

=={{header|Kotlin}}==

 

fun main(args: Array<String>) {

}

println("\n$story")

 

{{out}}

 

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

k = instr(temp$,"<")

while k

print temp$

wait

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

Like some other examples, this prompts the user for a filename for a story template rather than reading the story in from user input.

InputString["Enter the filename of the story template:"]];

answers =

" " <> StringTrim[#, "<" | ">"] <> ":"] &,

Union[StringCases[text, RegularExpression["<[^>]+>"]]]];

{{out}}

<pre>George went for a walk in the park. he

found a car. George decided to take it home.</pre>

 

=={{header|Nim}}==

{{trans|Python}}

 

#let templ = readLineFromStdin "Enter your story: "

for f,v in zip(fields, values).items:

story = story.replace(f, v)

Sample run:

<pre>The story template is:

=={{header|Oforth}}==

 

| story i word |

]

 

=={{header|Pascal}}==

 

So, no stories involving < symbols, please.

Program Madlib; Uses DOS, crt; {See, for example, https://en.wikipedia.org/wiki/Mad_Libs}

{Reads the lines of a story but which also contain <xxx> sequences. For each value of xxx,

for i:=1 to StoryLines do Roll(Story[i]); {Write the amended story.}

END.

Example run:

C:\Nicky\Pascal\FILEME~1>MADLIB.EXE

=={{header|Perl}}==

Use the name of the file with a story as the parameter to the programme.

use warnings;

use strict;

 

$story =~ s/<(.*?)>/$blanks{$1}/g;

 

=={{header|Phix}}==

Set mlfile to the name of a suitable file, if you have one, otherwise it uses the default story.

{{out}}

<pre>

found a Rosetta Code Task. Pete decided to take it home.

</pre>

 

=={{header|Phixmonti}}==

true

while

endwhile

print

 

=={{header|PicoLisp}}==

This function extends the syntax a bit to be able to express different words with the same description, the syntax is <name:description>, if the description is omitted the name is used instead, keeping backwards compatibility with the syntax used in the task description:

(setq Template (split (chop Template) "<" ">"))

(let (Reps () Text ())

(prinl (need 30 '-))

(prinl (flip Text)) ) )

 

This runs the example:

=={{header|Pike}}==

this solution uses readline to make editing more convenient.

Stdio.Readline readln = Stdio.Readline();

else add_line(input);

}

 

{{out}}

=={{header|PL/I}}==

{{incorrect|PL/I|This seems to hard code the replaceable symbols instead of taking them from the story.}}

Mad_Libs: procedure options (main);

declare (line, left, right) character (100) varying;

end split;

 

<pre>

Please type a name:

 

=={{header|PowerShell}}==

function New-MadLibs

{

"`n{0} went for a walk in the park. {1} found a {2}. {0} decided to take it home.`n" -f $Name, $pronoun, $Item

}

Command line input:

New-MadLibs -Name hank -Male -Item shank

{{Out}}

<pre>

</pre>

Prompt for input:

New-MadLibs

{{Out}}

<pre>

</pre>

Command line input using splatting:

$paramLists = @(@{Name='mary'; Female=$true; Item="little lamb"},

@{Name='hank'; Male=$true; Item="shank"},

New-MadLibs @paramList

}

{{Out}}

<pre>

 

Foo went for a walk in the park. He found a bar. Foo decided to take it home.

</pre>

 

=={{header|Python}}==

 

# Optional Python 2.x compatibility

print('\nThe story becomes:\n\n' + story)

 

 

{{out}}

=={{header|Racket}}==

Instead of writing the story in the console, it reads from a file given by the player, this is mainly to keep surprise about the final text

(with-input-from-file file

(lambda ()

(string-replace mad-story (car change) (cdr change)))))

 

 

{{out}} with the story from this page

{{works with|rakudo|2015-09-18}}

Some explanation: <tt>S:g[...] = ...</tt> is a global substitution that returns its result. <tt>%</tt> is an anonymous state variable in which we cache any results of a prompt using the <tt>//=</tt> operator, which assigns only if the left side is undefined. <tt>slurp</tt> reads an entire file from STDIN or as named in the argument list.

Sample run:

<pre>$ madlibs walk

 

=={{header|REBOL}}==

t: {<name> went for a walk in the park. <he or she> found a <noun>. <name> decided to take it home.}

view layout [a: area wrap t btn "Done" [x: a/text unview]]

parse x [any [to "<" copy b thru ">" (append w: [] b)] to end]

foreach i unique w [replace/all x i ask join i ": "] alert x

=={{header|Red}}==

While the REBOL GUI version above also works in Red with minor changes, here is a text-only version.

while [not empty? line: input] [append phrase rejoin ["^/" line]]

words: parse phrase [collect [any [to "<" copy b thru ">" keep (b)]]]

foreach w unique words [replace/all phrase w ask rejoin [w ": "]]

{{out}}

Remarkably (with Red 0.6.4 for Windows built 5-Aug-2020/18:58:49+02:00), replacements made in original phrase are dynamically reflected in the display of the phrase entered. Hence first stage of execution yields:

 

=={{header|REXX}}==

parse arg iFID . /*allow user to specify the input file.*/

if iFID=='' | iFID=="," then iFID="MAD_LIBS.TXT" /*Not specified? Then use the default.*/

 

say copies('═', 79) /*display a final (output) fence. */

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

<br><br>

 

=={{header|Ring}}==

temp="<name> went for a walk in the park. <he or she> found a <noun>. <name> decided to take it home."

k = substr(temp,"<")

end

see temp + nl

 

=={{header|Ruby}}==

story = ""

until (line = gets).chomp.empty?

 

puts

 

Example

 

=={{header|Run BASIC}}==

k = instr(temp$,"<")

while k

wend

print temp$

{{out}}

<pre>

=={{header|Rust}}==

{{libheader|regex}}

 

use regex::Regex;

}

println!("Resulting story:\n\n{}", template);

{{out}}

<pre>

 

=={{header|Scala}}==

val input = "<name> went for a walk in the park. <he or she>\nfound a <noun>. <name> decided to take it home."

println(input)

println

println(output)

{{out}}

<pre><name> went for a walk in the park. <he or she>

 

=={{header|Seed7}}==

 

const proc: main is func

writeln("The story becomes:");

write(story);

 

{{out}}

=={{header|Sidef}}==

{{trans|Perl}}

 

var blanks = Hash.new;

}

 

 

=={{header|tbas}}==

LET LHS = POS(TXT$, LHS$, AFTER)

IF LHS = 0 THEN

END WHILE

 

 

=={{header|Tcl}}==

 

# Read the template...

puts [string repeat "-" 70]

puts -nonewline [string map $mapping $content]

Sample session:

<pre>

 

=={{header|VBScript}}==

End Function

 

WScript.StdOut.Write mad_libs("<name> went for a walk in the park. <he or she> found a <noun>. <name> decided to take it home.")

 

{{Out}}

name? babe

he or she? she

noun? cat

 

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

"\<" can be used to escape a "<" outside of a template (the escape is not recognized within a template), and "\>" can be used to escape a ">" inside of a template. Templates can span lines. A possible improvement from a UX standpoint is to check for template validity before beginning to request for substitutions; currently, unclosed templates are only found when they are encountered in the replacement process.

 

 

Module Program

Console.Write(result)

End Sub

 

{{out|note=for sample input}}

{{libheader|Wren-pattern}}

{{libheader|Wren-seq}}

 

System.print("Please enter a multi-line story template terminated by a blank line:\n")

story = story.replace(blank, repl)

}

 

{{out}}

 

=={{header|zkl}}==

do{ line=ask("Story: "); story.write(line,"\n") }while(line);

while(re.search(story,True)){

}

println("-----------------");

{{out}}

<pre>