Length of String Using Set Theory

Question

From Wikipedia Set-theoretic definition of natural numbers

The set N of natural numbers is defined as the smallest set containing 0 and closed under the successor function S defined by S(n) = n ∪ {n}.

The first few numbers defined this way are 0 = {}, 1 = {0} = {{}}, 2 = {0,1} = {{},{{}}}, 3 = {0,1,2} = {{},{{}},{{},{{}}}}.

Using this definition of natural numbers count the length of a string.

Input a string of characters from a-zA-Z of any length

Output the length of the string in set notation without separators

Examples

Input Empty string

Output {}

Input a

Output {{}}

Input aaaa

Output {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}

For readability output for 'aaaa' with separators is

{ 
    {} 
    {{}} 
    {{} {{}} } 
    {{}   {{}}   {{} {{} } }   }
}

Conditions

No digits 0 to 9 to appear in the code;
No use of character code conversion to generate numbers;
No use of +-*/ for arithmetic calculations including increment and decrement;
No mathematical operations other than Boolean Logic;
Input string does not count in determining byte length;

Winner Shortest code length in bytes.

As this is my first question I hope I have made it clear and rigorous enough. Friendly advice accepted.

Hm, can you implement a recursive definition without calling f(n-1)? — Martin Ender, Apr 10 '14 at 10:27
I have a solution (non-optimal in terms of byte length) that does not use recursion. If A is an array then A.pop();f(A) is recursive. — jing3142, Apr 10 '14 at 10:34
@jing3142 Kudos for implementing a solution yourself to make sure it's possible. +1 for great question. — Kyle Strand, Apr 10 '14 at 18:49
What does the restriction to a-zA-Z mean? Should we detect whitespace/rubish? or should we just expect this and report the length of the string, regardles on the content? — V-X, Apr 11 '14 at 8:44

Peter Taylor · Accepted Answer · 2014-04-10 11:23:05Z

GolfScript (18 17 bytes)

'{'\{;.'}'++}/'}'

Takes input on the stack (so if run as a program, via stdin). Leaves the output as two strings on the stack (so if run as a program, the correct output is sent to stdout).

To leave a single string on the stack, either append + to concat, or use the alternative

'{}'\{;.);\'}'++}/

Dissection

# Stack: input-str
'{'\
# Stack: <0< input-str  where <0< means the string representing 0 without its final }
# Loop over each character of the input string
{
    # Stack: <n< char
    # Discard the input character
    ;
    # Concatenate two copies of <n< and a }
    .'}'++
}/
# Push the final } to the stack
'}'

Alternative:

# Stack: input-str
'{}'\
# Stack: <0> input-str  (where <0> means the string representing 0)
# Loop over each character of the input string
{
    # Stack: <n> char
    # Discard the input character
    ;
    # Duplicate <n> and remove the final '}'
    .);
    # Stack manipulations
    \'}'
    # Stack: <n>-less-final-'}' <n> '}'
    # Concatenate the three strings to get <n+1>
    ++
}/

Impact of the restrictions

If decrement were allowed, it would permit the 15-byte solution

