Faire un simple wrapper de mots


22

(Remarque: il s'agit de ma première question de golf par code, mais pour autant que je sache, personne d'autre n'a fait exactement cela, donc je devrais être bon.)

Votre tâche consiste à créer un programme ou une fonction qui accepte une chaîne set un entier n, et renvoie ou génère ce texte encapsulé sur plusieurs lignes. Chaque mot doit être entièrement sur une ligne; c'est-à-dire aucun mot divisé au milieu. Chaque ligne ne peut pas dépasser plus de ncaractères et vous devez insérer autant de mots que possible sur chaque ligne.

Exemple:

s = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed eget erat lectus. Morbi mi mi, fringilla sed suscipit ullamcorper, tristique at mauris. Morbi non commodo nibh. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Sed at iaculis mauris. Praesent a sem augue. Nulla lectus sapien, auctor nec pharetra eu, tincidunt ac diam. Sed ligula arcu, aliquam quis velit aliquam, dictum varius erat." 
n = 50

output:
Lorem ipsum dolor sit amet, consectetur adipiscing
elit. Sed eget erat lectus. Morbi mi mi, fringilla
sed suscipit ullamcorper, tristique at mauris.
Morbi non commodo nibh. Pellentesque habitant
morbi tristique senectus et netus et malesuada
fames ac turpis egestas. Sed at iaculis mauris.
Praesent a sem augue. Nulla lectus sapien, auctor
nec pharetra eu, tincidunt ac diam. Sed ligula
arcu, aliquam quis velit aliquam, dictum varius
erat.

Votre sortie peut être un tableau de chaînes ou une seule chaîne avec des sauts de ligne. En outre, vous pouvez supposer qu'aucun mot ne sera plus long que n, alors ne vous inquiétez pas de traiter des cas étranges.

Les règles d'E / S standard s'appliquent et les failles standard sont interdites. Les espaces de fin sont autorisés.

Puisqu'il s'agit de , la solution de shortes en octets l'emporte.

Voici un exemple de programme en Python qui fonctionnerait.



3
n est la longueur de ligne maximale? ou la longueur que nous devons atteindre avant la rupture de ligne?
david

1
@david, ou le nombre de lignes?
Peter Taylor

1
28 octets Python est-il pertinent?
david

3
nest la longueur de ligne maximale, désolé que ce ne soit pas clair. Je vais clarifier. De plus, les règles ont maintenant été mises à jour de sorte qu'une simple division ne fonctionne pas.
ATMunn

Réponses:



5

PHP , 8 octets

Certes pas la solution la plus originale, mais PHP a une fonction native qui correspond parfaitement à vos besoins!

wordwrap:

string wordwrap ( string $str [, int $width = 75 [, string $break = "\n" [, bool $cut = FALSE ]]] )

Encapsule une chaîne dans un nombre donné de caractères à l'aide d'un caractère de rupture de chaîne.

Utilisez comme ça:

$str = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed eget erat lectus. Morbi mi mi, fringilla sed suscipit ullamcorper, tristique at mauris. Morbi non commodo nibh. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Sed at iaculis mauris. Praesent a sem augue. Nulla lectus sapien, auctor nec pharetra eu, tincidunt ac diam. Sed ligula arcu, aliquam quis velit aliquam, dictum varius erat.";
echo wordwrap($str, 50);

Ou essayez-le en ligne!


5

JavaScript (ES6),  75 73  72 octets

Prend l'entrée comme (string)(n).

s=>n=>s.split` `.map(w=>r=(u=r?r+' '+w:w)[n]?(o+=r+`
`,w):u,o=r='')&&o+r

Essayez-le en ligne!

Variables

La sortie formatée est stockée dans o (en vert ci-dessous).

La ligne u mise à jour est définie comme la concaténation de:

  • la ligne actuelle r (en noir ci-dessous)
  • un espace si r n'est pas vide, ou rien d'autre (en orange ci-dessous)
  • le nouveau mot w (en bleu ci-dessous)

Nous devons insérer un saut de ligne à chaque fois que le n caractère -ème de u est défini (0 indexées, en rouge ci - dessous).

Exemple

n=16 ets = "LOREM IPSUM DOLOR"

Ajout de "LOREM":

0001020304050607080910111213141516LOREM

Ajout "IPSUM":

00010203040506070809dix111213141516LOREMjePSUM

Ajout de "DOLOR":

00010203040506070809dix111213141516LOREMjePSUMOLOR

00010203040506070809dix111213141516LOREMjePSUMOLOR


Les espaces de fin sont autorisés. peut r+w+' '- être ?
l4m2

5

Perl 6 , 46 29 octets

{;*.comb(/.**{1..$_}[\s|$]/)}

Essayez-le en ligne!

Solution basée sur Regex qui prend les entrées au curry, comme f(n)(s)et renvoie une liste de lignes. Chaque ligne sauf la dernière a un espace de fin

Explication:

{;*                         }   # Anonymous code block that returns a Whatever lambda
   .comb(/                /)    # Split the string by
          .**{1..$_}            # Up to n characters
                    [\s|$]      # Terminated by a whitespace char or the end of the string

4

Vim, 15 octets / touches

DJ:se tw=<C-r>"
gq_

Une question de mise en forme du texte? Je connais juste l'outil pour le travail! Et il a même mon nom dans les deux premières touches: D

<C-r>signifie ctrl-r.

Cela pourrait être un peu plus court en V , mais je préfère répondre en vanilla vim pour des réponses qui montrent vraiment à quel point vim peut être concis pour le bon défi. Et la différence est si petite de toute façon.

Cela pourrait également être le cas pour 15 octets également:

:se tw=<C-r><C-w>
ddgq_

Essayez-le en ligne!


1
Explication:: DJ:Ce programme a été réalisé par DJ, notre chat préféré avec un diamant autour du cou. [...]
Erik the Outgolfer

4

R , 36 27 octets

R a ceci comme intégré ( strwrap), nous retournons un vecteur de lignes divisées.

function(s,n)strwrap(s,n+1)

Essayez-le en ligne!


1
Oui, cela devrait être autorisé. Les tableaux de lignes sont autorisés, donc je ne vois pas pourquoi ce serait différent.
ATMunn

4

Haskell , 70 octets

s!n|length s<=n=[s]|(t,_:d)<-splitAt(until((<'!').(s!!))pred n)s=t:d!n


3

Java (JDK) , 46 44 octets

Fondamentalement, une solution regex pure en Java, presque certainement la plus courte que j'ai écrite.

Bravo à Kevin pour avoir aidé à réduire encore plus les octets dans l'expression régulière!

n->s->s.replaceAll(".{1,"+n+"}( |$)","$0\n")

Essayez-le en ligne!

En utilisant un lamdba au curry, il crée une expression régulière pour correspondre avec avidité aux ncaractères suivis d'un espace ou d'une fin de chaîne. Il remplace ensuite ces caractères par eux-mêmes suivis d'une nouvelle ligne.


@KevinCruijssen correspond en [ $]fait juste à un espace ou $si je me souviens bien, plutôt qu'à la fin de la chaîne. Il semble que cela fonctionne, il semble donc qu'il puisse simplement être joué dans un seul espace pour encore moins d'octets.
Luke Stevens

Ah, cela peut en effet être juste un espace, car vous ajoutez des nouvelles lignes et vous n'avez pas besoin d'ajouter une nouvelle ligne de fin à la fin.
Kevin Cruijssen

1
Vous pouvez jouer au golf 2 octets supplémentaires en supprimant les parenthèses dans l'expression régulière, et utiliser à la $0place de $1.
Kevin Cruijssen

@KevinCruijssen Nice one! C'est juste une honte replaceAlltellement verbeuse!
Luke Stevens

2
Pour moi, c'est faux, apparaît si je modifie la phrase latine de l'exercice dans la façon dont il se termine par "... dictum varius abc erat." Il y a une nouvelle ligne inutile après la lettre c ...
RosLuP

2

Mathematica, 16 octets

InsertLinebreaks

Fonction intégrée. Prend une chaîne et un entier en entrée et renvoie une chaîne en sortie.

InsertLinebreaks["string", n]
 insère des caractères de nouvelle ligne pour ne pas faire plus de ligne que n caractères.


2

Powershell, 40 83 octets

Cas de test avec n=80ajout.

param($s,$n)$s-split' '|%{if(($o+$_|% le*)-lt$n){$o+=' '*!!$o+$_}else{$o;$o=$_}}
$o

Script de test:

$f = {

param($s,$n)$s-split' '|%{if(($o+$_|% le*)-lt$n){$o+=' '*!!$o+$_}else{$o;$o=$_}}
$o

}

@(
,(50, "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed eget erat lectus. Morbi mi mi, fringilla sed suscipit ullamcorper, tristique at mauris. Morbi non commodo nibh. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Sed at iaculis mauris. Praesent a sem augue. Nulla lectus sapien, auctor nec pharetra eu, tincidunt ac diam. Sed ligula arcu, aliquam quis velit aliquam, dictum varius erat.",
"Lorem ipsum dolor sit amet, consectetur adipiscing",
"elit. Sed eget erat lectus. Morbi mi mi, fringilla",
"sed suscipit ullamcorper, tristique at mauris.",
"Morbi non commodo nibh. Pellentesque habitant",
"morbi tristique senectus et netus et malesuada",
"fames ac turpis egestas. Sed at iaculis mauris.",
"Praesent a sem augue. Nulla lectus sapien, auctor",
"nec pharetra eu, tincidunt ac diam. Sed ligula",
"arcu, aliquam quis velit aliquam, dictum varius",
"erat.")
,(80, "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed eget erat lectus. Morbi mi mi, fringilla sed suscipit ullamcorper, tristique at mauris. Morbi non commodo nibh. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Sed at iaculis mauris. Praesent a sem augue. Nulla lectus sapien, auctor nec pharetra eu, tincidunt ac diam. Sed ligula arcu, aliquam quis velit aliquam, dictum varius erat.",
"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed eget erat lectus.",
"Morbi mi mi, fringilla sed suscipit ullamcorper, tristique at mauris. Morbi non",
"commodo nibh. Pellentesque habitant morbi tristique senectus et netus et",
"malesuada fames ac turpis egestas. Sed at iaculis mauris. Praesent a sem augue.",
"Nulla lectus sapien, auctor nec pharetra eu, tincidunt ac diam. Sed ligula arcu,",
"aliquam quis velit aliquam, dictum varius erat.")
) | %{
    $n,$s,$expected = $_
    $result = &$f $s $n
    "$result"-eq"$expected"
    # $result   # uncomment this line to dispaly a result
}

Sortie:

True
True


Merci. Le faux ternaire est une expression. Ce script contient un implicite returndans la elsepartie et une déclaration dans la thenpartie.
mazzy


2

Japt , 20 octets

¸rÈ+Yi[X·ÌY]¸Ê>V?R:S

Essayez-le en ligne!

Merci à Bubbler et Shaggy pour leur aide

Explication:

¸                       #Split into words
 r                      #For each word, add them to the output in this way:
     i                  # Choose a character using this process:
       X·Ì              #  Get the last line of the output
          Y             #  And the current word
      [    ]¸           #  Join them with a space
             Ê>V?       #  If the resulting line is greater than the allowed length:
                ?R      #   Choose "/n" (newline)
                  :S    #  Otherwise choose " " (space)
     i                  # Add the chosen character to the output
  È+Y                   # Add the current word to the output

24 octets avec [X,Y].join(...).
Bubbler


1

Retina 0.8.2 , 37 octets

.+$
$*
!`(?=\S.*¶(1)+)(?<-1>.)+(?=\s)

Essayez-le en ligne! Prend set nsur des lignes séparées. Explication:

.+$
$*

Convertissez nen unaire.

(?=\S.*¶(1)+)(?<-1>.)+(?=\s)

Faites correspondre les espaces non blancs, puis regardez en avant net comptez comme $#1. Revenez ensuite en arrière et utilisez un groupe d'équilibrage pour faire correspondre les ncaractères suivis d'espaces.

!`

Sortez les correspondances sous forme de liste de lignes.


Existe-t-il un moyen dans Retina de mettre la première entrée dans une expression régulière que nous utilisons avec la deuxième entrée? Donc quelque chose comme ça: .{1,50} et$0¶ , mais où 50est reçu en entrée à la place?
Kevin Cruijssen

@KevinCruijssen Dans Retina 1, vous pouvez probablement utiliser une étape Eval pour donner un résultat similaire, mais c'est ennuyeux, donc je n'ai pas pris la peine.
Neil

1

Fusain , 19 octets

Nθ←F⪪S «¿‹⁺LιⅈθM→⸿ι

Essayez-le en ligne! Le lien est vers la version détaillée du code. Prend l'entrée de net ssur des lignes distinctes. Explication:

Nθ

Entrée n.

Déplacez le curseur vers la gauche d'un carré pour équilibrer le mouvement de droite à partir de la première itération de la boucle.

F⪪S «

Divisez la chaîne sur les espaces et faites une boucle sur les mots.

¿‹⁺Lιⅈθ

Calculez si le mot suivant atteindra le bord droit.

M→

Si ce n'est pas le cas, déplacez-vous d'un carré vers la droite.

⸿

S'il démarre alors une nouvelle ligne.

ι

Sortez le mot.



1

05AB1E , 18 octets

õs#vDy«g²›i,}yðJ}?

Essayez-le en ligne.

Explication:

õ                   # Push an empty string "" to the stack
 s                  # Swap to take the (implicit) string input
  #                 # Split it by spaces
   v            }   # For-each `y` over the words:
    D               #  Duplicate the top of the stack
                    #  (which is the empty string in the very first iteration)
     y«             #  Append the current word `y`
       g            #  Get its length
        ²›i }       #  If its lengthy is larger than the second input:
           ,        #   Pop and output the current duplicated value with trailing newline
             yð     #  Push the word `y` and a space " "
               J    #  Join the entire stack together
                 ?  # After the loop, output the last part as well (without newline)

