Dans certains pays, il existe des recommandations ou des lois sur la manière de créer des corridors d'urgence dans les rues à plusieurs voies par direction. (Dans ce qui suit, nous ne considérons que les voies qui vont dans la direction que nous empruntons.) Voici les règles en vigueur en Allemagne:

• S'il n'y a qu'une seule voie, tout le monde doit conduire à droite de manière à ce que les véhicules de secours puissent passer à gauche.
• S'il y a deux voies ou plus, les voitures de la voie la plus à gauche doivent rouler à gauche et tous les autres doivent se déplacer à droite.

Défi

Etant donné le nombre N>0de voies régulières, affichez la disposition des voies lorsqu'un corridor d'urgence est formé à l'aide d'une chaîne de N+1caractères ASCII. Vous pouvez utiliser deux caractères quelconques du code ASCII 33jusqu'à 126, un pour indiquer le couloir d'urgence et un pour désigner les voitures. Les espaces finaux ou suivants, les sauts de ligne, etc. sont autorisés.

Exemples

Ici, nous utilisons Ele couloir d’urgence et Cles voitures.

N  Output
1  EC
2  CEC
3  CECC
4  CECCC
5  CECCCC
6  CECCCCC
   etc

Python 2, 29 26 octets

lambda n:10**n*97/30-1/n*9

Exemple:

>>> f(1)
23
>>> f(2)
323
>>> f(3)
3233

Python 3, 35 33 octets

lambda N:'C'*(N>1)+'EC'+'C'*(N-2)

Edit: déposer f=pour sauvegarder 2 octets, grâce au rappel de @dylnan .

Essayez-le en ligne!

Pour le visualiser:

lambda N:'🚘'*(N>1)+'🚔🚘'+'🚘'*(N-2)

Sortie:

1 🚔🚘
2 🚘🚔🚘
3 🚘🚔🚘🚘
4 🚘🚔🚘🚘🚘
5 🚘🚔🚘🚘🚘🚘
6 🚘🚔🚘🚘🚘🚘🚘

Essayez 🚔 en ligne!

Python 3, 40 octets

Une solution simple:

lambda N:str(10**N).replace('100','010')

Essayez-le en ligne!

C (gcc) , 32 octets

f(n){printf(".%.*f"+1%n,n-1,0);}

Essayez-le en ligne!

Usages 0et .personnages:

.0
0.0
0.00
0.000
0.0000

Japt, 5 4 octets

Utilisations qpour les voitures et +pour le couloir.

ç¬iÄ

L'essayer

Merci à Oliver qui a joué au golf 4 octets en même temps que moi.

Explication

Une solution courte mais une explication délicate!

La chose la plus simple en premier: la çméthode, lorsqu'elle est appliquée à un entier, répète son argument de chaîne ce nombre de fois. La iméthode prend 2 arguments ( s& n) et insère sà l'index nde la chaîne à laquelle elle est appliquée.

En développant les 2 raccourcis unicode utilisés, on obtient ce çq i+1qui, une fois transpilé en JS, devient U.ç("q").i("+",1), où se Utrouve l’entrée. Nous répétons donc les q Utemps, puis nous insérons un +index 1.

L'astuce finale est que, grâce au wrapping d'index de Japt, when U=1, il'insertion de l' +index 0, quelle que soit la valeur pour laquelle vous l'insérez , sera insérée n.

R, 50 octets

-11 merci à Giuseppe!

pryr::f(cat("if"(x<2,12,c(21,rep(2,x-1))),sep=""))

Sorties 1 pour le couloir d'urgence et 2 pour les voies normales

Ma tentative, 61 octets

Rien de spécial à voir ici, mais inscrivons R sur le tableau de bord =)

q=pryr::f(`if`(x<2,cat("EC"),cat("CE",rep("C",x-1),sep="")))

Usage:

q(5)
CECCCC

Haskell , 38 34 32 octets

f 1="EC"
f n="CE"++("C"<*[2..n])

Essayez-le en ligne!

Python 2, 30 29 28 octets

