Rosetta Code

Narcissist: Difference between revisions

Page Discussion

Narcissist (view source)

Revision as of 13:43, 13 January 2024

12,101 bytes added ,  4 months ago
m
→‎{{header|Phix}}: missing /, or type it in
(Added PowerShell)
m (→‎{{header|Phix}}: missing /, or type it in)
 
(44 intermediate revisions by 29 users not shown)
Line 8:
</blockquote>
 
For concreteness, in this task we shall assume that symbol = character. The narcissist should be able to cope with any finite input, whatever its length. Any form of output is allowed, as long as the program always halts, and "accept", "reject" and "not yet finished" are distinguishable.
 
The narcissist should be able to cope with any finite input, whatever its length.
 
Any form of output is allowed, as long as the program always halts, and "accept", "reject" and "not yet finished" are distinguishable.
<br><br>
 
=={{header|Ada}}==
Line 15 ⟶ 20:
Took code from [[Quine]], has to be in one line (could be done pretty printed, too, but not as simple).
 
<langsyntaxhighlight Adalang="ada">with Ada.Text_IO;procedure Self is Q:Character:='"';A:String:="with Ada.Text_IO;procedure Self is Q:Character:='';A:String:=;B:String:=A(1..49)&Q&A(50..61)&Q&A&Q&A(62..A'Last);C:String:=Ada.Text_IO.Get_Line;begin Ada.Text_IO.Put_Line(Boolean'Image(B=C));end Self;";B:String:=A(1..49)&Q&A(50..61)&Q&A&Q&A(62..A'Last);C:String:=Ada.Text_IO.Get_Line;begin Ada.Text_IO.Put_Line(Boolean'Image(B=C));end Self;</langsyntaxhighlight>
 
=={{header|ALGOL 68}}==
Line 22 ⟶ 27:
{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}
{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of '''format'''[ted] ''transput''}}
<langsyntaxhighlight lang="algol68">STRINGs="STRINGs="";print(readstring=2*s[:9]+2*s[9:])";print(readstring=2*s[:9]+2*s[9:])</langsyntaxhighlight>
Output: T or F depending on input.
 
=={{header|AppleScript}}==
 
As long as the script hasn't been exported as run-only (''ie.'' without its source code):
 
<syntaxhighlight lang="applescript">(display dialog "" default answer "")'s text returned = (do shell script ("osadecompile " & (path to me)'s POSIX path's quoted form))</syntaxhighlight>
 
{{output}}
Depending on the text entered and button clicked, one of:
<syntaxhighlight lang="applescript">true
false
error "User cancelled." number -128</syntaxhighlight>
 
=={{header|Arturo}}==
<syntaxhighlight lang="arturo">blk:[print (("blk:" ++ (as .code blk) ++ "do blk") = input "") ? -> "accept" -> "reject"]do blk</syntaxhighlight>
 
{{out}}
 
<pre>$ arturo narcissist.art < narcissist.art
accept</pre>
 
=={{header|AutoHotkey}}==
{{works with|AutoHotkey 1.1}}
<langsyntaxhighlight AutoHotkeylang="autohotkey">Narcissist(Input) {
FileRead, Source, % A_ScriptFullPath
return Input == Source ? "accept" : "reject"
}</langsyntaxhighlight>
'''Example Use:'''
<langsyntaxhighlight AutoHotkeylang="autohotkey">MsgBox, % Narcissist(FileOpen(A_ScriptFullPath, "r").Read()) "`n"
. Narcissist("This isn't the text you're looking for.")</langsyntaxhighlight>
{{Output}}
<pre>accept
Line 41 ⟶ 66:
{{works with|BBC BASIC for Windows}}
Prints '1' on success and '0' on failure.
<langsyntaxhighlight lang="bbcbasic">INPUT a$:PRINT -(a$=$(PAGE+34)+$(PAGE+33)):REM INPUT a$:PRINT -(a$=$(PAGE+34)+$(PAGE+33)):REM</langsyntaxhighlight>
 
=={{header|Befunge}}==
Line 48 ⟶ 73:
Outputs <tt>1</tt> if the given line of input matches the source code, and <tt>0</tt> if it doesn't.
 
