Je définis le n-ième ternaire comme un ternaire qui retourne n et a la forme:

1 ? 2 ? 3 ? n - 1 ? n : 0 : 0 : 0  # n - 1 zeroes

Écrivez une fonction ou un programme complet qui, étant donné une entrée n, affichera ou renverra le n-ième ternaire. Code-Golf.

Cas de test

0 #=> undefined behaviour
1 #=> 1
2 #=> 1 ? 2 : 0
3 #=> 1 ? 2 ? 3 : 0 : 0
10 #=> 1 ? 2 ? 3 ? 4 ? 5 ? 6 ? 7 ? 8 ? 9 ? 10 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0

Le 1000 e ternaire, je pense qu'il y a une sorte d'harmonie zen.

Pyth - 19 18 17 octets

Les espaces me tuent, pensant à une meilleure façon de les gérer.

+j" ? "SQ*tQ" : 0

Il joint simplement les nombres par un " ? ", puis concatène la deuxième partie.

+              String concatenation
 j" ? "        Join by the string
  SQ           1-indexed inclusive range to input
 *             String repetition
  tQ           Input - 1
  " : 0        String implicitly closed by end of program

Essayez-le en ligne ici .

CJam, 18 18 octets

ri,:)":?0"*2/ze_S*

Essayez-le en ligne .

Explication

ri,:)          e# Generate the list 1..n.
":?0"*         e# Insert ":?0" between every two numbers.
2/             e# Split into pairs, e.g. 1:, ?0, 2:, ?0, ..., ?0, n.
z              e# First items in every pair before second items in every pair.
e_             e# Concatenate the two parts.
S*             e# Insert spaces.

Rubis, 31 octets

f=->n{[*1..n]*' ? '+' : 0'*~-n}

Tester:

> f[1]
=> "1"
> f[7]
=> "1 ? 2 ? 3 ? 4 ? 5 ? 6 ? 7 : 0 : 0 : 0 : 0 : 0 : 0"

CJam, 19 octets

Juste un début ...

ri_,:)'?*\(":0"*+S*

Comment ça fonctionne

