Długość łańcucha przy użyciu teorii mnogości

20

Z Wikipedii Zestaw teoretycznej definicji liczb naturalnych

Zbiór N liczb naturalnych jest zdefiniowany jako najmniejszy zbiór zawierający 0 i zamknięty pod funkcją następczą S zdefiniowaną przez S (n) = n ∪ {n}.

Pierwsze kilka liczb zdefiniowanych w ten sposób to 0 = {}, 1 = {0} = {{}}, 2 = {0,1} = {{}, {{}}}, 3 = {0,1,2 } = {{}, {{}}, {{}, {{}}}}.

Korzystając z tej definicji liczb naturalnych, policz długość łańcucha.

Wprowadź ciąg znaków od a-zA-Z o dowolnej długości

Wyprowadza długość łańcucha w ustawionej notacji bez separatorów

Przykłady

Wpisz pusty ciąg

Wyjście {}

Wprowadź a

Dane wyjściowe {{}}

Wpisz aaaa

Wyjście {{} {{}} {{} {{}}} {{} {{}} {{} {{}}}}}

Dla czytelności wyjście dla „aaaa” z separatorami wynosi

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

Warunki

  1. W kodzie nie ma cyfr od 0 do 9;
  2. Bez użycia konwersji kodu znaków do generowania liczb;
  3. Bez użycia + - * / do obliczeń arytmetycznych, w tym zwiększania i zmniejszania;
  4. Żadnych operacji matematycznych innych niż logika logiczna;
  5. Łańcuch wejściowy nie liczy się przy określaniu długości bajtu;

Zwycięzca Najkrótsza długość kodu w bajtach.

Ponieważ jest to moje pierwsze pytanie, mam nadzieję, że wyjaśniłem je wystarczająco rygorystycznie. Przyjmujemy przyjazną radę.

code-golf  math  restricted-source  arithmetic  set-theory 
— jing3142
źródło
Hm, czy możesz zaimplementować definicję rekurencyjną bez wywoływania f(n-1)?
— Martin Ender
1
Mam rozwiązanie (nieoptymalne pod względem długości bajtów), które nie korzysta z rekurencji. Jeśli A jest tablicą, to A.pop (); f (A) jest rekurencyjne.
— jing3142
Trafne spostrzeżenie.
— Martin Ender
1
@ jing3142 Kudos za samodzielne wdrożenie rozwiązania, aby upewnić się, że jest to możliwe. +1 za świetne pytanie.
— Kyle Strand
Co oznacza ograniczenie do a-zA-Z? Czy powinniśmy wykryć białe znaki / rubish? czy powinniśmy się tego spodziewać i podać długość ciągu, względy na treść?
— VX

Odpowiedzi:

7

GolfScript ( 18 17 bajtów)

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

Pobiera dane wejściowe na stosie (więc jeśli jest uruchamiany jako program, przez stdin). Pozostawia wyjście jako dwa ciągi na stosie (więc jeśli uruchomione jako program, poprawne wyjście zostanie wysłane do standardowego wyjścia).

Aby zostawić pojedynczy ciąg na stosie, dołącz +do konkat lub użyj alternatywy

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

Sekcja

# 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
'}'

Alternatywny:

# 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>
    ++
}/

Wpływ ograniczeń

Gdyby dopuszczono zmniejszenie, pozwoliłoby to na rozwiązanie 15-bajtowe

