Longest string challenge: Difference between revisions

;Background:

This "longest string challenge" is inspired by a problem that used to be given to students learning Icon. Students were expected to try to solve the problem in Icon and another language with which the student was already familiar. The basic problem is quite simple; the challenge and fun part came through the introduction of restrictions. Experience has shown that the original restrictions required some adjustment to bring out the intent of the challenge and make it suitable for Rosetta Code.

 

 

 

* In general, the restrictions are meant to avoid the explicit use of these features.

* "No arithmetic operations" - Again, at some level something may have to advance through the string. Often there are ways a language can do this implicitly advance a cursor or pointer without explicitly using a +, - , ++, --, add, subtract, etc.

* The datatype restrictions are amongst the most difficult to reinterpret. In the language of the original challenge strings are atomic datatypes and structured datatypes like lists are quite distinct and have many different operations that apply to them. This becomes a bit fuzzier with languages with a different programming paradigm. The intent would be to avoid using an easy structure to accumulate the longest strings and spit them out. There will be some natural reinterpretation here.

At the end of the day for the implementer this should be a bit of fun. As an implementer you represent the expertise in your language, the reader may have no knowledge of your language. For the reader it should give them insight into how people think outside the box in other languages. Comments, especially for non-obvious (to the reader) bits will be extremely helpful. While the implementations may be a bit artificial in the context of this task, the general techniques may be useful elsewhere.

<br><br>

=={{header|Ada}}==

 

In order to comply with the avoidance of greater-than or less-than comparisons and iterations with operators, only Constraint_Error exception handling is used to obtain comparison of less-than, equal-to, or greater-than. With these, only the strings that are longer than previous strings and the succeeding strings, and equal in length to each other are printed. They are printed in reverse order, but this is specifically allowed by the instructions. In order to be clear to the reader, all cases of less-than, equal to, and greater-than are manually iterated through. Since equal-to/not-equal-to testing is allowed, there should be no question that a "case" statement is also allowed.

 

 

procedure Longest_Strings is

end if;

end;

 

The output, given the above example input, is:

So this is the first solution.

 

with Ada.Text_IO, Ada.Characters.Latin_1;

 

end if;

end loop;

 

Output, when run with its own source code as the input:

Here is the second solution. It also makes heavy use of exceptions, but it does not require to compute the difference (which is an arithmetic operation, i.e., a bit of a cheat). Instead, the procedure Funny_Stuff carries some auxiliary strings S, T. If they are unequal and neither is empty, it recursively calls itself with the same strings shortened by 1. At some point of time, either S is empty, or T is empty, or both are empty.

 

with Ada.Text_IO, Ada.Characters.Latin_1;

end if;

end loop;

 

The output, when given its own source code as the input:

 

Warts are that all input strings must be shorter than (bound -1) characters and it is assumed that ABS "1" > ABS "0"; this true for every known implementation of Algol 68.

BEGIN

INT bound = 1000000; CO Arbitrary upper limit on string lengths CO

buffer := buffer[2 : UPB buffer] CO Step over newline CO

OD

{{out}}

<pre>printf "a\nbb\nccc\nddd\nee\nf\nggg\n" | a68g Longest_String.a68

 

Alternative recursive solution - the only standard operators used are string concatenation and array upper bound and SIGN (the signum function). Operators ATLEASTASLONGAS and LONGERTHAN are defined without the use of any comparison or arithmetic operators. The input file is processed recursively so this would run out of stack space for a large input file. Exploits some features of Algol 68 STRING slicing.

# , 0 if its operand is 0 #

# , 1 if its operand is > 0 #

# find the logest lines from standard inoout #

VOID( print longest lines( stand in, read line( stand in ) ) )

 

=={{header|AutoHotkey}}==

If the top line of the output does not contain a character at the position of the last character in this line of the input, then reset the output to be this line *and* set "LongestLength" to be the length of this line.

did I break any rules?

(

a

buffer := A_LoopField "`n", LongestLen := StrLen(A_LoopField)

}

=={{header|AWK}}==

 

