Non paru.
Protégé par la licence CC BY-NC-ND 2.0.
Un jour v… Zut, voilà un accroc. J’aurais dû sortir dans GLMF un long blabla sur ma solution utilisant Python d’un joujou à M. Rubik mais, un jour avant un lundi, un contact sous mon long gros doigt pas droit pour salut malotru a chu, kaputt. Tabarnak, dit-on à Ottawa.
Voici un patois du Python pour cinq moins un scripts n’utilisant pas chr(101).
Allons-y alors pour un baratin un poil moins long sur trois plus un scripts contraints, sans chr(101) ni chr(69). Ils sont traduits pas à pas. Mais Rubik, alors ? Bah, plus tard.
Amusons-nous pour voir jusqu’où on ira (où tu voudras quand tu voudras).
Nous avons à disposition un patois à Python utilisant vingt mots signifiants, pas plus :
Lançons-nous :
class a(): t=lambda truc:truc**2 b=a.t print(b(4))
Mouais, pas concluant. Soyons plus probant, surtout plus original & innovant.
Ouvrons par un FizzBuzz, un pont-aux-ânons courant pour un bizut du Python.
Substituons un produit par trois fois cinq par Fizz Buzz, sinon un produit par trois sans cinq par Fizz, supplantons un produit par cinq sans trois par Buzz & substituons nib si on a un produit ni par trois ni par cinq. Ainsi, nous substituons 30=15×2 par Fizz Buzz, 20=5×4 par Buzz, 18=3×6 par Fizz & 17 par 17.
On doit avoir la disposition à partir d’un : 1, puis 2, puis Fizz, 4, Buzz, Fizz, 7, 8, Buzz, Fizz, 11…
01: #!/usr/bin/python3 02: n=30 03: for i in rang
Caramba. La fonction standard disparaît du script, ainsi qu’un champion du tambour à Spinal Tap au mitan d’un solo.
BrainFuckons un coup pour avoir
01: #!/usr/bin/python3 03: n=30 05: rng=[0] 06: for _ in "1"*n: 07: rng+=[rng[-1]+1]
Comptons nos uns un par un à la 06 puis ajoutons
09: l=[] 10: for i in rng: 11: if i%15==0: 12: l+=["FizzBuzz"] 13: if i%3==0 and i%5: 14: l+=["Fizz"] 15: if i%5==0 and i%3: 16: l+=["Buzz"] 17: if i%3 and i%5: 18: l+=[i] 20: print(*l)
Sans sinon, nous contrôlons tout dans Buzz moins un
Dans un instant, poussons voir l’animal :
> ./fizzbuzz.py FizzBuzz 1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz 16 17 Fizz 19 Buzz Fizz 22 23 Fizz Buzz 26 Fizz 28 29 FizzBuzz Hi hon, l’ânon a franchi un pont. « Ook ! Ook ! » applaudit à un plus Fizz mains l’orang-outang d’Ankh-Morpork ; du haut vol !
Un chouïa plus dur, risquons un look and say du fort connu John Horton Conway, mort par covid-19 un 11 avril.
On dit ainsi qu’on lit : 11 suit 1 car on lit « un 1 ». Donc 1130 suit 1000 car on lit « un 1 trois 0 ». Ayons du soin :112011 suit 1001 mais pas 2021 ni 2120 (là on voudrait Conway, pas Robinson).
Faisons sans fonction, utilisons aussi un truc vu avant dans FizzBuzz mais ici, on fait sans
01: #!/usr/bin/python3 03: r,l=1,10 05: L=[str(r)] 06: las=[r] 08: for _ in "1"*(l-1): 09: lp=[] 10: p=-1
Sans l’instruction sinon non plus, nous utilisons l’infirmation (mais pas la proposition d’Augustus, ni ici, ni plus bas) :
11: for c in L: 12: if c==p: 13: lp[-1][0]+=1 Tant qu’on a un n° kif-kif, on grandit d’un. 14: if c!=p: 15: p=c 16: lp+=[[1,c]]
Sinon, on adjoint un duo tout frais. Voici la justification :
On a à l’initialisation,
Puis
Pour finir,
On adjoint
17: L=[] 18: for p in lp: 19: L+=[str(p[0]),p[1]] 20: las+=["".join(L)] 21: print(*las)
Lançons ça dans un
> ./lookandsay.py 1 11 21 1211 111221 312211 13112221 1113213211 31131211131221 13211311123113112211
On a dix mots dits : « un », « un un… », à la fin, « un trois… » Nous avons produit un bout d’A005150, nous voilà rompu à un dur travail d’obligation.
Attrapons un raton qui court sous l’agropyrum dans un champ, car il a faim.
Choisissons nos graduations s’ouvrant par 1 jusqu’à n. Posons l’amaigri raton sur n. Il court sur 1, puis sur n−1, puis sur 2, puis sur n−3… tournicotant jusqu’au noyau.
Si n=6, il parcourt ainsi 6, 1, 5, 2, 4, 3. On voit alors un limaçon fort gidouillant qu’Ubu a sur son rond bidon.
Fig. 1 Limaçon pour n=6.
Joli, non ? Non ? Ah si !
Mais alors, un n° à Quayno ? Racontons-ça.
Adoptons n=1.
Si n≠1, rabâchons n fois l’action du raton :
On doit mouvoir tous nos n° sans condition. Or si n=4, au rang 1, on a 4, 1, 3, 2 mais on n’a pas mû 3 donc nous abandonnons n=4.
On doit avoir 1, 2, 3, … ,n au rang n tout rond. Or si n=7, au rang 7, on a 2, 4, 6, 7, 5, 3, 1 mais pas 1, 2, 3, 4, 5, 6, 7 (qu’on a pourtant au rang 8 & avant au rang 4). Trop tard & trop tôt à la fois.
Mais pas avant non plus. Or si n=8, au rang 4 (& 8 aussi), on a 1, 2, 3, 4, 5, 6, 7, 8. Trop tôt.
Si nos trois conditions sont OK, nous avons un n° à Quayno.
01: #!/usr/bin/python3
03: from sys import argv
05: nsmbl=lambda l:{i for i in l}
06: long=lambda l:sum(l.count(c) for c in nsmbl(l))
Pour tout chaînon
08: l=long(argv) 09: if l!=2: 10: m=40 11: if l==2: 12: m=int(argv[1]) 14: rng=[0] 15: for _ in "1"*(m+1): 16: rng+=[rng[-1]+1] 18: rang=lambda n:rng[:n] 19: rang2=lambda m,n:rng[m:n]
Ici, nous voulons avoir
21: suivant=lambda p: [[p[-1-i//2],p[(i-1)//2]][i%2] for i in rang(long(p))]
Si
Sinon,
| 0 | 1 | 2 | 3 | 4 | 5 | |
| 1 | 2 | 3 | 4 | 5 | 6 | |
| 0 | 1 | 0 | 1 | 0 | 1 | |
| −1 soit ici 5 | −2 soit 4 | −3 càd 3 | ||||
| (i−1)//2 | 0 | 1 | 2 | |||
| 6=p[5] | 1=p[0] | 5=p[4] | 2=p[1] | 4=p[3] | 3=p[2] |
Nous avons la disposition 6 puis 1, puis 5, puis 2, puis 4, puis 3.
Continuons 6 fois :
| pas | disposition | |||||
|---|---|---|---|---|---|---|
| 0 | 1 | 2 | 3 | 4 | 5 | 6 |
| 1 | 6 | 1 | 5 | 2 | 4 | 3 |
| 2 | 3 | 6 | 4 | 1 | 2 | 5 |
| 3 | 5 | 3 | 2 | 6 | 1 | 4 |
| 4 | 4 | 5 | 1 | 3 | 6 | 2 |
| 5 | 2 | 4 | 6 | 5 | 3 | 1 |
| 6 | 1 | 2 | 3 | 4 | 5 | 6 |
On a l’initial au rang n=6, pas avant.
Nos trois conditions sont là, nous avons donc un n° à Quayno.
23: q=[] 24: for n in rang2(1,m+1): 25: p=rang2(1,n+1) 26: p0=list(p) 28: prmutation=[] 29: for _ in rang(n): 30: p=suivant(p) 31: prmutation+=[p] 33: s=suivant(p0) 34: if n==1 or (p==p0 and \ 35: all(p0[i]!=s[i] for i in rang(n)) and \ 36: p0 not in prmutation[:-1]): 37: q+=[n] 38: print(*q)
Au rang n tout rond, on a l’initial (n° 34), mais pas avant (n° 36), &
> ./qunau.py 40 1 2 3 5 6 9 11 14 18 23 26 29 30 33 35 39
Nous avons conçu nos constituants d’A054639 (n° à Quayno) d’un jusqu’à quasi cinq fois huit.
Voici pour finir un script qui dit si un baratin normal ou parcouru par la fin sont grosso-modo voisins.
01: #!/usr/bin/python3
03: from sys import stdin
05: taux=lambda rr,ch:100-rr/long(ch)*100
07: nsmbl=lambda l:{i for i in l}
08: long=lambda l:sum(l.count(c) for c in nsmbl(l))
Tout ça là-haut, on connaît.
10: baratin=input() 12: rng=[0] 13: for _ in "1"*1000: 14: rng+=[rng[-1]+1] 16: rang=lambda n:rng[:n]
Ça aussi, on a vu.
18: f=chr(101)
19: trans={chr(i+32):chr(i+32) for i in rang(96)}
20: for i in rang(26):
21: trans[chr(65+i)]=chr(97+i)
23: for i,c in [(chr(198),"a"+f),(chr(200),f),(chr(201),f),(chr(202),f),(chr(203),f),(chr(338),"o"+f),
24: (chr(230),"a"+f),(chr(232),f),(chr(233),f),(chr(234),f),(chr(235),f),(chr(339),"o"+f)]:
25: trans[i]=c
26: for a in "ÀÁÂÃÄÅàáâãäå":
27: trans[a]="a"
# plions là dix plus trois fois pour c, i, n, o, u & y, on voit pourquoi
À partir du 18, intonations, ponctuation ou tildas sont aplanis. Sans ça, « Port-salut » & « Tu l’as trop » sont distincts, « Sato » & « ôtas » itou.
41: palindrom="".join(trans[c] for c in baratin) 43: alpha=[i for i in rang(long(baratin)) if baratin[i].isalpha()]
Là on a la position pour savoir plus loin si on a un baratin plus ou moins concordant lu par la fin ou non.
44: abus=[" "]*long(baratin)
45: for i in rang(long(alpha)//2):
46: if palindrom[alpha[i]]!=palindrom[alpha[-1-i]]:
47: abus[alpha[i]]="^"
48: abus[alpha[-i-1]]="^"
49: nbabus=abus.count("^")
Ici on voit tous nos abus fortuits trahis par un galurin chinois (un v qui a subi la rotation à 180°). Voir plus bas sur fond noir.
51: chaîn="".join(c for c in palindrom if c.isalpha())
52: print(baratin)
53: if nbabus:
54: print("".join(abus))
55: print("On a %d abus."%(nbabus//2))
56: print("Satisfaction : %.2f %%"%taux(nbabus,chaîn))
57: if not nbabus:
58: print("Parfait ! Aucun abus.")
Bilan du script :
> cat << FDF >palin.txt > Agonir rabota ! > FDF > ./lipodrom.py < palin.txt agonir rabota ! ^ ^^ ^^ ^ On a 3 abus. Satisfaction : 50.00 %
Trois abus car on trois duplicatas, ainsi g & t sont inclus 1 fois & non 2. Pourtant, la satisfaction vaut 50%…
> cat << FDF >palin.txt > Un as noir si mou qu'omis rions à nu ! > FDF > ./lipodrom.py <palin.txt > Un as noir si mou qu'omis rions à nu ! > Parfait ! Aucun abus.
Là, on n’a aucun abus ; louons La disparition p. 156.
Nous arrivions à la fin. Mais pourquoi tout ça ? Pour la distraction : nous nous plaçons dans un lacis au hauts murs & nous tâchons d’aboutir au portail final, ainsi qu’un rat ayant choisi son fatum.
Nous y voilà, finissons donc par un ch’tit madrigal qui tord un format connu à l’Oulipo.
Faux soli Cython
J’ai fait sans un gros bout du standard à Python. J’irai à l’hôpital aux murs à capitons. Qu’à Python ?
Ils font aussi du C contraint sans
Pourquoi pas du Python comptant moult