'{}'\{;..,(/*}/
— Peter Taylor
źródło
12

Funkcja Haskella, 35 34 znaki

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

Program Haskell z zakodowanym wejściem, 48 lub 49 47 lub 48 znaków

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

(47 znaków, jeśli nie masz nic przeciwko dodatkowym cudzysłowom wokół wyjścia; jeśli tak, użyj putStrzamiast zamiast print48 znaków)

Program Haskell, 51 50 znaków

f[]="{}";f(_:x)='{':f x++tail(f x);main=interact f
— John Dvorak
źródło
Jeśli możesz cofnąć kolejność, ponieważ jest to zestaw, możesz użyć: f [] = "{}"; f (_: x) = '{': f x ++ (tail.f) x, aby zapisać postać.
— isaacg
@isaacg Nice one. OP powinien jednak powiedzieć nam, czy ma coś przeciwko.
— John Dvorak
Ponieważ ustalona kolejność nie ma znaczenia, więc sugestia @isaacg jest dobra
— jing3142
5

Python 3-64

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

Jeśli wstawianie jest dozwolone:

Python 2 - 54

o=['{}']
for a in'whatever':o+=['{'+''.join(o)+'}']
print o.pop()
— isaacg
źródło
Nie jest raw-input () metodą wprowadzania, a nie samym łańcuchem wejściowym. Nie znając zakresu możliwych języków, nie pozwalałem na długość łańcucha, jeśli coś takiego jak w = „aaaaaaaaaaaa” było konieczne w kodzie. Przepraszam, jeśli nie jasne. Zaakceptowano wszelką pomoc w przeformułowaniu pytania.
— jing3142
Widzę. Przepiszę odpowiednio mój kod. Ogólnie jednak myślę, że powinieneś po prostu pominąć tę linię. Zasadniczo każdy język ma system we / wy.
— isaacg
Możesz zapisać symbol, używając o[-1]zamiasto.pop()
— i
1
„W kodzie nie ma cyfr od 0 do 9;”
— isaacg
1
Dziwny zapis znaków dla pierwszego: Zainicjuj o=[], który staje się o=['{}']po jednym kroku, i wydłuż wejściowy o jeden, zastępując go '_'+input(), zmniejszając przestrzeń po in.
— xnor
3

JavaScript 70 (znaki)

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

To był mój wysiłek przed postawieniem pytania. Zakładam, że ktoś z większą wiedzą na temat Javascript niż ja prawdopodobnie jest w stanie go pokonać.

Dziękuję Janowi Dvorakowi i Peterowi Taylorowi za dalsze obniżki

teraz 62

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

a teraz 61

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

Objaśnienie kodu oryginalnego

ustaw s na pusty

ciąg wejściowy na c i podzielony na tablicę

podczas gdy możliwe jest pop () znak z c to zrobić i zresetować s = s {s} jako następca

prąd wyjściowy s, ale musi być otoczony ustawionymi nawiasami.

— jing3142
źródło
Później nie potrzebujesz nawiasów klamrowych while(ratuje jedną postać).
— John Dvorak
1
Istnieje 7-znakowa oszczędność bez wymaganej wiedzy o JS: inicjalizuj s='{'i porzuć obie '{'+. (To wtedy zachowuje się jak moje rozwiązanie GS). Istnieje jeszcze 1-znakowa oszczędność poprzez użycie forzamiast whilei wciągnięcie jednej z dwóch inicjalizacji do inicjalizacji pętli.
— Peter Taylor
@ peter-taylor nie wiem, jak zamierzasz ubiegać się o pętlę. Używałem go tylko do liczenia.
— jing3142
3
for(a;b;c){d}jest bezpośrednio równoważne z a;while(b){d;c}większością języków, które mają oba. Więc chociaż for(;b;)jest identyczny while(b)pod względem efektu i liczby znaków, for(a;b;)oszczędza jeden znak a;while(b)i jest identyczny w działaniu.
— Peter Taylor
@ peter-taylor +1 za bardzo jasne i zwięzłe wyjaśnienie w komentarzu
— jing3142
3

J - 22 20 znaków

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

Jak można to uzyskać:

   #'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
{{{{}}{}}{{}}{}}

Alternatywnie można to napisać '{','{'&(,,~)&'}'@#, co oznacza to samo.

Stosowanie:

   '{','}' '{'&(,,~)~# 'aaaa'
{{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}
   f =: '{','}' '{'&(,,~)~#  NB. can be assigned to a function
   f 'VeryBig'
{{{{{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}{{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}{{{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}{{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}
— algorytmshark
źródło
2

Haskell - 35 znaków

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

Na rozwiązanie ma wpływ Jan Dvorak, ale bez odwrócenia kolejności.

— użytkownik102417
źródło
2

Scala, 64 znaki

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

Zwróć uwagę na podwójną rolę, jaką nawiasy klamrowe i sgrają w tym kodzie.

EDYCJA: usunięto cyfrę

— Karol S.
źródło
W kodzie jest cyfra
— jing3142
@ jing3142 Ups. Nigdy więcej.
— Karol S
2

Python 3 (44)

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

Na każdym kroku sjest ciąg reprezentujący zestaw z ostatecznym }usuniętym. Tworzymy zbiór reprezentujący n+1ze zbioru reprezentującego nza pomocą relacji f (n + 1) = f (n) ∪ {f (n)}. Aby zaimplementować połączenie z ciągami, dołączamy ciąg dla {f (n)}, który jest dokładnie taki, sale ze }zwróconym końcowym , i zaniedbujemy uwzględnienie końcowego }w wyniku. Na koniec dodajemy ostatnią '}'wersję przed drukowaniem.

Jeśli mogę na stałe zakodować ciąg, liczba znaków zmniejsza się do 35 znaków, przełączając się na Python 2, aby zapisać nawiasy w pliku print.

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

Może być sposób na zaoszczędzenie miejsca po printzrobieniu czegoś print'{'+sz odwróceniem s, ale to psuje się z +=dopisywaniem po prawej stronie.

— xnor
źródło
2

gs2, 12 bajtów

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

mnemonika:

"{}"
right-uncons @0 swap + + b5
rot length times
— Lynn
źródło
1

Mathematica, 115 znaków

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

Pełny kod, jak pokazano, ma 121 znaków, ale 6 z nich jest użytych jako ciąg wejściowy ( "test"), który zgodnie z regułami się nie liczy.

Bez wymogu braku ograniczników długość kodu można by dodatkowo zmniejszyć o 24 znaki; bez wyraźnej konwersji na ciąg znaków można usunąć kolejne 9 znaków.

— celtschk
źródło
1
Pomyślałem, że eliminując potrzebę stosowania ograniczników, które zwykle są wymagane w zapisie zestawu, pomogłem zmniejszyć rozmiar kodu. Więc jeśli ich użyjesz, zmniejszysz rozmiar kodu i skorzystaj z nich.
— jing3142
1

Ruby, 27 lat, rodzaj oszustwa

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

Wątpliwe rzeczy:

  1. Wygląda jak [[], [[]], [[], [[]]], [[], [[]], [[], [[]]]]]
  2. Większość metod wprowadzania do ruby ​​będzie zawierać znak nowej linii, który zwiększa liczbę o 1.
— histocrat
źródło
1
Powinno być całkowicie uzasadnione, jeśli inspectmacierz ręcznie i trwynik.
— John Dvorak
1

Pure Bash, 54

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

Wynik:

$ ./strlenset.sh
{}
$ ./strlenset.sh a
{{}}
$ ./strlenset.sh aa
{{} {{}}}
$ ./strlenset.sh aaa
{{} {{}} {{} {{}}}}
$ ./strlenset.sh aaaa
{{} {{}} {{} {{}}} {{} {{}} {{} {{}}}}}
$
— Cyfrowa trauma
źródło
1

Julia 43

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

Konstrukt {z ...} rozwija ciąg z do tablicy. Zwiń pętle na wszystkich elementach tablicy, ignorując zawartość i zamiast tego budując z pustego łańcucha. Funkcja składania jest dostępna w Julii 0.30.

Przykładowe dane wyjściowe

julia> f("")
"{}"
julia> f("aa")
"{{}{{}}}"
julia> f("aaaa")
"{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}"
julia> f("aaaaaa")
"{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}"
— waTeim
źródło
1

Mathematica, 45 57 48 bajtów

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

Rozwiązanie 36 bajtów:

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

Wykorzystuje jednak pewne obliczenia arytmetyczne.

— alephalpha
źródło
0

Delphi XE3 (264)

Ok, nawet się do siebie nie
zbliżam, ale fajnie było to robić :) Prawdopodobnie przesadzając. Sprawdzanie, czy jest lepszy sposób, aby to zrobić.

Grał w golfa

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.

Nie golfił

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.

Wyniki testów

Testowane ciągi o długości 0..10

{}
{{} }
{{} {{}} }
{{} {{}} {{}{{}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}}}} }
— Teun Pronk
źródło
Dzieki za probe. Moim zdaniem rozważałem długość jako operację matematyczną, ponieważ zwraca ona liczbę, podobnie jak użycie pętli „for”, która polega na zliczaniu.
— jing3142
0

Perl 5: 33 znaków

Nie jest do końca jasne, które postacie powinienem liczyć jako część rozwiązania. Prawdopodobnie nie echo ... |część, ponieważ służy ona tylko do wprowadzenia linii do standardowego wejścia. Prawdopodobnie nie jest to nazwa pliku binarnego Perla, ponieważ możesz zmienić nazwę tego, co chcesz.

Policzyłem więc przełączniki wiersza poleceń przekazane do perla, znaki cudzysłowu owinięte wokół kodu Perla i sam kod Perla.

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

Również powiązane .

— Tobyink
źródło
1
Powinieneś liczyć się pljako standard, ale dostajesz -ei cytaty wokół kodu za darmo. Ref
— Peter Taylor
0

Perl 6: 37 znaków

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

lub ze STDIN:

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

{"\{@_.join()\}"}...*tworzy leniwą listę ustawionych form liczb naturalnych i po prostu wybieramy tę, której potrzebujemy get.chars.

Leniwa lista może być łatwiej napisana:

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

Który brzmi dość podobnie do definicji.

— Mouq
źródło
0

Dart: 85 znaków

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

(z dodatkową nową linią dla czytelności).

Wymóg nieużywania „0” naprawdę gryzie, w przeciwnym razie .firstbyłby [0]i (..).isNegativebyłby ..<0.

— lrn
źródło
0

Pyth, 13 bajtów

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

To jest golfowy odpowiednik Pyth'a dla odpowiedzi Python @ xnor. Pamiętaj, że Pyth jest nowszy niż to pytanie, więc ta odpowiedź nie kwalifikuje się do wygrania tego wyzwania.

Demonstracja.

— isaacg
źródło
— Leaky Nun
0

JavaScript, 171 149 147 142 bajtów

(Prawdopodobnie później będzie grał w golfa)

n = prompt (). split (""); for (a = []; n.pop ();) a.push (a.slice ()); alert (JSON.stringify ({a: a}) [ R = „zamień”] (/ [^ \ [\]] / g, "") [R] (/ \ [/ g, "{") [R] (/ \] / g, "}")) ;
— SuperJedi224
źródło
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.