<langsyntaxhighlight lang="befunge">900:0g~>:::0>`#0\#:5#:5#:+#<#~-#g*#0\#:5#+8#1+#\-#!*#-_$$"E"-!>_9-!.@</langsyntaxhighlight>
 
=={{header|C}}==
Based upon the quine. Reads until EOF or newline from stdin, and writes "1" or "0" to stdout.
<langsyntaxhighlight lang="c">extern void*stdin;main(){ char*p = "extern void*stdin;main(){ char*p = %c%s%c,a[300],b[300];sprintf(a,p,34,p,34);fgets(b,300,stdin);putchar(48+!strcmp(a,b)); }",a[300],b[300];sprintf(a,p,34,p,34);fgets(b,300,stdin);putchar(48+!strcmp(a,b)); }</langsyntaxhighlight>
 
=={{header|C sharp}}==
<langsyntaxhighlight lang="csharp">
using System;
using System.IO;
Line 84 ⟶ 109:
}
}
</syntaxhighlight>
</lang>
 
=={{header|Common Lisp}}==
Only checks the first line of stdin:
<langsyntaxhighlight lang="lisp">#1=(PRINT (EQUAL (WRITE-TO-STRING '#1# :CIRCLE 1) (READ-LINE *STANDARD-INPUT*)))</langsyntaxhighlight>
 
=={{header|D}}==
<syntaxhighlight lang="d">import std.file; import std.stdio; import std.string; void main() { auto source = readText("narcissist.d").chomp; auto input = readln().chomp(); if (source == input) writeln("accept"); else writeln("reject"); }</syntaxhighlight>
 
=={{header|Déjà Vu}}==
<langsyntaxhighlight lang="dejavu">!. = !prompt "Enter my code: " concat( swap !decode!utf-8 !encode!quoted dup swap ) "!. = !prompt \qEnter my code: \q concat( swap !decode!utf-8 !encode!quoted dup swap ) "</langsyntaxhighlight>
 
=={{header|Forth}}==
 
<langsyntaxhighlight lang="forth">: narcissist [ source ] sliteral compare 0= ;</langsyntaxhighlight>
 
 
=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">Dim As String a, s = "Dim As String a, s = Input a : Print (a = Left(s, 21) + Chr(34) + s + Chr(34) + Mid(s, 47, 3) + Mid(s, 23, 108)) + Mid(s, 54, 3)" : Input a : Print (a = Left(s, 21) + Chr(34) + s + Chr(34) + Mid(s, 47, 3) + Mid(s, 23, 108))</syntaxhighlight>
 
 
=={{header|Go}}==
Line 100 ⟶ 134:
This version reads until EOF and expects a newline at the end of the input. If this is being checked from a file, make sure that the file has exactly one newline at the end of it.
 
<langsyntaxhighlight lang="go">package main; import "os"; import "fmt"; import "bytes"; import "io/ioutil"; func main() {ios := "os"; ifmt := "fmt"; ibytes := "bytes"; iioutil := "io/ioutil"; zero := "Reject"; one := "Accept"; x := "package main; import %q; import %q; import %q; import %q; func main() {ios := %q; ifmt := %q; ibytes := %q; iioutil := %q; zero := %q; one := %q; x := %q; s := fmt.Sprintf(x, ios, ifmt, ibytes, iioutil, ios, ifmt, ibytes, iioutil, zero, one, x); in, _ := ioutil.ReadAll(os.Stdin); if bytes.Equal(in, []byte(s)) {fmt.Println(one);} else {fmt.Println(zero);};}\n"; s := fmt.Sprintf(x, ios, ifmt, ibytes, iioutil, ios, ifmt, ibytes, iioutil, zero, one, x); in, _ := ioutil.ReadAll(os.Stdin); if bytes.Equal(in, []byte(s)) {fmt.Println(one);} else {fmt.Println(zero);};}</langsyntaxhighlight>
A version respecting the 80 character line limit:
<langsyntaxhighlight lang="go">package main
 
import (
Line 140 ⟶ 174:
}
 
var x = `</langsyntaxhighlight>
 
=={{header|Haskell}}==
<langsyntaxhighlight Haskelllang="haskell">main = let fi t e c = if c then t else e in do ct <- getContents; putStrLn $ fi ['a','c','c','e','p','t'] ['r','e','j','e','c','t'] $ take (length ct - 1) ct == let q s = (s ++ show s) in q "main = let fi t e c = if c then t else e in do ct <- getContents; putStrLn $ fi ['a','c','c','e','p','t'] ['r','e','j','e','c','t'] $ take (length ct - 1) ct == let q s = (s ++ show s) in q "</langsyntaxhighlight>
 
