Imprimer une arche de nombres ascendants / descendants

28

J'ai pensé qu'un "arc" était la meilleure façon de décrire ce modèle de nombres:

1234567887654321
1234567  7654321
123456    654321
12345      54321
1234        4321
123          321
12            21
1              1

Formellement définie, chaque ligne se compose des nombres 1 à 9-n, des (n-1)*2espaces et des nombres 9-nà 1 (où nest la ligne actuelle).

Votre tâche consiste à écrire, en utilisant le code le plus court possible, un petit script / programme qui imprime le modèle ci-dessus soumis aux restrictions suivantes:

  1. Vous ne pouvez pas coder en dur le motif entier. Vous ne pouvez coder en dur qu'une seule ligne du modèle au maximum.
  2. Votre programme doit imprimer une nouvelle ligne (toute combinaison de \nou \r) à la fin de chaque ligne.

Prêt ... prêt ... partez!

code-golf  ascii-art  number  kolmogorov-complexity 
— Nathan Osman
source
1
Une petite astuce supplémentaire serait disponible avec la ligne supérieure 123456787654321car elle est égale à 11111111^2 ;-)
— Egor Skriptunoff
3
@EgorSkriptunoff 11111111^2 == 123465787654321 != 1234567887654321(remarquez la répétition 8)
— Bob
C'est en quelque sorte l'inverse de Imprimer ce diamant
— Peter Taylor
6
Cela ressemble plutôt à un rideau .
— Volatilité

Réponses:

22

Python 2, 65 55 53 51

s=12345678
while s:r='%-8d'%s;print r+r[::-1];s/=10

Raccourci en utilisant certaines des idées d' Ugoren .

— Volatilité
source
Hé, je savais qu'il y avait matière à amélioration: P
— Nathan Osman
2
Vous pouvez économiser beaucoup s=s[1:]par boucle etwhile s:
— ugoren
9

APL (18) 

k,⌽k←↑↑∘(1↓⎕D)¨⌽⍳8

Explication:

  • 1↓⎕D: la chaîne de chiffres ("0123456789") moins son premier élément
  • ↑∘(1↓⎕D)¨⌽⍳8: sélectionnez les premiers [8..1] caractères ('12345678', '1234567' ...)
  • ↑: formater comme matrice (remplir les caractères non utilisés avec des blancs)
  • k,⌽k←: stockage ket affichage ksuivis de la mise en miroir verticale dek
— marinus
source
4

Rubis: 61 50 caractères

s="87654321";s.chars{|c|puts s.reverse+s;s[c]=" "}

Exemple d'exécution:

bash-4.2$ ruby -e 's="87654321";s.chars{|c|puts s.reverse+s;s[c]=" "}'
1234567887654321
1234567  7654321
123456    654321
12345      54321
1234        4321
123          321
12            21
1              1
— homme au travail
source
4

Befunge - 3 x 18 = 54

Je sentais que je devais faire quelque chose avec befunge, ça faisait trop longtemps que je ne l'avais pas utilisé. Ce problème semblait le plus approprié pour la langue.

Il est horriblement lent en raison de la boucle d'impression qui prend environ 8 actions par caractère (les styles de comptage diffèrent). 

80v >#v"12345678"<
>5 *^ >,#$:_$:1-:v
^2< 0p0+7\*48\_@#<
— shiona
source
4

JavaScript, 71

s='1234567887654321',i=10;while(--i)console.log(s=s.split(i).join(' '))
— steveworley
source
s="1234567887654321";for(i=10;--i;)console.log(s=s.split(i).join(" "))pour 70 caractères, @SteveWorley
— WallyWest
3

C, 83 caractères

main(a,b,n){
    for(a=12345678,n=1e8,b=n-a-1;a;a/=10)
        printf("%-8d%8d\n",a,b),
        b%=n/=10;
}
— ugoren
source
3

Python 2, 75 62

Cela ne battra pas la réponse de Volatility, mais voici une autre approche utilisant les chaînes mutables de python ( bytearray):

s=bytearray('1234567887654321')
for i in range(8):s[8-i:8+i]=i*'  ';print s

modifier

J'ai trouvé une version plus courte, en utilisant str.replace:

s='1234567887654321'
for c in s[8:]:print s;s=s.replace(c,' ')
— Baptiste M.
source
3

Perl, 41

plus -Einterrupteur. Nombre total de caractères sur la ligne de commande: 50

nécessite au moins perl5, version 10.

perl -E'say@!=1..8-$_,$"x(2*$_),reverse@!for-0..7'
— amon
source
Je dirais que c'est 42, car le look standard -Eest un ajout d'un octet au programme.
— Timtech
3

Mathematica 92 85 67 54 51

