Longueur de chaîne utilisant la théorie des ensembles

20

De Wikipédia Définition théorique des nombres naturels

L'ensemble N de nombres naturels est défini comme le plus petit ensemble contenant 0 et fermé sous la fonction successeur S définie par S (n) = n ∪ {n}.

Les premiers nombres définis de cette façon sont 0 = {}, 1 = {0} = {{}}, 2 = {0,1} = {{}, {{}}}, 3 = {0,1,2 } = {{}, {{}}, {{}, {{}}}}.

En utilisant cette définition des nombres naturels, comptez la longueur d'une chaîne.

Entrez une chaîne de caractères de a-zA-Z de n'importe quelle longueur

Afficher la longueur de la chaîne en notation définie sans séparateurs

Exemples

Entrée chaîne vide

Sortie {}

Entrez un

Sortie {{}}

Entrée aaaa

Sortie {{} {{}} {{} {{}}} {{} {{}} {{} {{}}}}}

Pour la lisibilité, la sortie pour 'aaaa' avec séparateurs est

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

Conditions

  1. Pas de chiffres de 0 à 9 pour apparaître dans le code;
  2. Pas d'utilisation de conversion de code de caractères pour générer des nombres;
  3. Pas d'utilisation de + - * / pour les calculs arithmétiques incluant l'incrémentation et la décrémentation;
  4. Aucune opération mathématique autre que la logique booléenne;
  5. La chaîne d'entrée ne compte pas pour déterminer la longueur d'octet;

Gagnant Longueur de code la plus courte en octets.

Comme il s'agit de ma première question, j'espère l'avoir suffisamment claire et rigoureuse. Conseils amicaux acceptés.

code-golf  math  restricted-source  arithmetic  set-theory 
— jing3142
source
Hm, pouvez-vous implémenter une définition récursive sans appeler f(n-1)?
— Martin Ender
1
J'ai une solution (non optimale en termes de longueur d'octet) qui n'utilise pas la récursivité. Si A est un tableau, alors A.pop (); f (A) est récursif.
— jing3142
C'est un bon point.
— Martin Ender
1
@ jing3142 Félicitations pour avoir implémenté une solution vous-même pour vous assurer qu'elle est possible. +1 pour une grande question.
— Kyle Strand
Que signifie la restriction à a-zA-Z? Faut-il détecter les espaces / rubis? ou devrions-nous simplement nous attendre à cela et signaler la longueur de la chaîne, le regard sur le contenu?
— VX

Réponses:

7

GolfScript ( 18 17 octets)

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

Prend des entrées sur la pile (donc si exécuté en tant que programme, via stdin). Laisse la sortie sous forme de deux chaînes sur la pile (donc si elle est exécutée en tant que programme, la sortie correcte est envoyée à stdout).

Pour laisser une seule chaîne sur la pile, ajoutez +à concaténer ou utilisez l'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 des restrictions

Si la décrémentation était autorisée, cela permettrait la solution à 15 octets