=={{header|Huginn}}==
<syntaxhighlight lang="huginn">#! /bin/sh
exec huginn --no-argv -E "${0}"
#! huginn
 
main() {
c = "#! /bin/sh{1}~"
"exec huginn --no-argv -E {3}${{0}}{3}{1}#! huginn{1}{1}~"
"main() {{{1}{2}c = {3}{0}{3};{1}~"
"{2}s = {3}{3};{1}~"
"{2}while ( ( line = input() ) != none ) {{{1}~"
"{2}{2}s += line;{1}~"
"{2}}}{1}~"
"{2}self = copy( c ).replace( {3}{5}{3}, {3}{3} )~"
".format({1}{2}{2}c.replace( {3}{5}{3}, ~"
"{3}{5}{4}{3}{4}n{4}t{4}t{4}{3}{3} ), ~"
"{3}{4}n{3}, {3}{4}t{3}, {3}{4}{3}{3}, {3}{4}{4}{3}, ~"
"{3}{5}{3}{1}{2});{1}~"
"{2}print( s == self ? {3}1{4}n{3} : {3}0{4}n{3} );{1}}}{1}{1}";
s = "";
while ( ( line = input() ) != none ) {
s += line;
}
self = copy( c ).replace( "~", "" ).format(
c.replace( "~", "~\"\n\t\t\"" ), "\n", "\t", "\"", "\\", "~"
);
print( s == self ? "1\n" : "0\n" );
}
</syntaxhighlight>
 
=={{header|Icon}} and {{header|Unicon}}==
{{trans|Go}}
Since we can't put a link statement and program on a single line, we implement a simplified inline sprintf so we don't have to deal with all the double quotes or substrings and offsets. If we'd needed to write multiple procedures on a line it can be done [[Icon%2BUnicon/Intro#Semi-colons| Semi-colons in the language intro]]
<langsyntaxhighlight Iconlang="icon">procedure main();yes:="Accept";no:="Reject";pat:="procedure main();yes:=$;no:=$;pat:=$;a:=[yes,no,pat];narc:=char(0)[0:0];pat?{while narc||:=tab(find(char(36))) do{narc||:=image(get(a));move(1)};narc||:=tab(0)};write(if read()==narc then yes else no);end";a:=[yes,no,pat];narc:=char(0)[0:0];pat?{while narc||:=tab(find(char(36))) do{narc||:=image(get(a));move(1)};narc||:=tab(0)};write(if read()==narc then yes else no);end</langsyntaxhighlight>
Example:<pre>./narcissist.exe < narcissist.icn
Accept</pre>
Line 154 ⟶ 218:
 
=={{header|J}}==
<langsyntaxhighlight lang="j">#!/j602usr/bin/jconsoleijconsole
main=:3 : 0 NB. tested under j602
self=: '#!/j602/bin/jconsole',LF,'main=:',(5!:5<'main'),LF,'main''''',LF
echo self -: stdin''
)
main''</langsyntaxhighlight>
 
Example use:
 
<syntaxhighlight lang="text">$ ./narcissist.ijs <narcissist.ijs
1
</langsyntaxhighlight>
 
Note that this assumes a suitable os command line.
Line 171 ⟶ 235:
 
'''Alternative solution:'''
<langsyntaxhighlight lang="j"> narcissist=.(-:,~,2#{:)&'(-:,~,2#{:)&'''</langsyntaxhighlight>
 