1

Java 8, 135 octets

n->s->{String r="",S[]=s.split(" "),t=r;for(int i=0;i<S.length;)if((t+S[i]).length()>n){r+=t+"\n";t="";}else t+=S[i++]+" ";return r+t;}

Essayez-le en ligne.

Explication:

n->s->{                      // Method with integer & String parameters and String return
  String r="",               //  Result-String, starting empty
         S[]=s.split(" "),   //  Input-String split by spaces
         t=r;                //  Temp-String, starting empty as well
  for(int i=0;i<S.length;)   //  Loop `i` in the range [0, amount_of_words):
    if((t+S[i]).length()>n){ //   If `t` and the word are larger than the integer input:
      r+=t+"\n";             //    Add `t` and a newline to the result
      t="";}                 //    And reset `t` to an empty String
     else                    //   Else:
       t+=S[i++]+" ";        //    Append the word and a space to `t`
                             //    (and then increase `i` by 1 with `i++` for the next word
                             //     of the next iteration)
  return r+t;}               //  Return the result-String appended with `t` as result


1

APL (Dyalog Unicode) , 14 octets SBCS

Fonction Infix; l'argument de gauche est n, l'argument de droite est n.

CY'dfns'wrap

Essayez-le en ligne!

⎕CYc op y dans la bibliothèque dfns

 puis