'{}'\{;..,(/*}/

John Dvorak · Accepted Answer · 2014-04-10 12:58:05Z

12

Haskell function, 35 34 characters

f[]="{}";f(_:x)='{':f x++tail(f x)

Haskell program with hardcoded input, 48 or 49 47 or 48 characters

 f[]="{}";f(_:x)='{':f x++tail(f x);main=print$f"aaaa"

(47 characters if you don't mind extra quotes around the output; if you do, use putStr instead of print for a total of 48 characters)

Haskell program, 51 50 characters

f[]="{}";f(_:x)='{':f x++tail(f x);main=interact f

edited Apr 10 '14 at 12:58

answered Apr 10 '14 at 10:55

John Dvorak

9,0993 gold badges27 silver badges51 bronze badges

\$\begingroup\$ If you're OK with reversing the order, since it's a set, you can use: f[]="{}";f(_:x)='{':f x++(tail.f)x to save a character. \$\endgroup\$ – isaacg Apr 10 '14 at 11:12
\$\begingroup\$ @isaacg Nice one. OP should tell us if he minds, though. \$\endgroup\$ – John Dvorak Apr 10 '14 at 12:13
\$\begingroup\$ As its a set order does not matter so @isaacg 's suggestion is good \$\endgroup\$ – jing3142 Apr 10 '14 at 12:40

Add a comment |

isaacg · Accepted Answer · 2014-04-10 10:58:37Z

5

Python 3 - 64

o=['{}']
for a in input():o+=['{'+''.join(o)+'}']
print(o.pop())

If inlining the input is allowed:

Python 2 - 54

o=['{}']
for a in'whatever':o+=['{'+''.join(o)+'}']
print o.pop()

edited Apr 10 '14 at 10:58

answered Apr 10 '14 at 10:44

isaacg

40.7k5 gold badges61 silver badges200 bronze badges

\$\begingroup\$ Isn't raw-input() the method of inputing not the input string itself. Not being familiar with the range of languages possible I was disallowing the string length if something like w='aaaaaaaaaaaa' was necessary within the code. Sorry if not clear. Any help in re-wording question accepted. \$\endgroup\$ – jing3142 Apr 10 '14 at 10:52
\$\begingroup\$ I see. I'll rewrite my code accordingly. In general, however, I think you should just leave that line out. Essentially every language has an I/O system. \$\endgroup\$ – isaacg Apr 10 '14 at 10:55
\$\begingroup\$ You can save a symbol by using o[-1] instead of o.pop() \$\endgroup\$ – aland Apr 11 '14 at 11:06
1

\$\begingroup\$ "No digits 0 to 9 to appear in the code;" \$\endgroup\$ – isaacg Apr 11 '14 at 18:06
1

\$\begingroup\$ A strange character-save for the first one: Initialize o=[], which becomes o=['{}'] after one step, and lengthen the input by one by replacing it with '_'+input(), cutting the space after in. \$\endgroup\$ – xnor Jul 18 '14 at 13:41

Add a comment |

jing3142 · Accepted Answer · 2014-04-10 17:20:10Z

3

Javascript 70 (chars)

s='';c=prompt().split('');while(c.pop()){s+='{'+s+'}'}alert('{'+s+'}')

This was my effort before setting the question. I would assume someone with more knowledge of Javascript than me can probably beat it.

Thank you Jan Dvorak and Peter Taylor for further reductions

now 62

s='{';c=prompt().split('');while(c.pop())s+=s+'}';alert(s+'}')

and now 61

s='{';for(c=prompt().split('');c.pop();)s+=s+'}';alert(s+'}')

Explanation of Original Code

set s to be empty

input string into c and split into an array

while it is possible to pop() a character from c do so and reset s=s{s} as successor

output current s but need to surround with set brackets.

edited Apr 10 '14 at 17:20

answered Apr 10 '14 at 12:28

jing3142

3671 silver badge9 bronze badges

\$\begingroup\$ You don't need braces after while (saves one character). \$\endgroup\$ – John Dvorak Apr 10 '14 at 13:00
1

\$\begingroup\$ There's a 7-char saving without any more knowledge of JS required: initialise s='{' and ditch the two '{'+. (This then behaves like my GS solution). There's a further 1-char saving by using for instead of while and pulling in one of the two initialisations to the for-loop initialisation. \$\endgroup\$ – Peter Taylor Apr 10 '14 at 13:00
\$\begingroup\$ @peter-taylor not sure how you mean to apply for-loop. I have only ever used it for counting. \$\endgroup\$ – jing3142 Apr 10 '14 at 16:00
3

\$\begingroup\$ for(a;b;c){d} is directly equivalent to a;while(b){d;c} in most languages which have both. So while for(;b;) is identical to while(b) in effect and character count, for(a;b;) saves one char over a;while(b) and is identical in effect. \$\endgroup\$ – Peter Taylor Apr 10 '14 at 16:26
\$\begingroup\$ @peter-taylor +1 for very clear and concise explanation within a comment \$\endgroup\$ – jing3142 Apr 10 '14 at 17:21

| Show 1 more comments

algorithmshark · Accepted Answer · 2014-07-18 05:34:11Z

J - 22 20 char

'{','}' '{'&(,,~)~#

How this can be derived:

   #'123'                      NB. string length
3
   'Left' (,,~) 'Right'        NB. dyad to concat L,R,R
LeftRightRight
   '{' (,,~) '}'               NB. using braces
{}}
   '{'&(,,~) '}'               NB. bind left argument, now it's a monad
{}}
   '{'&(,,~) '{'&(,,~) '}'     NB. twice
{{}}{}}
   '{'&(,,~)^:2 '}'            NB. ^: is monad functional power
{{}}{}}
   '{'&(,,~)^:3 '}'            NB. any integer
{{{}}{}}{{}}{}}
   3 '{'&(,,~) '}'             NB. convenient feature of dyadic &
{{{}}{}}{{}}{}}
   '}' '{'&(,,~)~ 3            NB. swap argument order
{{{}}{}}{{}}{}}
   '}' '{'&(,,~)~ #'123'       NB. using string length
{{{}}{}}{{}}{}}
   '{', '}' '{'&(,,~)~ #'123'  NB. add final brace
{{{{}}{}}{{}}{}}
   ('{','}' '{'&(,,~)~#) '123' NB. works as a verb
{{{{}}{}}{{}}{}}

Alternatively, this can be written '{','{'&(,,~)&'}'@#, meaning the same thing.

Usage:

   '{','}' '{'&(,,~)~# 'aaaa'
{{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}
   f =: '{','}' '{'&(,,~)~#  NB. can be assigned to a function
   f 'VeryBig'
{{{{{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}{{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}{{{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}{{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}

user102417 · Accepted Answer · 2014-04-10 17:52:20Z

2

Haskell - 35 charactes

g[]="{}";g(_:x)=(init.g)x++g x++"}"

Solution is influenced by Jan Dvorak's one, but without reversing the order.

edited Apr 10 '14 at 17:52

answered Apr 10 '14 at 17:42

user102417

212 bronze badges

Add a comment |

Community · Accepted Answer · 2020-06-17 09:04:33Z

2

Scala, 64 characters

def f(s:String):String=s"{${s.tails.toSeq.tail.map(f)mkString}}"

Note the dual roles that both the braces and s play in this code.

EDIT: removed a digit

edited Jun 17 '20 at 9:04

Community♦

1

answered Apr 10 '14 at 15:04

Karol S

1613 bronze badges

\$\begingroup\$ There is a digit in the code \$\endgroup\$ – jing3142 Apr 10 '14 at 15:48
\$\begingroup\$ @jing3142 Oops. Not any more. \$\endgroup\$ – Karol S Apr 10 '14 at 18:02

Add a comment |

xnor · Accepted Answer · 2014-07-18 14:28:54Z

Python 3 (44)

s='{'
for _ in input():s+=s+'}'
print(s+'}')

At each step, s is the string representing the set with the final } removed. We create the set representing n+1 from the set representing n via the relationship f(n+1) = f(n) ∪ {f(n)}. To implement the union with strings, we append the string for {f(n)}, which is exactly s but with the final } returned, and neglect to include the final } in the result. Finally, we add back a final '}' before printing.

If I may hardcode the string, the character count cuts down to 35 character, switching to Python 2 to save parantheses on the print.

s='{'
for _ in'string':s+=s+'}'
print s+'}'

There might be a way to save the space after the print by doing something like print'{'+s with a reversed s, but this messes up with the += appending on the right.

Lynn · Accepted Answer · 2015-05-12 15:42:17Z

2

gs2, 12 bytes

7b 7d 05 27 a0 42 30 30 e4 43 2e 32

mnemonics:

"{}"
right-uncons @0 swap + + b5
rot length times

answered May 12 '15 at 15:42

Lynn

59k11 gold badges117 silver badges248 bronze badges

Add a comment |

celtschk · Accepted Answer · 2014-04-10 19:34:49Z

1

Mathematica, 115 characters

StringReplace[ToString@Function[s,NestWhile[#~Append~#&,{},(s~Read~Character//StringQ)&]]@StringToStream@"test",", "->""]

The complete code as shown has 121 characters, but 6 of them are used for the input string ("test") which, according to the rules, doesn't count.

Without the requirement that there are no delimiters, the code length could be reduced further by 24 characters; without explicit conversion to string then another 9 characters could be removed.

answered Apr 10 '14 at 19:34

celtschk

4,6602 gold badges20 silver badges21 bronze badges

1

\$\begingroup\$ I thought that removing the need for deliminators, which are usually are required in set notation, I was helping to reduce code size. So if using them reduces your code size go ahead and use them. \$\endgroup\$ – jing3142 Apr 11 '14 at 7:45

Add a comment |

histocrat · Accepted Answer · 2014-04-10 21:46:56Z

1

Ruby, 27, kind of cheating

a=*a
gets.chars{a=*a,a}
p a

Questionable things:

Output looks like [[], [[]], [[], [[]]], [[], [[]], [[], [[]]]]]
Most methods of input to ruby will include a trailing newline, which inflates the count by 1.

edited Apr 10 '14 at 21:46

answered Apr 10 '14 at 21:15

histocrat

21.4k4 gold badges34 silver badges78 bronze badges

1

\$\begingroup\$ It should be perfectly legit if you inspect the array manually and tr the result. \$\endgroup\$ – John Dvorak Apr 15 '14 at 18:08

Add a comment |

Community · Accepted Answer · 2020-06-17 09:04:33Z

1

Pure Bash, 54

f()([ $@ ]&&(a=`f ${@%?}`
echo $a{$a}))
echo {`f $@`}

Output:

$ ./strlenset.sh
{}
$ ./strlenset.sh a
{{}}
$ ./strlenset.sh aa
{{}{{}}}
$ ./strlenset.sh aaa
{{}{{}}{{}{{}}}}
$ ./strlenset.sh aaaa
{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}
$

edited Jun 17 '20 at 9:04

Community♦

1

answered Apr 11 '14 at 3:36

Digital Trauma

67.1k8 gold badges99 silver badges240 bronze badges

Add a comment |

Community · Accepted Answer · 2020-06-17 09:04:33Z

Julia 43

f(z)="{"foldl((x,y)->"$x{$x}","",{z...})"}"

The construct {z...} expands the string z into an array. Fold loops over all elements of the array ignoring the contents and instead building up from the empty string. The function foldl is available in Julia 0.30.

Sample Output

julia> f("")
"{}"
julia> f("aa")
"{{}{{}}}"
julia> f("aaaa")
"{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}"
julia> f("aaaaaa")
"{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}"

Community · Accepted Answer · 2020-06-17 09:04:33Z

1

Haskell, 31 bytes

foldl(\s _->init s++s++"}")"{}"

edited Jun 17 '20 at 9:04

Community♦

1

answered May 12 '15 at 13:45

alephalpha

24.4k5 gold badges38 silver badges101 bronze badges

Add a comment |

Community · Accepted Answer · 2020-06-17 09:04:33Z

1

Mathematica, 45 57 48 bytes

"{"~~Fold[#~~"{"~~#~~"}"&,"",Characters@#]~~"}"&

A 36 bytes solution:

Fold[{##{##}}&@@#&,{},Characters@#]&

However, it uses some arithmetic calculations.

edited Jun 17 '20 at 9:04

Community♦

1

answered Apr 11 '14 at 15:00

alephalpha

24.4k5 gold badges38 silver badges101 bronze badges

Add a comment |

Teun Pronk · Accepted Answer · 2014-04-10 11:15:22Z

Delphi XE3 (264)

Ok I dont even come close to the other but it was fun to do :)
Probably overthinking it. Going to see if there is a better way to do this.

Golfed

uses System.SysUtils;var s,f:string;a:TArray<char>;b:TArray<string>;i,x:integer;begin readln(s);a:=s.ToCharArray;f:='{';setlength(b,Length(a));for I:=Low(a)to High(a) do begin s:='{';for x:=Low(b)to High(b)do s:=s+b[x];b[i]:=s+'}';f:=f+b[i];end;writeln(f+'}');end.

Ungolfed

uses
  System.SysUtils;
var
  s,f:string;
  a:TArray<char>;
  b:TArray<string>;
  i,x:integer;
begin
    readln(s);
    a:=s.ToCharArray;
    f:='{';
    setlength(b,Length(a));
    for I:=Low(a)to High(a) do
    begin
      s:='{';
      for x:=Low(b)to High(b)do
        s:=s+b[x];
      b[i]:=s+'}';
      f:=f+b[i];
    end;
    writeln(f+'}');
end.

Testing results

Tested strings with length 0..10

{}
{{} }
{{} {{}} }
{{} {{}} {{}{{}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}}}} }

Thanks for trying. In my mind I was considering length as a mathematical operation as it returns a number and as is the use of a 'for' loop which involves counting. — jing3142, Apr 10 '14 at 12:37

tobyink · Accepted Answer · 2014-04-10 16:51:23Z

Perl 5: 33 characters

It's not quite clear which characters I should count as part of the solution. Probably not the echo ... | part because that's just used to feed a line in to stdin. Probably not the name of the perl binary, because you could rename that whatever you wanted.

~~So I've counted the command-line switches passed to perl, the quote marks wrapped around the Perl code, and the Perl code itself.~~

#                                1         2         3
#                     12  3456789012345678901234567890123
$ echo "aaaa" | perl -ple'$s.="{$s}"while s/.//;$_="{$s}"'

Also, related.

You should count pl as astandard, but you get -e and the quotes around the code for free. Ref — Peter Taylor, Apr 10 '14 at 14:53

Mouq · Accepted Answer · 2014-04-11 00:52:48Z

Perl 6: 37 characters

say ({"\{@_.join()\}"}...*)["(input string)".chars]

or from STDIN:

say ({"\{@_.join()\}"}...*)[get.chars]

{"\{@_.join()\}"}...* makes a lazy list of the set forms of the natural numbers, and we just grab the one we need with get.chars.

The lazy list might be more readably written:

-> *@prev { '{'~ @prev.join ~'}' } ... *

Which reads pretty similarly to the definition.

lrn · Accepted Answer · 2014-08-05 09:15:55Z

0

Dart: 85 characters

a(p,i)=>(--i).isNegative?p:a("$p{$p}",i);
main(s){print("{${a("",s.first.length)}}");}

(with extra newline for readability).

The requirement of not using "0" really bites, otherwise .first would be [0] and (..).isNegative would be ..<0.

answered Aug 5 '14 at 9:15

lrn

5213 silver badges7 bronze badges

Add a comment |

isaacg · Accepted Answer · 2015-05-11 12:43:28Z

0

Pyth, 13 bytes

+u++GG\}z\{\}

This is the golfed Pyth equivalent of @xnor's Python answer. Note that Pyth is newer than this question, so this answer is not eligible to win this challenge.

Demonstration.

answered May 11 '15 at 12:43

isaacg

40.7k5 gold badges61 silver badges200 bronze badges

\$\begingroup\$ u+G]GlQY \$\endgroup\$ – Leaky Nun Jun 26 '16 at 3:08

Add a comment |

SuperJedi224 · Accepted Answer · 2015-05-18 16:57:21Z

0

Javascript, 171 149 147 142 bytes

(Will likely be golfed further later)

n=prompt().split("");for(a=[];n.pop();)a.push(a.slice());alert(JSON.stringify({a:a})[R="replace"](/[^\[\]]/g,"")[R](/\[/g,"{")[R](/\]/g,"}"));

edited May 18 '15 at 16:57

answered May 6 '15 at 18:55

SuperJedi224

11.5k1 gold badge37 silver badges65 bronze badges

Add a comment |

Stack Exchange Network

current community

your communities

more stack exchange communities

Length of String Using Set Theory

21 Answers 21

GolfScript (18 17 bytes)

Dissection

Impact of the restrictions

Haskell function, 35 34 characters

Haskell program with hardcoded input, 48 or 49 47 or 48 characters

Haskell program, 51 50 characters

Python 3 - 64

Python 2 - 54

Javascript 70 (chars)

now 62

and now 61

J - 22 20 char

Scala, 64 characters

Python 3 (44)

gs2, 12 bytes

Mathematica, 115 characters

Ruby, 27, kind of cheating

Pure Bash, 54

Julia 43

Haskell, 31 bytes

Mathematica, 45 57 48 bytes

Delphi XE3 (264)

Golfed

Ungolfed

Testing results

Perl 6: 37 characters

Dart: 85 characters

Pyth, 13 bytes

Javascript, 171 149 147 142 bytes

Your Answer

Not the answer you're looking for? Browse other questions tagged code-golf math restricted-source arithmetic set-theory or ask your own question.

Linked

Hot Network Questions

Length of String Using Set Theory

21 Answers 21

GolfScript (18 17 bytes)

Dissection

Impact of the restrictions

Haskell function, 35 34 characters

Haskell program with hardcoded input, 48 or 49 47 or 48 characters

Haskell program, 51 50 characters

Python 3 - 64

Python 2 - 54

Javascript 70 (chars)

now 62

and now 61

J - 22 20 char

Scala, 64 characters

Python 3 (44)

gs2, 12 bytes

Mathematica, 115 characters

Ruby, 27, kind of cheating

Pure Bash, 54

Julia 43

Haskell, 31 bytes

Mathematica, 45 57 48 bytes

Delphi XE3 (264)

Golfed

Ungolfed

Testing results

Perl 6: 37 characters

Dart: 85 characters

Pyth, 13 bytes

Javascript, 171 149 147 142 bytes

Your Answer

Sign up or log in

Post as a guest

Not the answer you're looking for? Browse other questions tagged code-golf math restricted-source arithmetic set-theory or ask your own question.

Linked

Related

Hot Network Questions