'''Example use:'''
<langsyntaxhighlight lang="j"> (-:,~,2#{:)&'(-:,~,2#{:)&''' '(-:,~,2#{:)'
0
(-:,~,2#{:)&'(-:,~,2#{:)&''' '(-:,~,2#{:)&''(-:,~,2#{:)&'''''''
1</langsyntaxhighlight>
 
=={{header|Java}}==
<syntaxhighlight lang="java">import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
 
public class Narcissist {
private static final String SOURCE = "import java.io.BufferedReader;%nimport java.io.IOException;%nimport java.io.InputStreamReader;%n%npublic class Narcissist {%n private static final String SOURCE = %c%s%c;%n private static final char QUOTE = 0x22;%n%n public static void main(String[] args) throws IOException {%n BufferedReader br = new BufferedReader(new InputStreamReader(System.in));%n StringBuilder sb = new StringBuilder();%n%n while (true) {%n String line = br.readLine();%n if (null == line) break;%n sb.append(line).append(System.lineSeparator());%n }%n%n String program = String.format(SOURCE, QUOTE, SOURCE, QUOTE, QUOTE, QUOTE, QUOTE, QUOTE);%n if (program.equals(sb.toString())) {%n System.out.println(%caccept%c);%n } else {%n System.out.println(%creject%c);%n }%n }%n}%n";
private static final char QUOTE = 0x22;
 
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringBuilder sb = new StringBuilder();
 
while (true) {
String line = br.readLine();
if (null == line) break;
sb.append(line).append(System.lineSeparator());
}
 
String program = String.format(SOURCE, QUOTE, SOURCE, QUOTE, QUOTE, QUOTE, QUOTE, QUOTE);
if (program.equals(sb.toString())) {
System.out.println("accept");
} else {
System.out.println("reject");
}
}
}
</syntaxhighlight>
 
=={{header|JavaScript}}==
{{works with|SpiderMonkey|1.7.0}}
Based upon [[Quine#Using_eval|one of the quines]]. Outputs 'true' if source is equal to inputted line (newline terminated), 'false' otherwise.
<langsyntaxhighlight lang="javascript">var code='var q=String.fromCharCode(39);print("var code=" + q + code + q + "; eval(code)" == readline())'; eval(code)</langsyntaxhighlight>
 
{{works with|JScript}}
<langsyntaxhighlight lang="javascript">var oFSO = new ActiveXObject("Scripting.FileSystemObject");
function readfile(fname) {
var h = oFSO.OpenTextFile(fname, 1, false);
Line 205 ⟶ 298:
// compare and contrast
WScript.Echo(self === whatever ? "Accept" : "Reject");
</syntaxhighlight>
</lang>
 
{{works with|Julia|1.2}}
 
=={{header|Julia}}==
<syntaxhighlight lang="julia">mysource = Base.read(Base.source_path(), String)
println(Int(ARGS[1] == mysource))</syntaxhighlight>
 
=={{header|Kotlin}}==
<syntaxhighlight lang="scala">// version 1.1.0 (run on Windows 10)
 
fun main(args: Array<String>) {
val text = java.io.File("narcissist.kt").readText()
println("Enter the number of lines to be input followed by those lines:\n")
val n = readLine()!!.toInt()
val lines = Array<String>(n) { readLine()!! }
if (lines.joinToString("\r\n") == text) println("\naccept") else println("\nreject")
}</syntaxhighlight>
First run (pasting in program text):
{{out}}
<pre>
Enter the number of lines to be input followed by those lines:
 
9
// version 1.1.0 (run on Windows 10)
 
fun main(args: Array<String>) {
val text = java.io.File("narcissist.kt").readText()
println("Enter the number of lines to be input followed by those lines:\n")
val n = readLine()!!.toInt()
val lines = Array<String>(n) { readLine()!! }
if (lines.joinToString("\r\n") == text) println("\naccept") else println("\nreject")
}
 
accept
</pre>
Second run (entering any old rubbish):
 
{{out}}
<pre>
Enter the number of lines to be input followed by those lines:
 
1
the quick brown fox
 
reject
</pre>
 
=={{header|Liberty BASIC}}==
NOTE: You have to manually type in ALL of the code since the Input statement will not successfully input data from a paste event even though it will show up in the MainWin.
 
<syntaxhighlight lang="lb">
<lang lb>
s$ = "s$ = Input a$ : Print (a$ = Left$(s$, 5) + chr$(34) + s$ + chr$(34) + Mid$(s$, 14, 3) + Mid$(s$, 6, 100)) + Mid$(s$, 23, 3)" : Input a$ : Print (a$ = Left$(s$, 5) + chr$(34) + s$ + chr$(34) + Mid$(s$, 14, 3) + Mid$(s$, 6, 100))
</langsyntaxhighlight>
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
{{in}}
<langsyntaxhighlight Mathematicalang="mathematica">prog = "prog = ``;\nPrint[InputString[] == \n ToString[StringForm[prog, ToString[prog, InputForm]]]];";
Print[InputString[] == ToString[StringForm[prog, ToString[prog, InputForm]]]];</syntaxhighlight>
ToString[StringForm[prog, ToString[prog, InputForm]]]];</lang>
{{out}}
<pre>True</pre>
 
=={{header|PerlNanoquery}}==
<syntaxhighlight lang="nanoquery">import Nanoquery.IO
<lang perl># this is file narc.pl
local $/;
print do { open 0; <0> } eq <> ? "accept" : "reject";</lang>
Run:
<lang>perl narc.pl < narc.pl</lang>
 
// get a file tied to this program's source
=={{header|Perl 6}}==
$f = new(File, $args[len($args) - 1])
 
// get the source and split across lines
For the narcissist to work you must be very careful with whitespace. The following version works if it is given to standard input as exactly one line terminated by a newline character.
$source = split($f.readAll(), "\n")
 
// read that amount of lines from the console
Note how the code takes advantage of Perl 6's ability to nest quoting delimiters.
$in = list(len($source))
for ($i = 0) ($i < len($source)) ($i = $i + 1)
append $in input()
end
 
// check line by line
<lang perl6>EVAL my $self = q{say slurp() eq q[EVAL my $self = q{]~$self~q[}]~10.chr ?? q{Beautiful!} !! q{Not my type.}}</lang>
for ($i = 0) ($i < len($in)) ($i = $i + 1)
// check if the lines are equal
if ($in[$i] != $source[$i])
println "Reject"
exit
end
end
 
// if we got here, the lines are the same
println "Accept"</syntaxhighlight>
 
=={{header|Nim}}==
Program written on a single line to avoid problems with indentation. But we wanted to avoid the too easy solution consisting to read the source file. Input should be terminated by an end of file (Ctrl-D on Linux).
<syntaxhighlight lang="nim">
import strutils; let a = "import strutils; let a = $#; echo ord(stdin.readAll == a % (chr(34) & a & chr(34)) & chr(10))"; echo ord(stdin.readAll == a % (chr(34) & a & chr(34)) & chr(10))
</syntaxhighlight>
 
{{out}}
<pre>./narcissist
<pre>$ narcissist='EVAL my $self = q{say slurp() eq q[EVAL my $self = q{]~$self~q[}]~10.chr ?? q{Beautiful!} !! q{Not my type.}}'
whatever...
$ perl6 -e "$narcissist" <<<"$narcissist"
0</pre>
Beautiful!
<pre>
$ perl6 -e "$narcissist" <<<"$narcissist # a comment ruining it all"
./narcissist <narcissist.nim
Not my type.
1</pre>
 
=={{header|PARI/GP}}==
<syntaxhighlight lang="parigp">narcissist()=input()==narcissist</syntaxhighlight>
Run narcissist():<pre>Hello
0</pre>
<pre>narcissist() = {input() == narcissist;}
1</pre>
 
=={{header|Perl}}==
<syntaxhighlight lang="perl"># this is file narc.pl
local $/;
print do { open 0; <0> } eq <> ? "accept" : "reject";</syntaxhighlight>
Run:
<syntaxhighlight lang="text">perl narc.pl < narc.pl</syntaxhighlight>
 
=={{header|Phix}}==
<!--(notonline)-->
<syntaxhighlight lang="phix">
printf(1,"\n\n%t\n\n",get_text(command_line()[2],GT_LF_LAST)[1]=gets(0))
</syntaxhighlight>
{{out}}
Can be run using <code>p test.exw < test.exw</code> or the input manually typed in
<pre>
true
</pre>
<small>Aside: I suppose there should really be a leading <code>without js -- file i/o</code>, but I wanted to keep it a 1-liner.<br>
Interpreted-only, as is: to allow a compiled version to run, change <code>command_line()[2]</code> to (say) <code>"test.exw"</code><br>
or maybe <code>substitute(command_line()[2],".exe",".exw")</code>, and ship with/install the source code file.</small>
 
=={{header|PicoLisp}}==
<langsyntaxhighlight PicoLisplang="picolisp">(de narcissist (Str)
(= Str (str narcissist)) )</langsyntaxhighlight>
Output:
<pre>: (narcissist "(Str) (= Str (str narcissist))")
Line 253 ⟶ 437:
 
=={{header|PowerShell}}==
<lang{{works with|PowerShell>|2}}
<syntaxhighlight lang="powershell">
function entropy ($string) {
function Narcissist
$n = $string.Length
{
$string.ToCharArray() | group | foreach{
Param ( [string]$String )
$p = $_.Count/$n
If ( $String -eq $MyInvocation.MyCommand.Definition ) { 'Accept' }
$i = [Math]::Log($p,2)
Else { 'Reject' }
-$p*$i
} | measure -Sum | foreach Sum
}
</syntaxhighlight>
entropy $(get-content "$($MyInvocation.MyCommand.Name )" -Raw)
<syntaxhighlight lang="powershell">
</lang>
Narcissist 'Banana'
Narcissist @'
 
Param ( [string]$String )
If ( $String -eq $MyInvocation.MyCommand.Definition ) { 'Accept' }
Else { 'Reject' }
 
'@
</syntaxhighlight>
{{out}}
<pre>
Reject
4.74418336918292
Accept
</pre>
 
=={{header|Python}}==
For{{Works with|Python |2.x:}}
<syntaxhighlight lang="python">
<lang Python>
import sys
with open(sys.argv[0]) as quine:
Line 278 ⟶ 473:
else:
print("Reject")
</syntaxhighlight>
</lang>
 
{{Works with|Python|3}}
<syntaxhighlight lang="python">
_='_=%r;print (_%%_==input())';print (_%_==input())
</syntaxhighlight>
 
=={{header|Quackery}}==
 
As a dialogue in the Quackery shell. (REPL)
 
<syntaxhighlight lang="quackery">Welcome to Quackery.
 
Enter "leave" to leave the shell.
 
/O> [ this copy unbuild = ] is narcissist
... $ "[ this copy unbuild = ]" narcissist
...
 
Stack: 1
 
/O> drop
... $ "Nothing is more important than my egomania. -- Clara Oswald" narcissist
...
 
Stack: 0
 
/O> leave
...
 
Cheerio.</syntaxhighlight>
 
=={{header|Racket}}==
Line 285 ⟶ 510:
typed when the code stops to read some input.
 
<syntaxhighlight lang="racket">
<lang Racket>
-> ((lambda (x) (equal? (read) (list x (list 'quote x))))
'(lambda (x) (equal? (read) (list x (list 'quote x)))))
Line 291 ⟶ 516:
'(lambda (x) (equal? (read) (list x (list 'quote x)))))
#t
</syntaxhighlight>
</lang>
 