wrap[c]  utiliser l'enveloppe [n] fonction

[c]  code de cette fonction
[n]  notes pour cette fonction


Version golfée de wrap, 59 octets SBCS

{⍺≥≢⍵:⍵⋄(t↑⍵),2↓⎕TC,⍺∇⍵↓⍨t+b⊃⍨t←⊃⌽⍺,g/⍨⍺≥g←⍸(⍺+1)↑b' '=⍵}

Essayez-le en ligne!

{} Dfn; est l'argument gauche (largeur), est l'argument droit (chaîne)

≢⍵ décompte (nombre de caractères) de la chaîne

⍺≥: Si la largeur est supérieure ou égale à celle-ci, alors:

   retourner la chaîne

 autrement:

  ' '=⍵ Masque booléen où les blancs sont égaux à la chaîne

  b← stocker dans b(pour b lanks)

  (… En )↑ tirer le nombre d'éléments suivant:

   ⍺+1 un de plus que la largeur

  i ndices où vrai

  g← stocker dans g(pour g aps)

  ⍺≥ Masque booléen dont la largeur est supérieure ou égale à celle

  g/⍨ filtrer les indices d'écart par ce

  ⍺, ajouter cela à la largeur

  ⊃⌽ choisissez le dernier élément de cela (lit. choisissez le premier de l'inverse)

  t← stocker t(pour t ake)

  b⊃⍨ utilisez-le pour choisir un élément du masque des bords b

  t+ ajouter cela à t

  ⍵↓⍨ supprimer autant de caractères de la chaîne

  ⍺∇ recurse sur cela avec le même argument gauche gauche

  ⎕TC, Ajout qui a la liste des t erminal c ontrol caractères (8: HT, 10: NL, 13: CR)

  2↓ enlevez les deux premiers caractères de cela (en laissant juste un 13: CR)

  (), Joignez cela à ce qui suit:

   t↑⍵ les premiers tcaractères de la chaîne



0

JavaScript + HTML + CSS, 117 64 octets

-53 octets avec l'aimable autorisation de @Neil

n=50
s="Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed eget erat lectus. Morbi mi mi, fringilla sed suscipit ullamcorper, tristique at mauris. Morbi non commodo nibh. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Sed at iaculis mauris. Praesent a sem augue. Nulla lectus sapien, auctor nec pharetra eu, tincidunt ac diam. Sed ligula arcu, aliquam quis velit aliquam, dictum varius erat."
f=(n,s)=>document.body.innerHTML+=`<tt><p style=width:${n}ch>${s}`
f(n,s)


1
Au moins dans mon navigateur, vous pouvez réduire cela à (n,s)=>document.body.innerHTML+=`<p style=width:${n}ch><tt>${s}</tt></p>` 74 octets. Si vous êtes prêt à déterrer les anciennes versions de Firefox, vous pouvez enregistrer 8 octets supplémentaires avec (n,s)=>document.body.innerHTML+=`<pre wrap width=${n}>${s}</pre>` .
Neil

@Neil Belle utilisation des chunités. Firefox 65 se calcule 50chcomme 500px; Chromium 70 calcule 50chcomme400px
guest271314

Cette réponse est fausse. elit. Sed eget erat lectus. Morbi mi mi, fringilla sed(2e ligne) compte plus de 50 caractères. J'utilise le dernier Chrome.
mbomb007

J'ai pu modifier ma suggestion originale de travailler dans Chrome en mettant l' <p>intérieur du <tt>.
Neil



0

C # (.NET Core) , 162 octets

string[]t(string n,int a){var g="";for(int i=0;i++<Math.Floor((double)n.Length/a);)g+=$"^.{{{i*a-1}}}|";return Regex.Split(n,$@"(?n)(?<=({g.Trim('|')})\S*)\s");}}