ri_                       e# Read the number as integer and make a copy of it on stack
   ,:)                    e# Convert the copy to array [1 .. n]
      '?*                 e# Join the numbers with a '?'. So we have [1 '? 2 '? ... '? n]
         \(               e# Swap the stack to get original integer on top. Decrement it by 1
           ":0"*          e# Get n-1 repeated ":0" string
                +S*       e# Join the two strings and fill it with spaces. 

Essayez-le en ligne ici

Brainfuck, 305

(Sans numéro d'entrée de STDIN, voir modifier en bas)

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

J'ai utilisé ce joli algorithme pour imprimer un nombre, ce qui prend 155 octets de l'ensemble du programme.

Il fonctionne pour des entrées jusqu'à 32 768 (limitation de 16 bits de l'algorithme). Il ne produit pas d'espaces de fin et fonctionne également pour la saisie 1:

input    output
0        [infinite loop (til underflow)]
1        "1"
2        "1 ? 2 : 0"
4        "1 ? 2 ? 3 ? 4 : 0 : 0 : 0"
etc.

Visite rapide:

Configuration (97 octets)

-                                 Decrease input (position 0)
[->+>+<<]  >>>                    Copy input twice to the right and 
                                      shift 3 positions to the right
++++[>++++++++<-]>   [<+>-]       Precalculate number 32 (=" ") at position 3
+++++++[>+++++++++<-]>  [<+>-]    Precalculate number 63 (="?") at position 4
++++++[>++++++++<-]>    [<+>-]    Precalculate number 48 (="0") at position 5
++<<<<                            Precalculate number 2 for later use. This number
                                      will be printed in each iteration. (position 6)

Première partie (181 octets)

>>>+.-<<<                Go to the char "0" we saved, increase it, print it,
                             decrease it and go back (this prints "1" everytime)
[                        While our second copy of the number isn't zero
    >.>.<.>>>                Move to " ", print, move to "?", print,
                                 move to " " again, print, move to our
                                 number at the end which is initially 2

    [>>+>+<<<-]>>>[<<<+>>>-]<<+>[<->[>++++++++++<[->-[>+>>]>[+[-<+>]>+>>]<<<<<]>[-]
        ++++++++[<++++++>-]>[<<+>>-]>[<<+>>-]<<]>]<[->>++++++++[<++++++>-]]<
        [.[-]<]<             Algorithm to print the number at current position

    +<<<<                    Increase our number at the end and return to the beginning
-]                       Decrease the loop variable

Deuxième partie (27 octets)

>>-----<<<        Move to our "?" char and decrease it by 5 to get ":"
[-                While our first copy of the number isn't zero decrease it
   >>.>.<.>>.<<<<     Print " ", print ":", print " ", print "0"
]

S'il était permis de mapper les 8 commandes Brainfuck à 3 bits, alors ce programme prendrait 114 octets et 3 autres bits

Unaire, ~ 4,08 * 10 ^ 275 octets

Il serait trop long pour ici, mais il est juste 408452257862560239329948606295286361112603208650130608525040044700379331457759667646985586658469601803889628246410788572492437928714867190270708935427798983714797786123292750743771225096145575210320040188155473030775033228313350778616384531426430459309802833775612506568528463 zéros et fonctionne de la même que le programme Brainfuck.

ÉDITER : J'ai foiré, ce programme ne prend pas vraiment d'entrée utilisateur, il utilise juste la valeur actuelle du pointeur comme entrée. Pour pouvoir analyser un nombre beaucoup plus serait nécessaire et je ne peux pas être dérangé pour le faire.

Il fonctionne donc avec une valeur directement entrée dans le programme (en ajoutant n fois "+" avant le programme) mais pas avec STDIN

JavaScript (ES6), 42 39 octets

f=m=>(g=k=>k-m?k+` ? ${g(k+1)} : 0`:m)(1)

La fonction externe fprend la valeur d'entrée, puis appelle la fonction interneg récursivement la pour construire la chaîne du milieu vers l'extérieur, en utilisant la valeur d'entrée au maximum pour tester le cas de base.

Non golfé:

function f(max) {
    function g(count) {
        if(count==max) {
            // base case: return max for the center
            return max;
        } else {
            // recursive case: build outer shell around center
            return count + " ? " + g(count+1) + " : 0";
        }
    }

    return g(1);
}

Python 56 55

t=lambda n:' ? '.join(map(str,range(1,n+1)))+' : 0'*~-n

C # - 76

Func<int,string>F=k=>{var r="";for(;k>1;)r=" ? "+k--+r+" : 0";return"1"+r;};

Haskell, 53 octets

g n='1':foldr(\x s->" ? "++show x++s++" : 0")""[2..n]

Comment cela fonctionne: créez la chaîne de l'intérieur vers l'extérieur en commençant par une chaîne vide et en boucle de nbas en haut 2avec le préfixe du numéro actuel et un ?et l'ajout d'un : 0. Enfin mettre un 1devant tous.

Une approche différente (grâce à @Mauris désormais 9 octets plus court):

Haskell, 60 51 octets

 f n='1':((=<<[2..n])=<<[(" ? "++).show,\x->" : 0"])

Fonctionnement: un littéral 1suivi de ? <x>pour chaque <x>entrée [2..n]suivi d'une constante : 0pour chaque <x>entrée [2..n].

Pyth, 17 octets

jd.iSQs*RtQ,\?":0

Manifestation.

Julia, 44 31 octets

n->join(1:n," ? ")*" : 0"^(n-1)

Cela crée une fonction sans nom qui accepte un entier en entrée et renvoie une chaîne. Pour l'appeler, donnez-lui un nom, par exemplef=n->... .

D'abord, nous réunissons les entiers 1 à n , en séparant chacun avec ?et les espaces en une seule chaîne. Ensuite, nous y ajoutons la chaîne" : 0" répétée n -1 fois.

Exemples:

julia> f(1)
"1"

julia> f(3)
"1 ? 2 ? 3 : 0 : 0"

julia> f(0)
can't repeat a string -1 times

JavaScript ES7, 62 octets

n=>[for(i of Array(n).keys())i+1].join` ? `+' : 0'.repeat(n-1)

Je ne sais pas si je peux jouer au golf plus. Mais c'est une solution assez simple

Firefox uniquement:

var f=n=>[for(i of Array(n).keys())i+1].join` ? `+' : 0'.repeat(n-1)

alert(f(+prompt('Input: ')));

Équivalent ES5:

// Most browsers now support .repeat
String.prototype.repeat = String.prototype.repeat || function(n){var _n = '', i = 0; for (;i < n; i += 1){_n+=this};return _n}
                                                             //Function                         
function f(n){a=[];for(i of Array(n).keys()){a.push(i+1)};return a.join(' ? ')+' : 0'.repeat(n-1)}

alert(f(+prompt('Input: ')))

CoffeeScript, 52 octets

f=(n)->s='';s=' ? '+n--+s+' : 0'while n;s.slice 3,-4

Explication

f=(n)->
 s = ''                                # initialize string
 s = ' ? ' + n-- + s + ' : 0' while n  # prepend and append in decrementing loop
 s.slice 3,-4                          # chop off leading ?, trailing 0 and whitespace

SWI-Prolog, 90 octets

a(X):-Y is X-1,\+ (between(1,Y,L),\+writef('%w ? ',[L])),write(X),writef('%r',[' : 0',Y]).

Ne va certainement pas gagner, mais la \+ (between(1,TopBound,N),\+do_something(N))construction est assez intéressante pour répéter quelque chose sur une séquence d'entiers.

Swift 145 (135 sans espace blanc)

func t(n:Int) -> String {
    let a = (1..<n).reverse().reduce("") {" ? \($1)\($0) : 0"}
    return a.substringFromIndex(advance(a.startIndex, 3))
}

Pouvez-vous croire que la partie à sous-chaîne est en réalité plus longue que la partie à produire l'expression.

Perl, 36 octets

say join(" ? ",1..$_)." : 0"x($_-1)

35caractères +1pour-n .

Courir avec:

echo 10 | perl -nE'say join(" ? ",1..$_)." : 0"x($_-1)'

Java, 71

Je n'ai pas pu m'en empêcher après avoir commenté la réponse de RCB . Voici donc un autre Java (71 comme wow quand Java n'est-il pas le plus long!)

String t(int n){String s=""+n;for(;--n>0;)s=n+" ? "+s+" : 0";return s;}

Java, 125 88 octets

Original

String f(int n){if(n==1)return"1";String s="",e="";for(int i=1;i<n;i++){s+=i+" ? ";e+=i==n-1?": 0":": 0 ";}return s+n+" "+e;}

Avec un formatage et des noms de variables plus agréables:

String nAry(int n) {
    if (n == 1) {
        return "1";
    }
    String start = "", end = "";
    for (int i = 1; i < n; i++) {
        start += i + " ? ";
        end += (i == n - 1) ? ": 0" : ": 0 ";
    }
    return start + n + " " + end;
}

Amélioré - Merci aux commentaires de Jack Ammo ci-dessous:

String f(int n){String s="",e=s;for(int i=1;i<n;){s+=i+++" ? ";e+=" : 0";}return s+n+e;}

JavaScript (ES6), 59 octets

Même approche que ma réponse CoffeeScript, en utilisant l'aide des chaînes de modèle. String.prototype.repeatcoûte trop de caractères.

f=n=>{for(s=``;n;)s=` ? ${n--+s} : 0`;return s.slice(3,-4)}

Démo

Firefox uniquement pour l'instant, car c'est ES6.

f=n=>{for(s=``;n;)s=` ? ${n--+s} : 0`;return s.slice(3,-4)}

// DEMO
console.log = x => document.body.innerHTML += '<p>' + x

console.log(f(1));
console.log(f(3));
console.log(f(10));

K, 36 octets

{(3_,/(" ? ",)'$!x),(4*-1+x)#" : 0"}

Python 2, 63 60 58 56

Essayez-le ici

Solution simple: (63)

n=input()
for i in range(n-1):print-~i,'?',
print`n`+' : 0'*~-n

Edit : je voulais vraiment essayer une fonction récursive. Le voici: (56)

f=lambda n,c=1:`c`+(' ? '+f(n,c+1)if c<n else~-n*' : 0')

Edit : Quelqu'un sait pourquoi cela ne fonctionne pas? J'ai essayé une liste avec un index de c<n, mais cela n'a pas fonctionné en raison d'une erreur de débordement de pile. Même chose avec ceci:

f=lambda n,c=1:`c`+((c<n)*(' ? '+f(n,c+1))or~-n*' : 0')

rs , 77 octets

(\d+)/(_)^^(\1)
+^_(_+)/\1 _\1
_(_+)$/_\1( : 0)^^((^^\1))
(__+)/? (^^\1)
^./1

Démonstration en direct et cas de test.

Explication:

(\d+)/(_)^^(\1)

Développez le nombre en une série de N soulignements.

+^_(_+)/\1 _\1

Créez à plusieurs reprises une gamme de traits de soulignement, séparés par des espaces. par exemple, cela se transformerait ___en _ __ ___.

_(_+)$/_\1( : 0)^^((^^\1))

Ajouter au dernier ensemble de traits de soulignement (de longueur N) N-1 instances de : 0.

(__+)/? (^^\1)

Remplacez chaque groupe de traits de soulignement par sa longueur, précédé de ?, SAUF pour le premier.

^./1

Remplacez le premier par le chiffre 1.

En raison du format, cela gère également 0bien: il imprime simplement la chaîne vide.

Swift, 79 75 octets

let f={{$0+$1}((1..<$0).reduce(("1","")){($0.0+" ? \($1+1)",$0.1+" : 0")})}

fest implicitement déclaré comme une fonction avec un Intparamètre qui renvoie unString

Fonctionne avec n >= 1et se bloque lors de l'exécution lorsque n == 0. Il n'y a pas d'espaces de fuite

Edit: Géré pour supprimer 2 * 2 caractères, car l'interpolation de chaîne n'est pas toujours la plus courte

Remarque à modifier: ce code prend une éternité (il ne s'arrête pas) pour être compilé, mais il le serait certainement si le compilateur était capable de le gérer. Jetez un oeil à la version avant cette modification pour en obtenir une qui compile

> <> , 32 + 3 = 35 octets

:l(?vln" ? "ooo0$
"ooo>nl?!;" : 

Notez qu'il y a un espace de fin sur la deuxième ligne. Le +3 est pour le -vdrapeau, par exemple courir comme

$ py -3 fish.py ternary.py -v 2
1 ? 2 : 0

Prendre l'entrée comme un point de code comme

i:l(?vln" ? "ooo0$!
 "ooo>nl?!;" :

est de 34 octets, mais je préfère la version ci-dessus car elle est plus facile à tester et ne gagnera pas de toute façon.

Explication

Il y a pas mal de pseudo-récursivité et d'abus, alors jetons un coup d'œil.

La première ligne imprime la "1 ? 2 ? ... n-1 ? " pièce. La pile commence avec juste l'entrée n, grâce au -vdrapeau, et nous faisons ce qui suit:

:l(?v           If (length of stack + 1 > n), go to the second line
ln              Print the length of the stack
" ? "ooo        Print the reverse of " ? " (but hey, palindromes)
0$              Push 0 and swap, keeping n on top and increasing the 
                length of the stack by 1

> <> est toroïdal, donc ce qui précède s'exécute en boucle jusqu'à ce que la pile se compose de n en haut avec des n-1zéros en dessous, point auquel elle passe à la deuxième ligne.

La première fois que la deuxième ligne est exécutée, l' ninstruction est exécutée, imprimant le nen haut de la pile. Cela ne laisse que les n-1zéros, et nous faisons ce qui suit, également en boucle:

l?!;            If the stack is empty, terminate
" : "ooo        Print the reverse of " : " (but hey, palin...)
n               Print one of the 0s, decreasing the stack's length by 1
                This reuses the same n instruction from before

Scala, 78 71 52 50 octets

def f(n:Int)=(1 to n).mkString(" ? ")+" : 0"*(n-1)

Objective-C, 346 octets

-(void)printTernaryOfInt:(int)ternary{NSMutableString *outString=@"".mutableCopy; for (int i=1;i<=ternary;i++) {[outString appendString:[NSString stringWithFormat:@" ? %i",i]];}[outString deleteCharactersInRange:NSMakeRange(0, 2)];for (int i=1;i<ternary;i++) {[outString appendString:[NSString stringWithFormat:@" : 0"]];}NSLog(@"%@",outString);}

Mettre 0pour le intou quelque chose de négatif soulève une NSRangeExceptionraison de outStringcontenir nil. Cela devrait fonctionner sur iOS 2.0 et versions ultérieures et sur la plupart des dernières versions de Mac OS X.

Une ventilation du code:

-(void)printTernaryOfInt:(int)ternary{ ... }

Déclaration de fonction standard dans Objective-C.

NSMutableString *outString=@"".mutableCopy;

Crée une chaîne de destination pour la sortie outString, et la rend mutable. (En d'autres termes, il peut être lu et écrit.

for (int i=1;i<=ternary;i++) {[outString appendString:[NSString stringWithFormat:@" ? %i",i]];}

Ajoute la première partie de la chaîne à la sortie.

[outString deleteCharactersInRange:NSMakeRange(0, 2)];

Nettoie le début de la chaîne pour s'assurer qu'elle ? 1est remplacée par 1. Remarque: si elle a 0été donnée, c'est là que NSRangeExceptionse produirait, car il n'y a pas d'index 1.

for (int i=1;i<ternary;i++) {[outString appendString:[NSString stringWithFormat:@" : 0"]];}

Ajoute la deuxième partie de la chaîne à la chaîne.

NSLog(@"%@",outString);}

Crache la chaîne en arrière en utilisant NSLoget ferme la fonction.

Production:

La saisie 0donne ce journal de plantage:

    2015-07-11 05:15:28.036 Example App[41665:2134488] *** Terminating app due to uncaught exception 'NSRangeException', reason: '-[__NSCFString deleteCharactersInRange:]: Range or index out of bounds'
*** First throw call stack:
(
    0   CoreFoundation                      0x009b5746 __exceptionPreprocess + 182
    1   libobjc.A.dylib                     0x0063ea97 objc_exception_throw + 44
    2   CoreFoundation                      0x009b566d +[NSException raise:format:] + 141
    3   CoreFoundation                      0x00981813 mutateError + 259
    4   CoreFoundation                      0x009818c1 -[__NSCFString deleteCharactersInRange:] + 65
    5   Example App                         0x000e3785 -[ViewController printTernaryOfInt:] + 277
    6   Example App                         0x000e3645 -[ViewController placeOrder:] + 133
    7   libobjc.A.dylib                     0x006547cd -[NSObject performSelector:withObject:withObject:] + 84
    8   UIKit                               0x00d75a40 -[UIApplication sendAction:to:from:forEvent:] + 99
    9   UIKit                               0x00d759d2 -[UIApplication sendAction:toTarget:fromSender:forEvent:] + 64
    10  UIKit                               0x00eb613a -[UIControl sendAction:to:forEvent:] + 69
    11  UIKit                               0x00eb6557 -[UIControl _sendActionsForEvents:withEvent:] + 598
    12  UIKit                               0x00eb57c1 -[UIControl touchesEnded:withEvent:] + 660
    13  UIKit                               0x00dcdcaa -[UIWindow _sendTouchesForEvent:] + 874
    14  UIKit                               0x00dce786 -[UIWindow sendEvent:] + 792
    15  UIKit                               0x00d8c681 -[UIApplication sendEvent:] + 242
    16  UIKit                               0x00d9cab8 _UIApplicationHandleEventFromQueueEvent + 21484
    17  UIKit                               0x00d702e7 _UIApplicationHandleEventQueue + 2300
    18  CoreFoundation                      0x008d706f __CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE0_PERFORM_FUNCTION__ + 15
    19  CoreFoundation                      0x008ccb7d __CFRunLoopDoSources0 + 253
    20  CoreFoundation                      0x008cc0d8 __CFRunLoopRun + 952
    21  CoreFoundation                      0x008cba5b CFRunLoopRunSpecific + 443
    22  CoreFoundation                      0x008cb88b CFRunLoopRunInMode + 123
    23  GraphicsServices                    0x029e42c9 GSEventRunModal + 192
    24  GraphicsServices                    0x029e4106 GSEventRun + 104
    25  UIKit                               0x00d740b6 UIApplicationMain + 1526
    26  Example App                         0x000e3cfa main + 138
    27  libdyld.dylib                       0x02d76ac9 start + 1
    28  ???                                 0x00000001 0x0 + 1
)
libc++abi.dylib: terminating with uncaught exception of type NSException

1 donne ceci:

2015-07-11 05:06:02.360 Example App[41665:2134488]  1

2 donne ceci:

2015-07-11 05:06:07.613 Example App[41665:2134488]  1 ? 2 : 0

7 donne ceci:

2015-07-11 05:06:12.147 Example App[41665:2134488]  1 ? 2 ? 3 ? 4 ? 5 ? 6 ? 7 : 0 : 0 : 0 : 0 : 0 : 0

200 donne ceci:

2015-07-11 05:06:35.552 Example App[41665:2134488]  1 ? 2 ? 3 ? 4 ? 5 ? 6 ? 7 ? 8 ? 9 ? 10 ? 11 ? 12 ? 13 ? 14 ? 15 ? 16 ? 17 ? 18 ? 19 ? 20 ? 21 ? 22 ? 23 ? 24 ? 25 ? 26 ? 27 ? 28 ? 29 ? 30 ? 31 ? 32 ? 33 ? 34 ? 35 ? 36 ? 37 ? 38 ? 39 ? 40 ? 41 ? 42 ? 43 ? 44 ? 45 ? 46 ? 47 ? 48 ? 49 ? 50 ? 51 ? 52 ? 53 ? 54 ? 55 ? 56 ? 57 ? 58 ? 59 ? 60 ? 61 ? 62 ? 63 ? 64 ? 65 ? 66 ? 67 ? 68 ? 69 ? 70 ? 71 ? 72 ? 73 ? 74 ? 75 ? 76 ? 77 ? 78 ? 79 ? 80 ? 81 ? 82 ? 83 ? 84 ? 85 ? 86 ? 87 ? 88 ? 89 ? 90 ? 91 ? 92 ? 93 ? 94 ? 95 ? 96 ? 97 ? 98 ? 99 ? 100 ? 101 ? 102 ? 103 ? 104 ? 105 ? 106 ? 107 ? 108 ? 109 ? 110 ? 111 ? 112 ? 113 ? 114 ? 115 ? 116 ? 117 ? 118 ? 119 ? 120 ? 121 ? 122 ? 123 ? 124 ? 125 ? 126 ? 127 ? 128 ? 129 ? 130 ? 131 ? 132 ? 133 ? 134 ? 135 ? 136 ? 137 ? 138 ? 139 ? 140 ? 141 ? 142 ? 143 ? 144 ? 145 ? 146 ? 147 ? 148 ? 149 ? 150 ? 151 ? 152 ? 153 ? 154 ? 155 ? 156 ? 157 ? 158 ? 159 ? 160 ? 161 ? 162 ? 163 ? 164 ? 165 ? 166 ? 167 ? 168 ? 169 ? 170 ? 171 ? 172 ? 173 ? 174 ? 175 ? 176 ? 177 ? 178 ? 179 ? 180 ? 181 ? 182 ? 183 ? 184 ? 185 ? 186 ? 187 ? 188 ? 189 ? 190 ? 191 ? 192 ? 193 ? 194 ? 195 ? 196 ? 197 ? 198 ? 199 ? 200 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0 : 0

C, 84 78 octets

C, même s'il n'est pas le plus court, en fonction:

i;f(n){while(++i<n)printf("%i ? ",i);printf("%i",n);while(--i)printf(" : 0");}

Au nom du golf, le intspécificateur de type est laissé de i, fet nparce qu'elle est la valeur par défaut. ipeut être non initialisé car il s'agit d'une variable globale et par défaut à zéro. fne renvoie pas de valeur, mais cela ne provoque qu'un avertissement. printfn'est pas #include'd. Pour exécuter, voici une version complète du programme:

#include <stdio.h>

i;f(n){while(++i<n)printf("%i ? ",i);printf("%i",n);while(--i)printf(" : 0");}

int main(int argc, char *argv[]){
    if(argc != 2){
        return 1;
    }
    f(atoi(argv[1]));
    puts("");
}

C, 63 octets

Fonction réutilisable, prend n comme argument.

i;f(n){for(i=1;i<2*n;i++)printf(i-1?n/i?" ? %d":" : 0":"1",i);}

Non golfé et commenté (assez simple):

int f(int n) {
    int i;

    // 1 ... n, n+1 ... 2n-1
    for(i = 1; i < 2*n; i++) {
        // If i == 1, prints "1"
        // If i <= n, prints " ? %d", i (i = 2 ... n)
        // Else, prints " : 0" (i = n+1 ... 2n-1)
        printf(
            i-1 ?
                n/i ?
                    " ? %d" :
                    " : 0" :
                "1",
        i);
    }
}

Lisp commun, 84

(format t "~{~A ? ~}~@*~{~[~;~:;0~^ ? ~]~}" (loop for i from 1 to (read) collect i))

Tout d'abord, (loop for i from 1 to (read) collect i)génère une liste d'entiers de 1 à tout ce qui est inséré, qui est utilisé comme seul argument de la fonction. Mais la vraie magie réside dans la chaîne de contrôle qui ressemble à du bruit de ligne. "~{~A ? ~}"itère sur la liste entière stockée dans le premier argument, en sortant chaque nombre avec le ?pour la première moitié. ~@*réinitialise la liste d'arguments au premier argument. ~{~[~;~:;0~^ ? ~]~}réitère la liste, produisant 0 ?pour chaque argument consommé, mais ne produisant rien si l'argument est 0 ou 1.