=={{header|Raku}}==
(formerly Perl 6)
 
For the narcissist to work you must be very careful with whitespace. The following version works if it is given to standard input as exactly one line terminated by a newline character.
 
Note how the code takes advantage of Raku's ability to nest quoting delimiters.
 
<syntaxhighlight lang="raku" line>EVAL my $self = q{say slurp() eq q[EVAL my $self = q{]~$self~q[}]~10.chr ?? q{Beautiful!} !! q{Not my type.}}</syntaxhighlight>
 
{{out}}
<pre>$ narcissist='EVAL my $self = q{say slurp() eq q[EVAL my $self = q{]~$self~q[}]~10.chr ?? q{Beautiful!} !! q{Not my type.}}'
$ raku -e "$narcissist" <<<"$narcissist"
Beautiful!
$ raku -e "$narcissist" <<<"$narcissist # a comment ruining it all"
Not my type.
</pre>
 
=={{header|REXX}}==
===version 1===
(returns &nbsp; '''1''' &nbsp; or &nbsp; '''0''')
<syntaxhighlight lang ="rexx">/*REXX*/ say arg(1)=sourceline(1)</langsyntaxhighlight>
 
===version 2===
(returns &nbsp; '''accept''' &nbsp; or &nbsp; '''reject''')
<langsyntaxhighlight lang="rexx">/*REXX*/ say word('reject accept',1+(arg(1)=sourceline(1)))</langsyntaxhighlight>
 