lambda n:`10/3.`[1/n:n-~1/n]

Imprimer 3au lieu de Cet .au lieu de E.

Explication:

Essayez-le en ligne.

lambda n:    # Method with integer parameter and string return-type
  `10/3.`    #  Calculate 10/3 as decimal (3.333333333) and convert it to a string
  [1/n       #   Take the substring from index 1 if `n=1`, 0 otherwise
   ,n-~      #   to index `n+1` +
       1/n]  #    1 if `n=1`, 0 otherwise

Python 2, 33 32 31 29 28 octets

lambda n:1%n-1or'1-'+'1'*~-n

Imprime 1au lieu de Cet -au lieu de E.

-2 octets grâce à @ovs .
-1 octet grâce à @xnor .

Explication:

Essayez-le en ligne.

lambda n:    # Method with integer parameter and string return-type
  1%n-1      #  If `n` is 1: Return '-1'
  or         #  Else:
    '1-'+    #   Return '1-', appended with:
    '1'*~-n  #   `n-1` amount of '1's

Pyth, 10 9 8 octets

Xn1Q*NQZ

Utilisations 0pour désigner le couloir d’urgence et ".
Essayez-le ici

Explication

Xn1Q*NQZ
    *NQ     Make a string of <input> "s.
 n1Q         At index 0 or 1...
X      Z    ... Insert 0.

brainfuck , 42 octets

,[[>]+[<]>-]>>[<]<[<]>+>+<[<-[--->+<]>.,>]

Essayez-le en ligne!

Prend les entrées en tant que code de caractères et les sorties en tant Vque voies normales et voies Wdégagées. (Pour tester facilement, je recommande de remplacer le ,avec un certain nombre de +s)

Comment ça marche:

,[[>]+[<]>-] Turn input into a unary sequence of 1s on the tape
>>[<]<[<]    Move two cells left of the tape if input is larger than 1
             Otherwise move only one space
>+>+<        Add one to the two cells right of the pointer
             This transforms:
               N=1:  0 0' 1 0  -> 0 2' 1 0
               N>1:  0' 0 1 1* -> 0 1' 2 1*
[<-[--->+<]>.,>]  Add 86 to each cell to transform to Ws and Vs and print

Octave (MATLAB *), 31 30 28 27 22 octets

@(n)'CE'(1+(n>1==0:n))

Essayez-le en ligne!

Le programme fonctionne comme suit:

@(n)                   %Anonymous function to take input
            n>1==0:n   %Creates [1 0] if n is 1, or [0 1 (0 ...)] otherwise
         1+(        )  %Converts array of 0's and 1's to 1-indexed
    'CE'(            ) %Converts to ASCII by addressing in string

L'astuce utilisée ici consiste à vérifier le tableau de départ de 0:navec un contrôle si l'entrée est supérieure à 1. Le résultat est que, pour n>1le point de départ, il est converti en tableau logique de [0 1 (0 ...)]tandis que pour n==1le point de départ est inversé [1 0], ce qui permet l'inversion nécessaire.

Le reste ne fait que convertir la graine en chaîne avec suffisamment de voitures ajoutées.

(*) Le lien TIO inclut dans les commentaires de pied de page une solution alternative pour le même nombre d'octets qui fonctionne dans MATLAB ainsi qu'Octave, mais il en résulte une séquence de "0" et "1" plutôt que "E" et " C '. Pour être complet, le remplaçant est:

@(n)['' 48+(n>1==0:n)]

• Enregistré 1 octet en utilisant n==1~=0:1plutôt que 0:1~=(n<2). ~=a priorité sur <, d’où les crochets originaux, mais c’est ce qui semble ~=et qui ==sont traités par ordre d’apparition. Ainsi, en comparant avec 1, nous pouvons enregistrer un octet.

• 2 octets enregistrés en modifiant l'emplacement où la négation 2:nest effectuée. Cela enregistre une paire de crochets. Nous devons également changer le ~=à ==pour tenir compte du fait que cela sera annulé plus tard.