Cette fonction utilise une expression régulière qui correspond à l'espace blanc le plus proche qui est proche du nième ou multiple du nième caractère et fractionne la chaîne en fonction de celui-ci.

Essayez-le en ligne!

Le lien TIO est un programme complet, et la fonction a un mot-clé statique afin que la fonction puisse être appelée à partir de main.

Test Regex


Cela ne donne pas la bonne sortie pour le cas de test - certaines lignes dépassent 50 caractères. Vous voulez "avant" pas "près", et aussi le fractionnement à un moment donné doit dépendre de l'endroit où il a été divisé plus tôt.
Ørjan Johansen

0

C # (Visual C # Interactive Compiler) , 78 octets

s=>n=>System.Text.RegularExpressions.Regex.Replace(s,".{1,"+n+"}( |$)","$0\n")

Essayez-le en ligne!

Nous remercions @LukeStevens d'avoir proposé la version Java ... Apparemment .NET vous fait importer l' RegularExpressionsespace de noms afin de faire un remplacement :(

Voici ma version originale qui se divise sur le caractère espace et utilise LINQ pour les réunir à nouveau:

C # (Visual C # Interactive Compiler) , 91 octets

s=>n=>s.Split(' ').Aggregate((a,w)=>a+(a.Length-a.LastIndexOf('\n')+w.Length>n?'\n':' ')+w)

Essayez-le en ligne!



0

APL (NARS), 48 caractères, 96 octets

{⊃⍵{⍺≥≢⍵:⊂⍵⋄k←1+⍺-' '⍳⍨⌽r←⍺↑⍵⋄(⊂k↑r),⍺∇k↓⍵}⍨⍺+1}

tester:

  f←{⊃⍵{⍺≥≢⍵:⊂⍵⋄k←1+⍺-' '⍳⍨⌽r←⍺↑⍵⋄(⊂k↑r),⍺∇k↓⍵}⍨⍺+1}
  s←"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed eget erat lectus. Morbi mi mi, fringilla sed suscipit ullamcorper, tristique at mauris. Morbi non commodo nibh. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Sed at iaculis mauris. Praesent a sem augue. Nulla lectus sapien, auctor nec pharetra eu, tincidunt ac diam. Sed ligula arcu, aliquam quis velit aliquam, dictum varius erat."
  50 f s
Lorem ipsum dolor sit amet, consectetur adipiscing 
elit. Sed eget erat lectus. Morbi mi mi, fringilla 
sed suscipit ullamcorper, tristique at mauris.     
Morbi non commodo nibh. Pellentesque habitant      
morbi tristique senectus et netus et malesuada     
fames ac turpis egestas. Sed at iaculis mauris.    
Praesent a sem augue. Nulla lectus sapien, auctor  
nec pharetra eu, tincidunt ac diam. Sed ligula     
arcu, aliquam quis velit aliquam, dictum varius    
erat.                                              

Je ne sais pas dans "{⊃⍵ {⍺≥≢⍵: ⊂⍵⋄ ..." Si c'est vrai ≥ ou c'est juste là> ...
RosLuP

0

C, 63 octets

b(a,n)char*a;{while(strlen(a)>n){for(a+=n;*a-32;--a);*a++=10;}}

La fonction de cet exercice b (a, n) romprait la ligne "a" comme dit l'exercice, de la même manière que sa longueur ne changerait pas (si nous voyons le résultat comme une chaîne) car changer certains espaces dans \ n ou une nouvelle ligne dans endroit. La chaîne d'entrée "a" ne devrait pas avoir de caractère \ n également pour la fonction b () (elle pourrait avoir \ n dans la chaîne d'entrée pour bs ())

La fonction b (a, n) ne serait correcte que parce que la restriction de cet exercice, qui impose que chaque mot d'une chaîne "a" a une longueur <n si ce n'est pas vrai, cette fonction peut aller
à une boucle infinie ... (très mal dans ma façon de voir donc je copie aussi la fonction plus bien car dans ce cas retournerait -1 et non irait à une boucle infinie; c'est bs (a, n) ci-dessous) je n'exclus pas les deux fonctions sont buggées .. .

#define R(x,y) if(x)return y
#define U unsigned
U bs(char*a,U n)
{U c,q,r=1,i,j;
 R(!a||n<1||n++>0xFFFF,-1);
 for(j=c=i=0;;++i,++c)
    {R(i==-1,-1);q=a[i];
     if(q==10)goto l;
     if(c>=n){R(i-j>n,-1);a[i=j]=10;l:c=-1;++r;}
     R(!q,r);
     if(q==32)j=i;
    }
}

résultat de b () passé sur une fonction qui ajoute la longueur de ligne à chaque ligne

Lorem ipsum dolor sit amet, consectetur adipiscing [50]
elit. Sed eget erat lectus. Morbi mi mi, fringilla [50]
sed suscipit ullamcorper, tristique at mauris. [46]
Morbi non commodo nibh. Pellentesque habitant [45]
morbi tristique senectus et netus et malesuada [46]
fames ac turpis egestas. Sed at iaculis mauris. [47]
Praesent a sem augue. Nulla lectus sapien, auctor [49]
nec pharetra eu, tincidunt ac diam. Sed ligula [46]
arcu, aliquam quis velit aliquam, dictum varius [47]
erat. [5]

@ceilingcat ok, le code ci-dessus prendrait également en compte le \ n ... un bug que j'ai trouvé avec le code était que la dernière ligne n'était pas correctement imprimée ... pourquoi n'écrivez-vous pas votre réponse C comme une autre? Il gagnerait sur le mien car il est plus court ... pour le vrai j'utilise la première ligne (ou la déclaration ";") pour la vérification de l'entrée uniquement car pour moi l'entrée doit être vérifiée même si c'est un peu plus longue; J'essaie en vain d'écrire la fonction en APL ...
RosLuP

@ceilingcat dans la dernière réponse, vu cette question ne pas dire si la chaîne d'entrée doit ou ne doit pas y avoir '\ n' char et vu que l'exemple n'a pas '\ n' Je suppose que la chaîne d'entrée n'a pas de nouveau caractère de ligne ...
RosLuP

Seulement 83 ... Oui, je dois voir si je gagne 3 caractères en utilisant l'ancienne définition de fonction ...
RosLuP

Seulement 81 .... .... ....
RosLuP

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.