≪ ‘NAR6’ RCL == ≫
‘NAR6’ STO
{{in}}
<pre>
≪ ‘NAR6’ RCL == ≫ NAR6
</pre>
{{out}}
<pre>
1: 1
</pre>
=={{header|RPL}}==
« LASTARG RCL →STR == » '<span style="color:blue">NARCISSIST</span>' STO
 
"« LASTARG RCL →STR == »" '<span style="color:blue">NARCISSIST</span>' EVAL <span style="color:grey">@ returns 1</span>
"string" '<span style="color:blue">NARCISSIST</span>' EVAL <span style="color:grey">@ returns 0</span>
=={{header|Ruby}}==
Translation of the C version.
<langsyntaxhighlight lang="ruby">s = "s = %s%s%s; puts(gets.chomp == (s %% [34.chr, s, 34.chr]) ? 'accept' : 'reject')"; puts(gets.chomp == (s % [34.chr, s, 34.chr]) ? 'accept' : 'reject')</langsyntaxhighlight>
Output:
<pre>$ ruby narcissist.rb < narcissist.rb
accept</pre>
 
=={{header|Rust}}==
<syntaxhighlight lang="rust">use std::io::{stdin, prelude::*};
fn main() {
let src = include_str!("main.rs");
let mut input = String::new();
stdin()
.lock()
.read_to_string(&mut input)
.expect("Could not read from STDIN");
println!("{}", src == input);
}</syntaxhighlight>
 