• Enregistré 1 octet en utilisant à <nouveau. Il s'avère que cela <a la même priorité ==qu'après tout. Placer le <calcul avant le ==garantit l’ordre correct d’exécution.

• 5 octets enregistrés en ne créant pas deux tableaux distincts. Vous ferez plutôt confiance au fait que la comparaison XNOR convertira une plage unique en logiques.

Gelée , 11 à 9 octets

’0ẋ⁾0E;ṙỊ

Essayez-le en ligne!

Programme complet.

Utilise 0au lieu de C.

C (gcc), 39 octets

f(n){printf("70%o"+!n,7|(1<<3*--n)-1);}

Essayez-le en ligne!

Emprunté et adapté l'astuce printf de la réponse d' ErikF .

Python 3, 32 octets

lambda n:f"{'CE'[n<2:]:C<{n+1}}"

Essayez-le en ligne!

Utilise une expression de chaîne de caractères f pour formater 'E'ou être 'CE'complétée à droite avec 'C'une largeur de n+1.

f"{          :       }    a Python 3 f-string expression.
   'CE'[n<2:]             string slice based on value of n.
             :            what to format is before the ':' the format is after.
              C           padding character
               <          left align
                {n+1}     minimum field width based on n

Brain-Flak , 100 à 66 octets

{({}[()]<((((()()()()){}){}){}())>)}{}(({}<>)())<>{<>{({}<>)<>}}<>

Essayez-le en ligne!

Utilise "comme voie d'urgence et !comme voie normale.

C #, 34 octets

n=>n++<2?"EC":"CE".PadRight(n,'C')

Essayez-le en ligne!

05AB1E , 7 octets

Î>∍1I≠ǝ

Essayez-le en ligne!

0 est C et 1 est E.

Explication

Î>          # Push 0 and input incremented            -- [0, 4]
  ∍         # Extend a to length b                    -- [0000]
   1I≠      # Push 1 and input falsified (input != 1) -- [0000, 1, 1] 
      ǝ     # Insert b in a at location C             -- [0100]
            # Implicit display

APL (Dyalog Unicode) , 21 17 16 octets

(-≠∘1)⌽'E',⍴∘'C'

Essayez-le en ligne!

Merci à Erik pour la sauvegarde de 4 octets et à Adám pour un octet supplémentaire.

Comment?

(-≠∘1)⌽'E',⍴∘'C' ⍝ Tacit function
           ⍴∘'C' ⍝ Repeat 'C', according to the input
       'E',      ⍝ Then append to 'E'
      ⌽          ⍝ And rotate
    1)           ⍝ 1
  ≠∘             ⍝ Different from the input? Returns 1 or 0
(-               ⍝ And negate. This rotates 0 times if the input is 1, and once if not.

Haskell , 35 33 32 octets

2 octets enregistrés grâce à Angs, 1 octet enregistré grâce à Lynn

(!!)$"":"EC":iterate(++"C")"CEC"

Essayez-le en ligne!

Haskell , 32 30 29 octets

Ceci est zéro indexé donc il ne relève pas le défi

g=(!!)$"EC":iterate(++"C")"CEC"

Essayez-le en ligne!

Haskell , 30 octets

Cela ne fonctionne pas car la sortie doit être une chaîne

f 1=21
f 2=121
f n=10*f(n-1)+1

Essayez-le en ligne!

Ici, nous utilisons des chiffres au lieu de chaînes, 2pour le couloir d'urgence, 1pour les voitures. Nous pouvons ajouter un 1à la fin en multipliant par 10 et en ajoutant 1. C'est moins cher car nous n'avons pas à payer tous les octets pour la concaténation et les littéraux de chaîne.

Ce serait moins coûteux à utiliser 0au lieu de, 1mais nous avons besoin de zéros non significatifs, qui finissent par être éliminés.

Python 3 , 30 29 octets

lambda n:"CEC"[~n:]+"C"*(n-2)

Essayez-le en ligne!

OK, il y a déjà beaucoup de réponses en Python, mais je pense que c'est le premier byter de moins de 30 ans parmi ceux qui utilisent encore les caractères "E" et "C" plutôt que des chiffres.

JavaScript (Node.js) , 28 octets

n=>n<2?21:"12".padEnd(n+1,1)

Essayez-le en ligne!

APL (Dyalog Unicode) , 16 octets

≡∘1⌽'CE',1↓⍴∘'C'

Essayez-le en ligne!

Stax , 7 octets

ü♣àj#F 

Exécuter et déboguer

Ceci utilise les caractères "0" et "1". Cela fonctionne car lorsque vous faites pivoter un tableau de taille 1, il ne change pas.

Déballé, non golfé et commenté, cela ressemble à ceci.

1]( left justify [1] with zeroes. e.g. [1, 0, 0, 0]
|)  rotate array right one place
0+  append a zero
$   convert to string