BEGIN {

maxlen = 0;

END {

for (k=1; k <= lenList; k++) print List[k];

 

Output:

ddd

ggg</pre>

 

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

Key to this solution are the functions '''FNcmp''', which compares the lengths of two strings without using comparison operators, and '''FNinc''', which increments an integer without using arithmetic operators. It also strictly adheres to the requirement to use only integer and string data types (no arrays or pointers) and avoids the use of LEN.

bufptr% = buffer%

longest$ = " "

DEF FNinc(i%) : REM Returns i%+1

FOR i% = i% TO i% : NEXT

Output:

<pre>

ggg

</pre>

 

=={{header|C}}==

#include <string.h>

printf("%s", buf);

return 0;

ccc

ddd

#include <stdio.h>

#include <stdlib.h>

 

return 0;

 

Here is a more concise variation which exits (with a non-zero return code) if it encounters a buffer overflow:

 

#include <stdlib.h>

#include <string.h>

printf("%s", buf);

exit(0);

 

=={{header|Clojure}}==

{{trans|Python}}

(:gen-class))

 

(println "Input text:")

(println "Output:\n" (process))

{{out}}

<pre>

=={{header|D}}==

{{trans|Python}}

 

/// Return a.length - b.length if positive, 0 otherwise.

 

writeln(lines);

{{out}}

<pre>ccc

ddd

ggg</pre>

 

=={{header|Go}}==

 

import (

}

printLongest("")

Description: It's basically the recursion+exceptions solution used by others, but staying close to the restrictions.

 

</pre>

The above expressions avoid arithmetic, but not all comparisons, because error values are typically tested and branched on. Eliminating all comparisons leaves no boolean values in the program and no way to use if statements, which in Go require a boolean condition. Conditional flow control is implemented with the following device:

// 1. statements executed in either case

// 2. func below is a closure that captures free variables

// 4a. conditional code. executed only if no panic happens

return // 7. function return happens in either case

A complication of course is that sometimes you want to conditionally execute code if the expression panics. Without a boolean value to invert, this case requires introducing an extra layer of func..defer..recover with a different expression contrived that will panic with the opposite effect.

 

=={{header|Groovy}}==

Solution: recursive

def aa = a, bb = b

while (bb && aa) {

}

return finalLongest

 

Test:

bb

ccc

ggg'''))

 

 

Output:

ddd

ccc</pre>

 

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

=== String Scanning / Pattern Matching Solution ===

local b # the current buffer (string)

local l # the last string

write(\L)

 

Sample Output:<pre>ccc

=== Recursive Solution ===

Here is a recursive solution using only single character substring-ing (no string scanning/pattern matching).

longest(".") # needs a single character seed to throw away

end

# Line must be at least as long as Longest

return Longest # feed back longest for length

 

Sample Output:<pre>ggg

=={{header|J}}==

 

compare =. ($:&}.)`((0 1,:_1 0) {~ <@,&isempty)@.(+.&isempty) NB. *@-&#

add =. ,`(,:@[)`] @. (compare {:)

ccc

ddd

 

Description:

=={{header|Java}}==

Translation of Python via D

import java.util.Scanner;

 

return false;

}

 

<pre>ccc

{{works with|Julia|0.6}}

 

end

return false

end

end

end

 

 

{{out}}

ddd

ggg</pre>

=={{header|Kotlin}}==

{{trans|Java}}

 

import java.io.File

// alternatively (but cheating as library functions will use comparisons and lists under the hood)

println(File("lines.txt").readLines().groupBy { it.length }.maxBy { it.key }!!.value.joinToString("\n"))

 

{{out}}

ggg

</pre>

 

=={{header|Lua}}==

 

while true do

s1 = s1:sub(1, -2)

end

 

 

 

Note that the <code>longer</code> function returns <code>true</code> even if both strings have the same length, so the return value can either be <code>true</code> or <code>false</code> and we can avoid using a comparison or equality operator in interpreting this return value.

The <code>longer</code> function also avoids using the length operator (<code>#</code>), because in the comments on the restrictions of this task it is stated that ''"Representing the length of any string as a number should also be avoided."''. Otherwise it could have been written shorter and faster like this:

 

if s1:sub(#s2):find('^$') then

return false

end

end

 

StringReplace[#,

x : "\n" | StartOfString ~~ a : Except["\n"] ... ~~ "\n" ~~

ee

f

{{Out}}

<pre>ccc

=={{header|MATLAB}} / {{header|Octave}}==

 

fid = fopen(file);

maxlen = 0; L = {};

disp(L);

end;

 

Output:

[1,3] = ggg

} </pre>

 

=={{header|OCaml}}==

Without the restrictions, the standard way to solve the task would be to iterate the lines, compare their length, and accumulate the longest lines in a list. Here we bypass the restriction of not using comparison operators (in the function <code>cmp</code>) by taking advantage that characters of strings are indexed from 0 to [length - 1] and trying to access to a character which index is the length of the other string (if it is beyond the end of the string an exception is raised). The other restriction of not using lists is easily bypassed by concatenating the results instead of accumulating it in a list.

 

try Some (input_line ic)

with End_of_file -> None

print_string acc

in

 

=={{header|Pascal}}==

{{works with|Free_Pascal}}

In this version, inc() is used instead of additions. It still has a comparison.

 

var

writeln (lines[position]);

end;

Output:

<pre>% ./LongestStringChallenge_1

{{libheader|SysUtils}}

This version uses range check exceptions for the comparisons of string lengths. The range checks are compiler specific. With FreePascal its requires the use of the type ANSIstring instead of "classic" type string.

 

{$mode ObjFPC}

writeln (lines[position]);

end;

Output:

<pre>% ./LongestStringChallenge_2

 

=={{header|Perl}}==

END{ print $all }

 

substr($_, length($l)) and $all = $l = $_

 

 

 

 

 

 

 

 

 

=={{header|PicoLisp}}==

Not sure if this meets the spirit. I would implement it the same way if there were no "restrictions":

(maxi '((L) (length (car L)))

(by length group

(in NIL

Another solution avoids 'group', and builds an associative buffer of lines instead:

(in NIL

(until (eof)

(conc @ (cons Line))

(push 'Buf (cons Len (cons Line))) ) ) ) )

 

=={{header|Pike}}==

 

<code>return -1;</code> starts the backend, which allows pike to execute the remaining call_outs and exit.

{

string longest = "";

call_out(exit, 0.01, 0);

return -1;

 

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

read: procedure options (main); /* 18 January 2012. */

declare line character (100) varying controlled;

 

end read;

output (the above file plus the following 3 lines):

<pre>

=={{header|PowerShell}}==

{{works with|PowerShell|2}}

# Get-Content strips out any type of line break and creates an array of strings

# We'll join them back together and put a specific type of line break back in

# Output longest strings

$LongestStrings.Split( "`n" )

 

===PowerShell Alternate Version===

The list restrictions should not apply here because this is essentially one line of code using only the input and no variables.

@'

a

Sort-Object -Property Name -Descending |

Select-Object -Property Count, @{Name="Length"; Expression={[int]$_.Name}}, Group -First 1

{{Out}}

<pre>

 

=={{header|PureBasic}}==

 

Procedure.i ConsoleWrite(t.s) ; compile using /CONSOLE option

StdOut(a$)

 

 

;Output:

 

=={{header|Python}}==

 

# This returns True if the second string has a value on the

lines += x

 

 

;Sample runs:

 

</pre>

 

=={{header|Racket}}==

This is an attempt to follow the problem restrictions: use just one list of the complete output (so it's not used as a container of strings), and the work is done by manipulating this list vs the input instead of direct comparisons.

 

#lang racket

 

[(newline? o) (loop O C i:rI rO i:rI)]

[else (loop O (cdr C) i:rI rO i:rC)])))

 

=={{header|REXX}}==

In the REXX language, &nbsp; ''everything'' &nbsp; is a string (characters).

<pre>

ccc

ddd

ggg

</pre>

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

<pre>

</pre>

 

===Dual code (works on TSO and PC)===

* 27.10.2010 Walter Pachl

**********************************************************************/

End

Else

<pre>

Maximum line length=5

 

=={{header|Ring}}==

# Project : Longest string challenge

 

load "stdlib.ring"

test2 = sort(test2)

see test2 + nl

Output:

<pre>

ddd

ggg

</pre>

 

=={{header|Ruby}}==

BEGIN {

v = [ ]

END {

v.each { |s| puts s }

 

Then ''ruby -n longest.rb < file.txt''

This uses a hash with arrays as values - but not explicit.

 

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

Uses in memory database

#mem execute("CREATE TABLE data(str)") ' And fields to hold the string data

 

str$ = #row str$()

print leng;" ";str$ ' print the data

 

Using a simple sort method

 

 

while word$(strings$,numWords + 1," ") <> "" ' Count the words

for i = 1 to numWords

print len(string$(i));" ";string$(i) ' print out the words in length descending sequence

<pre>3 ccc

3 ddd

1 a

1 f</pre>

=={{header|Scala}}==

 

=={{header|Sidef}}==

var a = ''; # Accumulator to save longest strings.

 

}

 

 

=={{header|Tcl}}==

Uses only string comparisons for equality and glob-style matching

 

 

set longest z

}

}

 

Test:

The solution uses the Mid function to compare string lengths.

 

'Read the input file. This assumes that the file is in the same

'directory as the script.

objfile.Close

Set objfso = Nothing

 

{{Out}}

ddd

ggg

</pre>

 

=={{header|XSLT 2.0}}==

This XSLT 2.0 style-sheet...

<xsl:output indent="yes" encoding="UTF-8" omit-xml-declaration="yes" />

<xsl:template match="/*">

return s[string-length(.) eq $l]" /></t>

</xsl:template>

 

...when applied to this input...

<s>a</s>

<s>bb</s>

<s>f</s>

<s>ggg</s>

 

...yields...

<s>ccc</s>

<s>ddd</s>

<s>ggg</s>

 

=={{header|zkl}}==

 

To decide which of two strings is longer, a character is removed from each until one is empty. If one still has text, it is longer.

while(a and b){a=a.del(0); b=b.del(0);}

if (not a and not b) return(0); // a & b same length

} //switch

}

{{out}}

<pre>