=={{header|Scala}}==
<syntaxhighlight lang="scala">import scala.io.StdIn
 
object Narcissist extends App {
val text = scala.io.Source.fromFile("Narcissist.scala", "UTF-8").toStream
println("Enter the number of lines to be input followed by those lines:\n")
val n = StdIn.readInt()
val lines = Stream {
StdIn.readLine()
}
if (lines.mkString("\r\n") == text) println("\naccept") else println("\nreject")
}</syntaxhighlight>
 
=={{header|Sidef}}==
<langsyntaxhighlight lang="ruby">say (File.new(__FILE__).open_r.slurp == ARGF.slurp);</langsyntaxhighlight>
 
=={{header|Swift}}==
 
<syntaxhighlight lang="swift">#! /usr/bin/swift
import Foundation
 
let script = CommandLine.arguments[0]
print(script)
let mytext = try? String.init(contentsOfFile: script, encoding: .utf8)
 
var enteredtext = readLine()
if mytext == enteredtext {
print("Accept")
} else {
print("Reject")
}</syntaxhighlight>
 
=={{header|Tcl}}==
With the use of explicit reflexive introspection:
<langsyntaxhighlight lang="tcl">apply {{} {puts [expr {[gets stdin] eq [info level 0]}]}}</langsyntaxhighlight>
Without such commands, using pure generation of strings and lists:
<langsyntaxhighlight lang="tcl">apply {s {puts [expr {[gets stdin]eq[list {*}$s $s]}]}} {apply {s {puts [expr {[gets stdin]eq[list {*}$s $s]}]}}}</langsyntaxhighlight>
 
=={{header|TXR}}==
{{Uses from|GNU coreutils|base64 utility}}
{{Uses from|GNU coreutils|sed utility}}
 
<syntaxhighlight lang="txr">@(bind my64 "QChuZXh0IDphcmdzKUBmaWxlbmFtZUAobmV4dCBmaWxlbmFtZSlAZmlyc3RsaW5lQChmcmVlZm9ybSAiIilAcmVzdEAoYmluZCBpbjY0IEAoYmFzZTY0LWVuY29kZSByZXN0KSlAKGNhc2VzKUAgIChiaW5kIGZpcnN0bGluZSBgXEAoYmluZCBteTY0ICJAbXk2NCIpYClAICAoYmluZCBpbjY0IG15NjQpQCAgKGJpbmQgcmVzdWx0ICIxIilAKG9yKUAgIChiaW5kIHJlc3VsdCAiMCIpQChlbmQpQChvdXRwdXQpQHJlc3VsdEAoZW5kKQ==")
<lang txr>@(bind my64 "QChuZXh0IDphcmdzKQpAZmlsZW5hbWUKQChuZXh0IGAhc2VkIC1uIC1lICcyLCRwJyBAZmlsZW5hbWUgfCBiYXNlNjRgKQpAKGZyZWVmb3JtICIiKQpAaW42NApAKG5leHQgYEBmaWxlbmFtZWApCkBmaXJzdGxpbmUKQChjYXNlcykKQCAgKGJpbmQgZmlyc3RsaW5lIGBAQChiaW5kIG15NjQgIkBteTY0IilgKQpAICAoYmluZCBpbjY0IG15NjQpCkAgIChiaW5kIHJlc3VsdCAiMSIpCkAob3IpCkAgIChiaW5kIHJlc3VsdCAiMCIpCkAoZW5kKQpAKG91dHB1dCkKQHJlc3VsdApAKGVuZCkK")
@(next :args)
@filename
@(next `!sed -n -e '2,$p' @filename | base64`)
@(freeform "")
@in64
@(next `@filename`)
@firstline
@(freeform "")
@rest
@(bind in64 @(base64-encode rest))
@(cases)
@ (bind firstline `@\@(bind my64 "@my64")`)
@ (bind in64 my64)
@ (bind result "1")
Line 339 ⟶ 635:
@(output)
@result
@(end)</lang>
</syntaxhighlight>
 
{{out}}
 
How to run, showing self-acceptance:
<pre>$ txr narcissist.txr narcissist.txr
1</pre>
 