Exécuter celui-ci

JavaScript (Node.js) , 19 octets

n=>--n?"0"+10**n:10

Essayez-le en ligne!

Perl 5 -p , 27 20 19 octets

$_=1x$_;s/1?\K1/E1/

Essayez-le en ligne!

Enregistré un octet en utilisant 1pour les voitures et Epour le couloir d'urgence.

Gelée , 6 octets

⁵*ṾṙỊṙ

Affiche les voies réservées aux voitures à 0 et la voie d’urgence à 1 .

Essayez-le en ligne!

Comment ça marche

⁵*ṾṙỊṙ  Main link. Argument: n

⁵*      Compute 10**n.
  Ṿ     Uneval; get a string representation.
   ṙỊ   Rotate the string (n≤1) characters to the left.
     ṙ  Rotate the result n characters to the left.

Espace blanc , 141 104 103 octets

[S S S N
_Push_0][S N
S _Duplicate_0][T   N
T   T   _Read_STDIN_as_number][T    T   T   _Retrieve][S S S T  S N
_Push_2][T  S S T   _Subtract][S N
S _Duplicate_input-2][N
T   T   N
_If_negative_Jump_to_Label_-1][S S S T  N
_Push_1][S N
S _Duplicate_1][T   N
S T _Print_as_integer][S S T    T   N
_Push_-1][T N
S T _Print_as_integer][T    S S T   _Subtract][N
S S T   N
_Create_Label_LOOP][S N
S _Duplicate][N
T   T   S N
_If_negative_Jump_to_EXIT][S S S T  N
_Push_1][S N
S _Duplicate_1][T   N
S T _Print_as_integer][T    S S T   _Subtract][N
S N
T   N
_Jump_to_LOOP][N
S S N
_Create_Label_-1][T N
S T _Print_as_integer][N
S S S N
_Create_Label_EXIT]

Lettres S(espace), T(tabulation) et N(nouvelle ligne) ajoutées uniquement en surbrillance.
[..._some_action]ajouté comme explication seulement.

Imprime 1au lieu de Cet -au lieu de E.

-1 octet grâce à @JoKing en suggérant l'utilisation de 1et à la -1place de 0et 1.

Explication en pseudo-code:

Integer i = STDIN-input as integer - 2
If i is negative (-1):
  Print i (so print "-1")
Else:
  Print "1-1"
  Start LOOP:
    If i is negative:
      EXIT program
    Print "1"
    i = i-1
    Go to the next iteration of the LOOP

Exemple fonctionne:

Contribution: 1

Command   Explanation                 Stack      Heap    STDIN   STDOUT   STDERR

SSSN      Push 0                      [0]
SNS       Duplicate top (0)           [0,0]
TNTT      Read STDIN as integer       [0]        {0:1}   1
TTT       Retrieve heap at 0          [1]        {0:1}
SSSTSN    Push 2                      [1,2]      {0:1}
TSST      Subtract top two            [-1]       {0:1}
SNS       Duplicate input-2           [-1,-1]    {0:1}
NTSN      If neg.: Jump to Label_-1   [-1]       {0:1}
NSSN      Create Label_-1             [-1]       {0:1}
TNST      Print top as integer        []         {0:1}           -1
NSSSN     Create Label_EXIT           []         {0:1}
                                                                         error