Méthode n ° 1 : (54 caractères) Crée un tableau en utilisant la ligne #, le col # et la distance à partir du bord gauche-droite.

Grid@Array[If[#2<9,#2,17-#2]/.x_/;x+#>9:>" "&,{8,16}]

Méthode n ° 2 : (67 caractères) Remplissez les plages toujours plus courtes.

Print@@@Table[Join[k = PadRight[Range@i, 8, " "], Reverse@k], {i, 8, 1, -1}];

Méthode n ° 3 : (85 caractères) Remplissez sélectivement chaque ligne d'un tableau.

Commencez par une liste de 8 caractères d'espace. Remplacez les positions 1 et 16 par "1"; remplacer "2" aux positions 2 et 15, etc.

p = 0; q = 16;
Print @@@Reverse@Rest@NestList[ReplacePart[#, {++p -> p, q-- -> p}]&,Array[" "&,q], 8];

Méthode n ° 4 : (86 caractères) Videz sélectivement chaque ligne d'un tableau.

p=8;q=9;
Print@@@NestList[ReplacePart[#,{p---> " ",q++-> " "}]&,Join[k=Range@8,Reverse@k],7];

Méthode n ° 5 : utilisation de chaînes (92 caractères)

p=8;s="12345678";
Print[#,StringReverse@#]&/@NestList[StringReplace[#,ToString@p-- ->  " "]&,s,7];
— DavidC
source
Ce nouveau est lisse! Je ferais +1 à nouveau si je le pouvais. :-) btw, vous pouvez supprimer le (), et le remplacer #1par #:Grid@Array[If[#2<9,#2,17-#2]/.x_/;x+#>9:>" "&,{8,16}]
— Mr.Wizard
Merci pour les conseils. Oui, Arraypeut parfois faire de belles tables sans avoir à ajouter d'itérateurs.
— DavidC
3

PHP, 68

(Inspiré par la réponse de HamZa)

for($n=8;$n;$r[]=$n--)echo str_replace($r," ","1234567887654321\n");

Joue sur le fait que str_replace de PHP peut accepter un tableau pour la recherche et une chaîne pour le remplacer, il remplacera chaque élément du tableau par la chaîne donnée. Après chaque itération, le numéro actuel est ajouté au tableau de recherche, le supprimant de la boucle suivante.

Exemple de code en action: http://ideone.com/9wVr0X

— M. Llama
source
hehe nice +1
— HamZa
ne semble pas mettre le bon nombre d'espaces au milieu
— nathan hayfield
@nathanhayfield: Comment ça? La première ligne a 0 espaces, la seconde 2, puis 4, 6, 8, etc.
— M. Llama
pas quand je l'ai exécuté sur writecodeonline.com/php
— nathan hayfield
C'est parce que la sortie n'était pas encapsulée dans des <pre>balises. Lorsqu'ils sont interprétés comme du texte html, les espaces sont réduits et les sauts de ligne sont ignorés, mais si vous vérifiez la source, vous verrez le contraire.
— M. Llama
3

Marbelous 165

@0
08
>0
LN
--
@0
:LN
}0}0}0}0
..SAPSSD0A
{0
:PS
}0
~~09
..//
<<@0
\\>0
&0//
--@1
@020
&0/\&0
@1
:SA
@0
}0
>0!!
--00@1
@0++//
+O/\@1
+O
:SD
}0@0
\\>0\/
--/\+O
@0..+O

Pseudocode:

MB():
    for x in 8..1:
        LN(x)
LN(x):
    SA(x)
    PS(x)
    SD(x)
    print "\n"
PS(x):
    print " "*(8-x)*2
SA(x):
    for n in 1..x:
        print n
SD(x):
    for n in x..1:
        print n
— Sparr
source
2

Python 2.x - 73 65 63 61 caractères

c=1;s='87654321'
while c<9:print s[::-1]+s;s=' '*c+s[c:];c+=1
— TerryA
source
2

PHP, 76

for($i=9;$i>1;){$r[]=$i--;echo str_replace($r,' ','1234567887654321')."\r";}
— HamZa
source
2

K, 28

-1_a,'|:'a:8$'{-1_x}\,/$1+!8

.

k)-1_a,'|:'a:8$'{-1_x}\,/$1+!8
"1234567887654321"
"1234567  7654321"
"123456    654321"
"12345      54321"
"1234        4321"
"123          321"
"12            21"
"1              1"