=={{header|UNIX Shell}}==
Informal proof.
<syntaxhighlight lang="bash">cmp "$0" >/dev/null && echo accept || echo reject</syntaxhighlight>
 
=={{header|VBA}}==
We consider what happens if we make an alteration to the code and feed it to the original.
Based on the quine
<syntaxhighlight lang="vb">Public Sub narcissist()
quote = Chr(34)
comma = Chr(44)
cont = Chr(32) & Chr(95)
rparen = Chr(41)
n = Array( _
"Public Sub narcissist()", _
" quote = Chr(34)", _
" comma = Chr(44)", _
" cont = Chr(32) & Chr(95)", _
" rparen = Chr(41)", _
" n = Array( _", _
"How many lines?", _
"Line ", _
" x = InputBox(n(5))", _
" flag = True", _
" For i = 0 To 5", _
" If InputBox(n(6) & i) <> n(i) Then flag = False", _
" Next i", _
" For i = 0 To 20", _
" If InputBox(n(6) & i + 6) <> quote & n(i) & quote & comma & cont Then flag = False", _
" Next i", _
" If InputBox(n(6) & 27) <> quote & n(21) & quote & rparen Then flag = False", _
" For i = 7 To 21", _
" If InputBox(n(6) & i + 21) <> n(i) Then flag = False", _
" Next i", _
" Debug.Print IIf(flag, 1, 0)", _
"End Sub")
x = InputBox(n(5))
flag = True
For i = 0 To 5
If InputBox(n(6) & i) <> n(i) Then flag = False
Next i
For i = 0 To 20
If InputBox(n(6) & i + 6) <> quote & n(i) & quote & comma & cont Then flag = False
Next i
If InputBox(n(6) & 27) <> quote & n(21) & quote & rparen Then flag = False
For i = 7 To 21
If InputBox(n(6) & i + 21) <> n(i) Then flag = False
Next i
Debug.Print IIf(flag, 1, 0)
End Sub</syntaxhighlight>
 
=={{header|Wren}}==
Changing any character of <code>narcissist.txr</code> can be divided into two cases.
<syntaxhighlight lang="wren">import "os" for Process, Platform
import "io" for File, Stdin, Stdout
 
var args = Process.allArguments
* Case 1: modification is done to line 1. This difference be caught by the <code>@(bind firstline ...)</code> directive later down in the query, causing a matching failure. The first line is verified to have exactly the form that it does, with the given base 64 string embedded.
var text = File.read(args[1]).trim()
System.print("Enter the number of lines to be input followed by those lines:\n")
Stdout.flush()
var n = Num.fromString(Stdin.readLine())
var lines = List.filled(n, null)
for (i in 0...n) lines[i] = Stdin.readLine()
var joiner = Platform.isWindows ? "\r\n" : "\n"
var text2 = lines.join(joiner)
System.print()
if (text2 == text) {
System.print("accept")
} else if (text.startsWith(text2)) {
System.print("not yet finished")
} else {
System.print("reject")
}</syntaxhighlight>
 
{{out}}
* Case 2: modification is done in some other line. This difference will be caught by <code>@(bind in64 my64)</code> because a modification to the data after the first line changes the base 64 string that is computed from that data, making <code>in64</code> not equivalent to <code>my64</code>, leading to a match failure.
Sample session:
<pre>
Enter the number of lines to be input followed by those lines:
 
2
These cases are an exhaustive partitioning of the possibilities; there are no ways to modify the data which do not land into one of these cases.
import "os" for Process, Platform
import "io" for File, Stdin, Stdout
 
not yet finished
Nothing in the query calls for any iteration or recursion. Termination depends on the base64 and sed utilities munching through the input, which presumably process an input of size N in O(N) steps. On that note, we could limit how many lines of the input are passed to base64 by using <code>sed -n -e '2,20p'</code>.
</pre>
 
=={{header|zkl}}==
<syntaxhighlight lang="zkl">stdin:=File.stdin.read();
thisFileSrc:=File(System.argv[1]).read();
println((stdin==thisFileSrc) and "input matches "+System.argv[1] or "No match");</syntaxhighlight>
Since zkl is [usually] compile-when-run, we just compare the contents of source file to stdin.
{{out}}
<pre>
$ zkl narcissist.zkl <narcissist.zkl
input matches narcissist.zkl
$ zkl narcissist.zkl <narcissist3.zkl
No match
</pre>
 
{{omit from|bc|Cannot read a file.}}
Petelomax
7,794

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/157316...350313"