Essayez-le en ligne (avec des espaces bruts, des onglets et des nouvelles lignes uniquement).
Arrêts avec erreur: sortie non définie.

Contribution: 4

Command   Explanation                   Stack      Heap    STDIN   STDOUT   STDERR

SSSN      Push 0                        [0]
SNS       Duplicate top (0)             [0,0]
TNTT      Read STDIN as integer         [0]        {0:4}   4
TTT       Retrieve heap at 0            [4]        {0:4}
SSSTSN    Push 2                        [4,2]      {0:4}
TSST      Subtract top two              [2]        {0:4}
SNS       Duplicate input-2             [2,2]      {0:4}
NTSN      If neg.: Jump to Label_-1     [2]        {0:4}
SSSTN     Push 1                        [2,1]      {0:4}
SNS       Duplicate top (1)             [2,1,1]    {0:4}
TNST      Print as integer              [2,1]      {0:4}           1
SSTTN     Push -1                       [2,1,-1]   {0:4}
TNST      Print as integer              [2,1]      {0:4}           -1
TSST      Subtract top two              [1]        {0:4}
NSSTN     Create Label_LOOP             [1]        {0:4}
 SNS      Duplicate top (1)             [1,1]      {0:4}
 NTTSN    If neg.: Jump to Label_EXIT   [1]        {0:4}
 SSSTN    Push 1                        [1,1]      {0:4}
 SNS      Duplicate top (1)             [1,1,1]    {0:4}
 TNST     Print as integer              [1,1]      {0:4}           1
 TSST     Subtract top two              [0]        {0:4}
 NSNTN    Jump to Label_LOOP            [0]        {0:4}

 SNS      Duplicate top (0)             [0,0]      {0:4}
 NTTSN    If neg.: Jump to Label_EXIT   [0]        {0:4}
 SSSTN    Push 1                        [0,1]      {0:4}
 SNS      Duplicate top (1)             [0,1,1]    {0:4}
 TNST     Print as integer              [0,1]      {0:4}           1
 TSST     Subtract top two              [-1]       {0:4}
 NSNTN    Jump to Label_LOOP            [-1]       {0:4}

 SNS      Duplicate top (-1)            [-1,-1]    {0:4}
 NTTSN    If neg.: Jump to Label_EXIT   [-1]       {0:4}
NSSSN     Create Label_EXIT             [-1]       {0:4}
                                                                            error

Essayez-le en ligne (avec des espaces bruts, des onglets et des nouvelles lignes uniquement).
Arrêts avec erreur: sortie non définie.

AutoHotkey 32 octets

Remplace la lettre "C" par "EC" à moins que le montant de C> 1, puis envoie "CEC" et quitte l'application.

::C::EC
:*:CC::CEC^c
^c::ExitApp

C => EC
CC => CEC quitte alors le programme. Tous les autres C seront entrés après la sortie du programme.

APL + WIN, 20 16 octets

4 octets économisés grâce à Adám

Invites pour l'entier n:

(-2≠⍴n)⌽n←1⎕/⍕10

1 pour le couloir d'urgence o pour les voitures.

J , 11 octets

1":1&<=i.,]

Essayez-le en ligne!

Basé sur le commentaire de ngn .

🚘 et 🚔:

1&<,~/@A.'🚔',~'🚘'$~,&4

MathGolf , 7 à 6 octets

ú░\┴╜╪

Essayez-le en ligne.

Sortie 1pour Eet 0pour C.

Explication:

ú         # 10 to the power of the (implicit) input
          #  i.e. 1 → 10
          #  i.e. 4 → 10000
 ░        # Convert it to a string
          #  i.e. 10 → "10"
          #  i.e. 10000 → "10000"
  \       # Swap so the (implicit) input is at the top of the stack again
   ┴╜     # If the input is NOT 1:
     ╪    #  Rotate the string once towards the right
          #   i.e. "10000" and 4 → "01000"
          # Output everything on the stack (which only contains the string) implicitly