Vous pouvez le généraliser pour 36: {-1_a,'|:'a:(#*m)$'m:{-1_x}\,/$1+!x}

k){-1_a,'|:'a:(#*m)$'m:{-1_x}\,/$1+!x} 5
"1234554321"
"1234  4321"
"123    321"
"12      21"
"1        1"
q)k){-1_a,'|:'a:(#*m)$'m:{-1_x}\,/$1+!x} 15
"123456789101112131415514131211101987654321"
"12345678910111213141  14131211101987654321"
"1234567891011121314    4131211101987654321"
"123456789101112131      131211101987654321"
"12345678910111213        31211101987654321"
"1234567891011121          1211101987654321"
"123456789101112            211101987654321"
"12345678910111              11101987654321"
"1234567891011                1101987654321"
"123456789101                  101987654321"
"12345678910                    01987654321"
"1234567891                      1987654321"
"123456789                        987654321"
"12345678                          87654321"
"1234567                            7654321"
"123456                              654321"
"12345                                54321"
"1234                                  4321"
"123                                    321"
"12                                      21"
"1                                        1"
— tmartin
source
2

Javascript, 67 caractères

Inspiré par la réponse de steveworley (je commenterais si je pouvais):

Extrait de code

a='1234567887654321\n',b='',c=10;while(--c)b+=a=a.split(c).join(' ')
<a href="#" onclick="javascript:document.getElementById('output').innerHTML = b;">Display</a>
<pre id="output">...</pre>
Développer l'extrait

La présence de la dernière nouvelle ligne suit les règles.

mise à jour: couper 2 caractères en supprimant les parenthèses (priorité de l'opérateur) et 1 en supprimant un espace inutile

Il me semblait que ça me trollait, car peu importe combien de façons différentes j'ai essayé de raccourcir ou de simplifier en décodant un segment de code, la longueur est restée la même jusqu'à ce que je laisse la règle "Je pense que cela compte" écrite ci-dessous s'appliquer.

(Si l'impression compte comme ce qui revient quand cela est exécuté dans la console chrome)

— Sophiα2329
source
Cela ne ressemble pas à l'autre réponse, les chiffres ne sont pas alignés sur la colonne de droite.
— AL
@AL L'alerte n'est pas nécessaire si vous lisez quelle sortie sort de la consonne btw.
— Sophiα2329
Pour aligner la colonne de droite, il doit y avoir 1 espace au lieu de 2 dans l'argument de chaîne de jointure. Avec 2 espaces, il est correctement aligné dans une alerte de navigateur basée sur Chrome.
— Qwertiy du
J'ai mis à jour votre message (la modification doit être acceptée) pour afficher le résultat dans un extrait de code sans alerte JS, un seul espace est nécessaire dans ce cas.
— AL
2

Brainfuck: 542 octets

-[----->+<]>--.+.+.+.+.+.+.+..-.-.-.-.-.-.-.>++++++++++.[->+++++
<]>-.+.+.+.+.+.+.+[-->+<]>++++..----[->++<]>-.-.-.-.-.-.-.>++++++++++.[->+++++
<]>-.+.+.+.+.+.[-->+<]>+++++....-----[->++<]>.-.-.-.-.-.>++++++++++.[->+++++
<]>-.+.+.+.+.--[--->++<]>--......-----[->++<]>-.-.-.-.-.>++++++++++.[->+++++
<]>-.+.+.+.-[--->++<]>--........++[-->+++<]>+.-.-.-.>++++++++++.[->+++++
<]>-.+.+.[--->++<]>--..........++[-->+++<]>.-.-.>++++++++++.[->+++++
<]>-.+.--[--->++<]>............[-->+++<]>++.-.>++++++++++.[->+++++
<]>-.-[--->++<]>..............[-->+++<]>+.
— NaCl
source
1

Mathematica , 59

61 en utilisant mes propres idées:

Grid[Clip[#~Join~Reverse@#&@Range@8,{1,9-#},{," "}]&~Array~8]

Ou 59, empruntant à la réponse de David:

Grid@Array[Join[k=PadRight[Range[9-#],8," "],Reverse@k]&,8]
— Mr.Wizard
source
Je viens d'enregistrer 4 caractères en utilisant Grid, inspiré par votre entrée.
— DavidC
1

R: 52

for(i in 8:1)cat(1:i,rep(" ",16-2*i),i:1,"\n",sep="")
— flodel
source
1

Haskell, 84

Un point de départ pour que quelqu'un s'améliore:

mapM_ putStrLn[let l=take(8-i)"12345678"++replicate i ' 'in l++reverse l|i<-[0..7]]

La partie la plus probable serait de faire valoir le l++reverse lpoint gratuitement, nous permettant de nous débarrasser de la letdéclaration, mais je pourrais trouver que c'était ap, ce qui nécessite des importations.

— shiona
source
1

PostScript: 105 caractères

La gestion des chaînes n'est pas facile dans PS mais peut rendre le code relativement simple:

0 1 7{(1234567887654321)dup
8 3 index sub(              )0 6 -1 roll 2 mul getinterval putinterval =}for

Une version légèrement plus longue à 120 caractères mais peut générer des arcs numériques différents en remplaçant le 8 au début de la deuxième ligne par un nombre compris entre 1 et 9:

/D{dup}def/R{repeat}def/P{=print}def
8 D -1 1{1 1 index{D P 1 add}R pop 2 copy sub{(  )P}R D{D P 1 sub}R pop()=}for pop
— MrMRDubya
source
C'est agréable de voir que je ne suis pas le seul à aimer PostScript.
— AJMansfield
1

GoRuby 2.1

36 caractères

8.w(1){|x|a=[*1..x].j.lj 8;s a+a.rv}

Non golfé

8.downto(1) do |x|
  a = [*1..x].join.ljust(8)
  puts a + a.reverse
end
— Patrick Oscity
source
1

K 20

{x,'|:'x:|x$,\$1+!x}    

q)k){x,'|:'x:|x$,\$1+!x}8    
"1234567887654321"    
"1234567  7654321"    
"123456    654321"    
"12345      54321"    
"1234        4321"      
"123          321"    
"12            21"    
"1              1"
— ppp
source
1

TSQL, 148

Edit: jusqu'à 148 avec la suggestion de manatwork et ajustez à ORDER BY.

Lisible:

WITH t AS(
    SELECT 1n, CAST(1 AS VARCHAR(MAX)) o
 UNION ALL
    SELECT n+1,o+CHAR(n+49)
    FROM t
    WHERE n<8
)
SELECT o  + SPACE(16-2*n) + REVERSE(o)
FROM t
ORDER BY 1 DESC

Golfé:

WITH t AS(SELECT 1n,CAST(1AS VARCHAR(MAX))o UNION ALL SELECT 1+n,o+CHAR(n+49)FROM t WHERE n<8)SELECT o+SPACE(16-2*n)+REVERSE(o)FROM t ORDER BY 1DESC

Sortie:

1234567887654321
1234567  7654321
123456    654321
12345      54321
1234        4321
123          321
12            21
1              1
— comfortablydrei
source
1
Joli. Mais pourriez-vous s'il vous plaît l'afficher également dans le format dans lequel vous avez compté 153 caractères? Quoi qu'il en soit, vous pouvez épargner 2 caractères à l'aide numérique au 1lieu de chaîne '1'où vous immédiatement castdans varchar. Cela me donne 149 caractères: with t as(select 1n,cast(1as varchar(max))o union all select n+1,o+char(n+49)from t where n<8)select o+space(16-2*n)+reverse(o)from t order by o desc.
— manatwork
@manatwork: Je n'ai pas pu reproduire le nombre 153, car je continuais à baisser. Appliqué votre suggestion, cependant. Merci!
— comfortablydrei
1

Haskell, 79

r n x|x>n=' '|True=x
t="87654321"
main=mapM(putStrLn.(`map`("12345678"++t)).r)t

Cela fonctionne en remplaçant les caractères> n par ' ', où les caractères n proviennent de "87654321" (qui se trouve être la queue de la chaîne pour effectuer la substitution).

— Joey Adams
source
1

PHP: 61 caractères (ou 60 caractères si vous remplacez le \ n par un véritable saut de ligne ASCII)

(Inspiré par la réponse de GigaWatt et HamZa)

for($n=9;$n;$r[$n--]=" ")echo strtr("1234567887654321\n",$r);

http://ideone.com/FV1NXu

— bwoebi
source
1

PowerShell: 38

Code golf

8..1|%{-join(1..$_+"  "*(8-$_)+$_..1)}

Procédure pas à pas

8..1|%{... }canalisez les entiers de 8 à 1 dans une boucle ForEach-Object.
-join(... )joint la sortie du code imbriqué en une seule chaîne sans délimiteurs.
1..$_renvoie des entiers allant de 1 à l'entier courant dans la boucle.
+" "*(8-$_)ajoute un double espace, multiplié par la différence entre 8 et l'entier courant, à la sortie.
+$_..1ajoute des entiers, descendant de l'entier courant à 1, à la sortie.

— Iszi
source
1

Javascript avec lambdas, 147

(s="12345678")[r="replace"](/./g,i=>s[r](RegExp(".{"+(i-1)+"}$"),Array(i*2-1).join(" ")))[r](/\d{1,8} */g,m=>m+(Array(m%10+1).join(m%10+1)-m)+"\n")

Peut être vérifié dans Firefox.

— Qwertiy
source
1

CJam, 22 caractères

Pas une réponse valide (car le langage a été développé après la question), et pas le plus court non plus, mais voici:

8,{S*_,9-~,:)\_2$W%N}%

Essayez-le en ligne ici

— Optimiseur
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.