'{}'\{;..,(/*}/
— Peter Taylor
source
12

Fonction Haskell, 35 34 caractères

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

Programme Haskell avec entrée codée en dur, 48 ou 49 47 ou 48 caractères

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

(47 caractères si cela ne vous dérange pas de guillemets supplémentaires autour de la sortie; si vous le faites, utilisez putStrau lieu de printpour un total de 48 caractères)

Programme Haskell, 51 50 caractères

f[]="{}";f(_:x)='{':f x++tail(f x);main=interact f
— John Dvorak
source
Si vous êtes d'accord pour inverser l'ordre, puisqu'il s'agit d'un ensemble, vous pouvez utiliser: f [] = "{}"; f (_: x) = '{': f x ++ (tail.f) x pour enregistrer un personnage.
— isaacg
@isaacg Nice one. OP devrait nous dire s'il le veut bien.
— John Dvorak
Comme son ordre fixe n'a pas d'importance, la suggestion de
— @isaacg
5

Python 3-64

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

Si l'inlining est autorisé:

Python 2 - 54

o=['{}']
for a in'whatever':o+=['{'+''.join(o)+'}']
print o.pop()
— isaacg
source
N'est-ce pas raw-input () la méthode d'entrée pas la chaîne d'entrée elle-même. Ne connaissant pas la gamme de langues possible, je refusais la longueur de chaîne si quelque chose comme w = 'aaaaaaaaaaaa' était nécessaire dans le code. Désolé si ce n'est pas clair. Toute aide pour reformuler la question est acceptée.
— jing3142
Je vois. Je vais réécrire mon code en conséquence. En général, cependant, je pense que vous devriez simplement laisser cette ligne de côté. Essentiellement, chaque langue possède un système d'E / S.
— isaacg
Vous pouvez enregistrer un symbole en utilisant o[-1]au lieu deo.pop()
— aland
1
"Aucun chiffre de 0 à 9 n'apparaît dans le code;"
— isaacg
1
Une étrange sauvegarde de caractère pour la première: initialiser o=[], qui devient o=['{}']après une étape, et allonger l'entrée d'une unité en la remplaçant par '_'+input(), en coupant l'espace après in.
— xnor
3

Javascript 70 (caractères)

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

C'était mon effort avant de poser la question. Je suppose que quelqu'un avec plus de connaissances sur Javascript que moi peut probablement le battre.

Merci Jan Dvorak et Peter Taylor pour de nouvelles réductions

maintenant 62

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

et maintenant 61

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

Explication du code d'origine

définir s pour être vide

chaîne d'entrée en c et divisée en un tableau

alors qu'il est possible de pop () un caractère de c faire ainsi et réinitialiser s = s {s} comme successeur

courant de sortie s mais doivent être entourés de supports définis.

— jing3142
source
Vous n'avez pas besoin d'accolades après while(enregistre un caractère).
— John Dvorak du
1
Il y a une économie de 7 caractères sans plus de connaissance de JS requise: initialisez s='{'et abandonnez les deux '{'+. (Cela se comporte alors comme ma solution GS). Il y a une autre économie de 1 caractère en utilisant forau lieu de whileet en tirant l'une des deux initialisations vers l'initialisation pour la boucle.
— Peter Taylor du
@ peter-taylor ne sait pas comment vous comptez appliquer for-loop. Je ne l'ai jamais utilisé que pour compter.
— jing3142
3
for(a;b;c){d}est directement équivalent à a;while(b){d;c}dans la plupart des langues qui ont les deux. Ainsi, tandis que for(;b;)est identique à l' while(b)effet et au nombre de caractères, for(a;b;)enregistre un caractère a;while(b)et est identique en effet.
— Peter Taylor
@ peter-taylor +1 pour une explication très claire et concise dans un commentaire
— jing3142
3

J - 22 20 caractères

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

Comment cela peut être dérivé:

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

Alternativement, cela peut être écrit '{','{'&(,,~)&'}'@#, ce qui signifie la même chose.

Usage:

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

Haskell - 35 caractères

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

La solution est influencée par celle de Jan Dvorak, mais sans inverser l'ordre.

— user102417
source
2

Scala, 64 caractères

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

Notez les rôles doubles que les accolades et sjouent dans ce code.

EDIT: a supprimé un chiffre

— Karol S
source
Il y a un chiffre dans le code
— jing3142
@ jing3142 Oups. Plus maintenant.
— Karol S
2

Python 3 (44)

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

À chaque étape, sla chaîne représentant l'ensemble avec la finale }supprimée. Nous créons l'ensemble représentant à n+1partir de l'ensemble représentant nvia la relation f (n + 1) = f (n) ∪ {f (n)}. Pour implémenter l'union avec des chaînes, nous ajoutons la chaîne pour {f (n)}, qui est exactement smais avec la finale }retournée, et négligeons d'inclure la finale }dans le résultat. Enfin, nous ajoutons une finale '}'avant l'impression.

Si je peux coder en dur la chaîne, le nombre de caractères est réduit à 35 caractères, en passant à Python 2 pour enregistrer des paranthèses sur le print.

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

Il pourrait y avoir un moyen d'économiser l'espace après le printen faisant quelque chose comme print'{'+savec un inversé s, mais cela gâche avec l' +=annexe à droite.

— xnor
source
2

gs2, 12 octets

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

mnémotechnique:

"{}"
right-uncons @0 swap + + b5
rot length times
— Lynn
source
1

Mathematica, 115 caractères

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

Le code complet, comme indiqué, contient 121 caractères, mais 6 d'entre eux sont utilisés pour la chaîne d'entrée ( "test") qui, selon les règles, ne compte pas.

Sans l'exigence de l'absence de délimiteurs, la longueur du code pourrait être encore réduite de 24 caractères; sans conversion explicite en chaîne, 9 autres caractères pourraient être supprimés.

— celtschk
source
1
Je pensais qu'en supprimant le besoin de suppresseurs, qui sont généralement requis dans la notation d'ensemble, j'aidais à réduire la taille du code. Donc, si les utiliser réduit la taille de votre code, utilisez-les.
— jing3142
1

Ruby, 27 ans, sorte de tricherie

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

Choses douteuses:

  1. La sortie ressemble à [[], [[]], [[], [[]]], [[], [[]], [[], [[]]]]]
  2. La plupart des méthodes d'entrée dans ruby ​​comprendront une nouvelle ligne de fin, ce qui gonfle le nombre de 1.
— histocrate
source
1
Il devrait être parfaitement légitime si vous inspectle tableau manuellement et trle résultat.
— John Dvorak
1

Pure Bash, 54

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

Production:

$ ./strlenset.sh
{}
$ ./strlenset.sh a
{{}}
$ ./strlenset.sh aa
{{} {{}}}
$ ./strlenset.sh aaa
{{} {{}} {{} {{}}}}
$ ./strlenset.sh aaaa
{{} {{}} {{} {{}}} {{} {{}} {{} {{}}}}}
$
— Traumatisme numérique
source
1

Julia 43

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

La construction {z ...} développe la chaîne z dans un tableau. Pliez les boucles sur tous les éléments du tableau en ignorant le contenu et à la place à partir de la chaîne vide. La fonction foldl est disponible dans Julia 0.30.

Exemple de sortie

julia> f("")
"{}"
julia> f("aa")
"{{}{{}}}"
julia> f("aaaa")
"{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}"
julia> f("aaaaaa")
"{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}"
— waTeim
source
1

Mathematica, 45 57 48 octets

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

Une solution à 36 octets:

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

Cependant, il utilise certains calculs arithmétiques.

— alephalpha
source
0

Delphi XE3 (264)

D' accord , je ne viennent même près de l'autre , mais il était amusant de le faire :)
overthinking Probablement il. Je vais voir s'il y a une meilleure façon de le faire.

Golfé

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.

Non golfé

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.

Résultats des tests

Cordes testées de longueur 0..10

{}
{{} }
{{} {{}} }
{{} {{}} {{}{{}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}}}} }
— Teun Pronk
source
Merci d'avoir essayé. Dans mon esprit, je considérais la longueur comme une opération mathématique car elle renvoie un nombre et tout comme l'utilisation d'une boucle «pour» qui implique le comptage.
— jing3142
0

Perl 5:33 caractères

Il n'est pas très clair quels caractères je devrais compter dans la solution. Probablement pas la echo ... |partie car c'est juste utilisé pour alimenter une ligne vers stdin. Probablement pas le nom du binaire perl, car vous pouvez renommer ce que vous voulez.

J'ai donc compté les commutateurs de ligne de commande passés à perl, les guillemets enroulés autour du code Perl et le code Perl lui-même.

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

Aussi, lié .

— tobyink
source
1
Vous devriez compter plcomme standard, mais vous obtenez -eet les citations autour du code gratuitement. Ref
— Peter Taylor
0

Perl 6: 37 caractères

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

ou de STDIN:

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

{"\{@_.join()\}"}...*fait une liste paresseuse des formes définies des nombres naturels, et nous prenons juste celle dont nous avons besoin get.chars.

La liste paresseuse pourrait être écrite de manière plus lisible:

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

Qui se lit assez similaire à la définition.

— Mouq
source
0

Fléchette: 85 caractères

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

(avec une nouvelle ligne supplémentaire pour plus de lisibilité).

L'exigence de ne pas utiliser "0" mord vraiment, sinon ce .firstserait [0]et ce (..).isNegativeserait ..<0.

— lrn
source
0

Pyth, 13 octets

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

C'est l'équivalent Pyth golfé de la réponse Python de @ xnor. Notez que Pyth est plus récent que cette question, donc cette réponse n'est pas éligible pour gagner ce défi.

Manifestation.

— isaacg
source
— Leaky Nun
0

Javascript, 171 149 147 142 octets

(Sera probablement joué au golf plus tard)

n = prompt (). split (""); for (a = []; n.pop ();) a.push (a.slice ()); alert (JSON.stringify ({a: a}) [ R = "remplacer"] (/ [^ \ [\]] / g, "") [R] (/ \ [/ g, "{") [R] (/ \] / g, "}")) ;
— SuperJedi224
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.